Bump filelock from 4.0.3 to 4.0.4

Bumps [filelock](https://github.com/tox-dev/py-filelock) from 4.0.3 to 4.0.4. - [Release notes](https://github.com/tox-dev/py-filelock/releases) - [Changelog](https://github.com/tox-dev/filelock/blob/main/docs/changelog.rst) - [Commits](https://github.com/tox-dev/py-filelock/compare/4.0.3...4.0.4) --- updated-dependencies: - dependency-name: filelock dependency-version: 4.0.4 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>
Merge branch 'release' into dev
2026-10-15 02:32:49 +00:00 · 2026-09-29 19:22:44 +00:00 · 2026-09-30 08:13:38 +13:00 · 2026-09-29 20:12:00 +01:00 · 2026-09-29 13:58:12 -04:00 · 2026-09-29 19:55:22 +02:00
411 changed files with 16780 additions and 5086 deletions
@@ -0,0 +1,39 @@
+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 FRAMEWORK_RELEASES, TOOLCHAIN_VERSION as t; print(f"{FRAMEWORK_RELEASES[f].tag}-{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 }}
@@ -19,6 +19,7 @@ on:
      - "esphome/core/**"
      - "esphome/writer.py"
      - "esphome/build_gen/**"
+      - "esphome/build_helpers/**"
      - "esphome/espidf/**"
      - "esphome/platformio/**"
      - "esphome/components/bk72xx/**"
@@ -195,6 +196,7 @@ jobs:
        # the default.
        id:
          - esp8266-arduino
+          - esp8266-arduino-native
          - esp32-arduino-platformio
          - esp32-arduino-esp-idf
          - esp32-idf-platformio
@@ -102,6 +102,8 @@ 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 }}
@@ -165,6 +167,8 @@ 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
@@ -183,6 +187,33 @@ 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
@@ -369,14 +400,9 @@ jobs:
      matrix:
        bucket: ${{ fromJson(needs.determine-jobs.outputs.integration-test-buckets) }}
    env:
-      # 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
+      # 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
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -396,14 +422,13 @@ jobs:
        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.13"
-      - 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
+      - name: Restore integration library cache
+        # A miss or a changed pin self-heals with a download, so no restore-keys
+        id: library-cache
        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
-          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') }}
+          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') }}
      - name: Restore Python virtual environment
        id: cache-venv
        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
@@ -471,16 +496,16 @@ jobs:
          # A full cron period of margin for the weekly refresh
          retention-days: 14
      - name: Print ccache statistics
-        # 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
+        # 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
        # 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.pio-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.library-cache.outputs.cache-hit != 'true'
        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
-          path: ${{ env.INTEGRATION_PIO_CACHE_PATH }}
-          key: ${{ steps.pio-cache.outputs.cache-primary-key }}
+          path: ${{ env.INTEGRATION_LIBRARY_CACHE_PATH }}
+          key: ${{ steps.library-cache.outputs.cache-primary-key }}

  import-time:
    name: Check import esphome.__main__ time
@@ -1097,6 +1122,11 @@ 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
@@ -1196,8 +1226,20 @@ jobs:
          if [ -n "$compile_csv" ]; then
            # Run compilation with grouping and isolation
            python3 script/test_build_components.py -e compile -c "$compile_csv" -f --isolate "$directly_changed_csv"
+            if [[ "${{ matrix.batch.check_idf_py }}" == "true" ]]; then
+              # The real idf.py must find nothing to configure or build in a
+              # tree built above; catches drift on ESP-IDF bumps.
+              echo "Checking the native ESP-IDF build matches idf.py"
+              python3 script/check_idf_py_equivalence.py
+            fi
          else
            echo "All components in this batch are validate-only -- skipping compile stage."
+            if [[ "${{ matrix.batch.check_idf_py }}" == "true" ]]; then
+              # determine-jobs and this step disagree on what compiles; fail
+              # rather than let the check run nowhere.
+              echo "::error::This batch was picked for the idf.py check but compiled nothing"
+              exit 1
+            fi
          fi

      - name: Print ccache statistics
@@ -1237,7 +1279,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
+          python3 script/test_build_components.py -e compile -t esp32-idf -c "$TEST_COMPONENTS" -f --toolchain platformio --fail-on-no-tests

          echo ""
          echo "ESP-IDF-via-PlatformIO build passed! Starting Arduino smoke test..."
@@ -1246,6 +1288,40 @@ 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
@@ -1415,12 +1491,9 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}

-      - 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: 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: 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'
@@ -1505,11 +1578,9 @@ jobs:
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
-      - 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: Cache the native ESP8266 toolchain
+        if: fromJSON(needs.determine-jobs.outputs.memory_impact).needs_arduino8266
+        uses: ./.github/actions/cache-arduino8266
      - name: Build, compile, and analyze memory
        id: extract
        run: |
@@ -1608,6 +1679,7 @@ jobs:
    needs:
      - common
      - seed-apt-cache
+      - seed-esp8266-native-cache
      - determine-jobs
      - ci-custom
      - pylint
@@ -1623,6 +1695,7 @@ 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@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
        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@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
        with:
          category: "/language:${{matrix.language}}"
@@ -10,7 +10,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.16.8
+    rev: v0.16.9
    hooks:
      # Run the linter.
      - id: ruff
@@ -18,7 +18,7 @@ repos:
      # Run the formatter.
      - id: ruff-format
  - repo: https://github.com/PyCQA/flake8
-    rev: 7.3.0
+    rev: 7.4.1
    hooks:
      - id: flake8
        additional_dependencies:
@@ -322,6 +322,25 @@ 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).
@@ -125,6 +125,7 @@ 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
@@ -22,7 +22,7 @@ RUN \
    -r /requirements.txt

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

 RUN \
    platformio settings set enable_telemetry No \
@@ -21,10 +21,14 @@ export PLATFORMIO_PLATFORMS_DIR="${pio_cache_base}/platforms"
 export PLATFORMIO_PACKAGES_DIR="${pio_cache_base}/packages"
 export PLATFORMIO_CACHE_DIR="${pio_cache_base}/cache"

-# Keep the native toolchain installs on the persistent cache root, not the
-# container's ephemeral user cache dir (re-downloaded on every restart).
+# Keep the native toolchain installs and compiler caches on the persistent
+# cache root, not the container's user cache dir: it is lost on every
+# restart, and not writable when the container runs as a non-root user.
 export ESPHOME_ESP_IDF_PREFIX="$(dirname "${pio_cache_base}")/idf"
 export ESPHOME_SDK_NRF_PREFIX="$(dirname "${pio_cache_base}")/sdk-nrf"
+export ESPHOME_ARDUINO8266_PREFIX="$(dirname "${pio_cache_base}")/arduino8266"
+export ESPHOME_HOST_PREFIX="$(dirname "${pio_cache_base}")/host"
+export ESPHOME_PLATFORMIO_CCACHE_DIR="$(dirname "${pio_cache_base}")/platformio-ccache"

 # If /build is mounted, use that as the build path
 # otherwise use path in /config (so that builds aren't lost on container restart)
@@ -15,10 +15,14 @@ export PLATFORMIO_PLATFORMS_DIR="${pio_cache_base}/platforms"
 export PLATFORMIO_PACKAGES_DIR="${pio_cache_base}/packages"
 export PLATFORMIO_CACHE_DIR="${pio_cache_base}/cache"

-# Keep the native toolchain installs on the persistent /data volume, not the
-# container's ephemeral user cache dir (wiped on every add-on update/restart).
+# Keep the native toolchain installs and compiler caches on the persistent
+# /data volume, not the container's ephemeral user cache dir (wiped on every
+# add-on update/restart).
 export ESPHOME_ESP_IDF_PREFIX=/data/cache/idf
 export ESPHOME_SDK_NRF_PREFIX=/data/cache/sdk-nrf
+export ESPHOME_ARDUINO8266_PREFIX=/data/cache/arduino8266
+export ESPHOME_HOST_PREFIX=/data/cache/host
+export ESPHOME_PLATFORMIO_CCACHE_DIR=/data/cache/platformio-ccache

 if bashio::config.true 'leave_front_door_open'; then
    export DISABLE_HA_AUTHENTICATION=true
@@ -0,0 +1,8 @@
+esphome:
+  name: docker-test-esp8266-native
+
+esp8266:
+  board: d1_mini
+  toolchain: arduino
+
+logger:
@@ -3,5 +3,7 @@ esphome:

 esp8266:
  board: d1_mini
+  # The PlatformIO path stays covered whatever the default is
+  toolchain: platformio

 logger:
@@ -16,7 +16,7 @@ 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 native_backend
+from esphome.build_helpers.native import analysis_backend, native_backend
 from esphome.const import (
    ALLOWED_NAME_CHARS,
    ARGUMENT_HELP_DEVICE,
@@ -838,7 +838,7 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:

    # Keep this here, NOT in codegen: config-hash and --only-generate must keep
    # working on machines that cannot run the toolchain.
-    if CORE.is_esp8266:
+    if CORE.is_esp8266 and CORE.using_toolchain_platformio:
        from esphome.components.esp8266 import check_rosetta

        check_rosetta()
@@ -1714,26 +1714,12 @@ 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'", _host_program_path(config)
-        )
+        _LOGGER.info("Successfully compiled program to path '%s'", CORE.firmware_bin)
    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(
@@ -1778,7 +1764,7 @@ def command_run(args: ArgsProtocol, config: ConfigType) -> int | None:
        return exit_code
    _LOGGER.info("Successfully compiled program.")
    if CORE.is_host:
-        program_path = _host_program_path(config)
+        program_path = str(CORE.firmware_bin)
        _LOGGER.info("Running program from path '%s'", program_path)
        return run_external_process(program_path)

@@ -2015,8 +2001,8 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
    from esphome.analyze_memory.ram_strings import RamStringsAnalyzer

    # Refuse an unsupported toolchain before paying for a full compile
-    native_toolchain = native_backend()
-    if native_toolchain is None and not CORE.using_toolchain_platformio:
+    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",
@@ -2024,6 +2010,11 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
            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)
@@ -2036,9 +2027,9 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:

    # Get idedata for analysis
    idedata = None
-    if native_toolchain is not None:
-        objdump = native_toolchain.get_objdump_path()
-        readelf = native_toolchain.get_readelf_path()
+    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
@@ -2052,7 +2043,7 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
        objdump_path = str(objdump)
        readelf_path = str(readelf)

-        firmware_elf = native_toolchain.get_elf_path()
+        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
@@ -2376,7 +2367,8 @@ def parse_args(argv):
        metavar="{" + ",".join(t.value for t in Toolchain) + "}",
        help=(
            "Select toolchain for compiling. Overrides '<platform>.toolchain' in YAML. "
-            f"Default: {Toolchain.PLATFORMIO.value}."
+            "Default: the platform's native toolchain where it has one, else "
+            f"{Toolchain.PLATFORMIO.value}."
        ),
    )

@@ -37,7 +37,7 @@ def find_elf_path(build_path: Path) -> Path | None:
    """
    name = build_path.name
    for candidate in (
-        # Native ESP-IDF: idf.py writes build/<name>.elf, which ESPHome copies
+        # Native ESP-IDF: the build writes build/<name>.elf, which ESPHome copies
        # to build/firmware.elf (see espidf.toolchain.create_elf_copy)
        build_path / "build" / "firmware.elf",
        # PlatformIO
@@ -2,7 +2,9 @@

 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.
+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.

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


 def resolve_libraries(
-    framework_path: Path, *, pio_platform: str, board_mcu: str, cache_key: str
+    framework_path: Path | None,
+    *,
+    pio_platform: str,
+    board_mcu: str,
+    cache_key: str,
+    framework: str | None = "arduino",
+    manifest_optional: bool = False,
 ) -> 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.
+    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.

    The returned list is not topologically sorted, so the caller must link
    the archives inside one ``--start-group``/``--end-group`` pair (the
@@ -359,18 +372,22 @@ 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()
-    # 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[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()
        )
-    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
@@ -497,12 +514,13 @@ def resolve_libraries(

    backend = LibraryBackend(
        platform=pio_platform,
-        framework="arduino",
+        framework=framework,
        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)
@@ -3,12 +3,12 @@
 Artifacts land in a machine-global cache (shared across projects, like the
 ESP-IDF install in ``esphome.espidf.framework``):

-    <cache>/arduino8266/frameworks/<version>/   framework-arduinoespressif8266
-    <cache>/arduino8266/toolchains/<version>/   toolchain-xtensa (gcc 10.3)
+    <cache>/arduino8266/frameworks/<tag>/   the Arduino core
+    <cache>/arduino8266/toolchains/<tag>/   xtensa-lx106-elf gcc 10.3

-Packages come from the PlatformIO registry (identical bits to the PlatformIO
-backend); ``ESPHOME_ARDUINO8266_*_MIRRORS`` overrides the URLs. ninja comes
-from PATH or the ninja PyPI wheel.
+Both come from esphome-libs releases pinned below;
+``ESPHOME_ARDUINO8266_*_MIRRORS`` overrides the URLs, with ``{VERSION}``
+standing for the release tag. ninja comes from PATH or the ninja PyPI wheel.
 """

 from __future__ import annotations
@@ -17,18 +17,73 @@ import os
 from pathlib import Path
 from typing import NamedTuple

-from esphome.build_helpers.ccache import ccache_defaults_env
+from esphome.build_helpers.ccache import ccache_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
 from esphome.framework_helpers import str_to_lst_of_str
-from esphome.platformio.registry import install_package, prefetch_packages
+from esphome.platformio.registry import (
+    Download,
+    Resolver,
+    get_systype,
+    install_package,
+    prefetch_packages,
+)

-FRAMEWORK_PACKAGE = "framework-arduinoespressif8266"
-TOOLCHAIN_PACKAGE = "toolchain-xtensa"
+FRAMEWORK_PACKAGE = "arduino-esp8266"
+_FRAMEWORK_RELEASES = "https://github.com/esphome-libs/arduino-esp8266/releases/"
+
+
+class FrameworkRelease(NamedTuple):
+    tag: str
+    sha256: str
+    size: int
+
+    def download(self) -> Download:
+        archive = f"{FRAMEWORK_PACKAGE}-{self.tag}.tar.gz"
+        url = f"{_FRAMEWORK_RELEASES}download/{self.tag}/{archive}"
+        return Download(url, self.sha256, self.size)
+
+
+# Arduino core version -> its build in esphome-libs/arduino-esp8266
+FRAMEWORK_RELEASES: dict[Version, FrameworkRelease] = {
+    Version(3, 1, 2): FrameworkRelease(
+        "3.1.2-esphome.1",
+        "e80751e3123676b967143e39c61f2d8693946db4c7806f2a83dcaaf797ecd582",
+        37189311,
+    ),
+}
+
+TOOLCHAIN_PACKAGE = "toolchain-xtensa-lx106-elf"
 # gcc 10.3, the toolchain Arduino core 3.x builds with; the build
 # generator's compile flags are tuned to it.
-TOOLCHAIN_VERSION = "2.100300.220621"
+TOOLCHAIN_VERSION = "10.3.0-esphome.2"
+_TOOLCHAIN_RELEASES = (
+    "https://github.com/esphome-libs/xtensa-lx106-elf-toolchain/releases/"
+)
+# Registry system tag -> (sha256, size) of that host's archive
+TOOLCHAIN_BUILDS: dict[str, tuple[str, int]] = {
+    "darwin_arm64": (
+        "849cede44d4d5c6ea0f14099783239f559f46327bea314281814f2652b486201",
+        60830321,
+    ),
+    "darwin_x86_64": (
+        "ca69904daabf0c5983b372423e5e62f49182a793e992c052e94666852470c897",
+        64149487,
+    ),
+    "linux_aarch64": (
+        "60a49a4f082bf246544bd409a9517dbbcab19bb30ac9decbee544b896aaccbd6",
+        67573397,
+    ),
+    "linux_x86_64": (
+        "1fba33ca1494ec79f2776e0e37eca93282d30f8bb9992f5f4f9a655d6fff1db4",
+        68431336,
+    ),
+    "windows_amd64": (
+        "af9066b0e5bf036f04f2bd9d08b89b81a7f183c57dac0abcaff71dd861cf5f3b",
+        67664137,
+    ),
+}

 ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS = str_to_lst_of_str(
    os.environ.get("ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS", "")
@@ -44,36 +99,40 @@ def get_arduino8266_tools_path() -> Path:
    return tools_cache_path(*ARDUINO8266_TOOLS_CACHE)


-# 3.1.1 rather than 3.1.0: the registry has no packages for 3.0.0, 3.0.1 or 3.1.0
-MIN_FRAMEWORK_VERSION = Version(3, 1, 1)
-
-
-def framework_package_version(ver: Version) -> str:
-    """Map an Arduino core version to its registry package version (3.1.2 ->
-    3.30102.0; the leading 3 is the package major).
-
-    Exact registry names for 3.x cores; callers floor at MIN_FRAMEWORK_VERSION.
-    """
-    if ver.major > 3:
+def framework_release(version: Version) -> FrameworkRelease:
+    if (release := FRAMEWORK_RELEASES.get(version)) is None:
        raise EsphomeError(
-            f"Arduino core {ver} is not supported yet; "
-            "the newest known core series is 3.x"
+            f"'toolchain: arduino' has no build of Arduino core {version}; "
+            f"available: {', '.join(str(v) for v in FRAMEWORK_RELEASES)}. "
+            "Use one of those or 'toolchain: platformio'"
        )
-    if ver.major < 3:
-        raise EsphomeError(
-            f"Arduino core {ver} is not supported; ESPHome requires core 3.x"
-        )
-    return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
+    return release


-def get_framework_path(package_version: str) -> Path:
-    return get_arduino8266_tools_path() / "frameworks" / package_version
+def get_framework_path(tag: str) -> Path:
+    return get_arduino8266_tools_path() / "frameworks" / tag


 def get_toolchain_path() -> Path:
    return get_arduino8266_tools_path() / "toolchains" / TOOLCHAIN_VERSION


+def toolchain_download() -> Download:
+    """The toolchain archive for the current host."""
+    systype = get_systype()
+    if (build := TOOLCHAIN_BUILDS.get(systype)) is None:
+        raise EsphomeError(
+            f"There is no ESP8266 toolchain for this system ({systype}); "
+            f"supported systems are {', '.join(sorted(TOOLCHAIN_BUILDS))}. "
+            "Either set 'toolchain: platformio' under 'esp8266:', or point "
+            "ESPHOME_ARDUINO8266_TOOLCHAIN_MIRRORS at a toolchain archive"
+        )
+    sha256, size = build
+    archive = f"{TOOLCHAIN_PACKAGE}-{TOOLCHAIN_VERSION}-{systype}.tar.gz"
+    url = f"{_TOOLCHAIN_RELEASES}download/{TOOLCHAIN_VERSION}/{archive}"
+    return Download(url, sha256, size)
+
+
 class InstalledPaths(NamedTuple):
    """Locations of the installed framework, toolchain, and ninja binary."""

@@ -84,24 +143,17 @@ class InstalledPaths(NamedTuple):

 def check_and_install(framework_version: Version) -> InstalledPaths:
    """Ensure framework, toolchain, and ninja are installed; return their paths."""
-    if framework_version < MIN_FRAMEWORK_VERSION:
-        # Config validation enforces this too; keep the module honest when
-        # called directly.
-        raise EsphomeError(
-            f"The native toolchain requires the Arduino core "
-            f">= {MIN_FRAMEWORK_VERSION}, got {framework_version}"
-        )
+    release = framework_release(framework_version)
    # Probe the cheap local dependency before ~110 MB of downloads
    ninja_path = find_ninja()
-    package_version = framework_package_version(framework_version)
-    framework_path = get_framework_path(package_version)
+    framework_path = get_framework_path(release.tag)
    downloads_dir = get_arduino8266_tools_path() / "downloads"
    toolchain_path = get_toolchain_path()
    # One spec per package: the prefetch and the installs must agree
    specs = (
        (
            FRAMEWORK_PACKAGE,
-            package_version,
+            release.tag,
            framework_path,
            ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS,
            ("cores/esp8266", "tools/sdk", "libraries"),
@@ -115,10 +167,25 @@ def check_and_install(framework_version: Version) -> InstalledPaths:
            ("bin", "xtensa-lx106-elf"),
        ),
    )
+    # Resolved only when a download is needed, so an installed toolchain
+    # keeps working on a host without a build; a mirror override wins
+    resolvers: dict[str, Resolver] = {}
+    if not ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS:
+        resolvers[FRAMEWORK_PACKAGE] = release.download
+    if not ESPHOME_ARDUINO8266_TOOLCHAIN_MIRRORS:
+        resolvers[TOOLCHAIN_PACKAGE] = toolchain_download
    # Fetch both archives at once; the installs below verify and extract
-    prefetch_packages([spec[:4] for spec in specs], downloads_dir)
+    prefetch_packages([spec[:4] for spec in specs], downloads_dir, resolvers)
    for name, version, dest, mirrors, expect in specs:
-        install_package(name, version, dest, mirrors, downloads_dir, expect=expect)
+        install_package(
+            name,
+            version,
+            dest,
+            mirrors,
+            downloads_dir,
+            expect=expect,
+            resolve=resolvers.get(name),
+        )
    return InstalledPaths(
        framework=framework_path, toolchain=toolchain_path, ninja=ninja_path
    )
@@ -143,17 +210,5 @@ 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))
+    env.update(ccache_env(ccache, ARDUINO8266_TOOLS_CACHE))
    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")
@@ -2,21 +2,21 @@

 from __future__ import annotations

-import json
 import logging
 from pathlib import Path
 import subprocess
 from typing import TYPE_CHECKING

-from esphome.build_helpers.ccache import resolve_ccache_path
+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, EsphomeError
-from esphome.helpers import write_file
+from esphome.core import CORE
 from esphome.types import ConfigType

 if TYPE_CHECKING:
@@ -28,20 +28,6 @@ _LOGGER = logging.getLogger(__name__)
 _MAX_RAM_SIZE = 81920


-def _warn_ignored_platformio_options() -> None:
-    """Warn for component-added platformio options the native build drops."""
-    from esphome.core.config import NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS
-
-    consumed = NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS
-    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 'arduino' toolchain",
-                key,
-            )
-
-
 _RAM_SECTIONS = (".data", ".rodata", ".bss")
 _FLASH_SECTIONS = (".irom0.text", ".text", ".text1", ".data", ".rodata")

@@ -84,21 +70,17 @@ def get_readelf_path() -> Path:
 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()
+    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_ccache_path()
-    build_gen.write_project(paths, ccache)
+    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)
-
-    # The DB is a pure function of build.ninja; regenerate when it is older
-    compdb = build_dir / "compile_commands.json"
-    ninja_file = build_dir / "build.ninja"
-    if not compdb.is_file() or compdb.stat().st_mtime < ninja_file.stat().st_mtime:
-        _write_compile_commands(paths.ninja, build_dir, env)
+    refresh_compile_commands(paths.ninja, build_dir, env, ninja_changed)

    cmd = [str(paths.ninja)]
    if verbose:
@@ -140,42 +122,6 @@ def run_compile(config: ConfigType, verbose: bool) -> int:
    return 0


-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", "c", "cxx", "asm"],
-        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(compdb, result.stdout)
-
-
 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
@@ -253,7 +199,7 @@ def get_idedata(ccache: str | None = None) -> dict | None:

    # 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_ccache_path()
+    launcher = ccache or resolve_absolute_ccache_path()
    return load_or_build_idedata(
        get_build_dir() / "compile_commands.json",
        get_elf_path(),
@@ -345,14 +345,28 @@ async def _apply_parent(config: ConfigType, id_key: str = CONF_ID) -> str:


 def _apply_lambda_args(args: TemplateArgsType) -> TemplateArgsType:
-    # Must match ApplyAction::ApplyFn and ApplyCondition::CheckFn exactly for the function
-    # pointer conversion.
+    # 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,
@@ -403,8 +417,8 @@ def register_apply_action(
 ) -> None:
    """Register an action that only forwards config values to its parent, with no C++ class.

-    Generates one stateless function for ``ApplyAction<Ts...>``: the parent (read from
-    ``id_key``) and constants are baked in, lambdas are called inline with the trigger args.
+    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.
@@ -449,10 +463,9 @@ def register_apply_action(
                *statements,
                "apply_call.perform();",
            ]
-        apply_lambda = LambdaExpression(
-            ["\n".join(statements)], lambda_args, capture="", return_type=cg.void
+        return _apply_function(
+            action_id, cg.void, template_arg, lambda_args, statements
        )
-        return cg.new_Pvariable(action_id, template_arg, apply_lambda)

    register_action(name, ApplyAction, schema, synchronous=True)(builder)

@@ -466,7 +479,7 @@ def register_apply_condition(
    ``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 stateless function for ``ApplyCondition<Ts...>``.
+    Generates one static predicate and an ``ApplyCondition`` templated on it.
    """
    call = check if isinstance(check, ApplyCall) else ApplyCall(check)
    members = call.members
@@ -492,13 +505,13 @@ def register_apply_condition(
            lambda_args,
            compare=True,
        )
-        check_lambda = LambdaExpression(
-            [f"return {parent}->{call.target.format(*exprs)};"],
+        return _apply_function(
+            condition_id,
+            cg.bool_,
+            template_arg,
            lambda_args,
-            capture="",
-            return_type=cg.bool_,
+            [f"return {parent}->{call.target.format(*exprs)};"],
        )
-        return cg.new_Pvariable(condition_id, template_arg, check_lambda)

    register_condition(name, ApplyCondition, schema)(builder)

@@ -14,7 +14,6 @@ from the build flags with the same precedence as the PlatformIO builder.

 from __future__ import annotations

-from collections.abc import Collection
 from dataclasses import dataclass
 import hashlib
 import logging
@@ -23,15 +22,26 @@ from pathlib import Path
 import re
 import shlex
 import subprocess
-import sys
 from typing import TYPE_CHECKING, NamedTuple

 from esphome.arduino8266.framework import toolchain_tool
+from esphome.build_helpers.idedata import is_joined_include
 from esphome.build_helpers.ninja import (
    escape as _e,
    quote_path as _q,
    shell_token as _shell_token,
 )
+from esphome.build_helpers.ninja_gen import (
+    ar_rule_lines,
+    collect_sources,
+    compile_edges,
+    compile_rule_lines,
+    library_edges,
+    pch_edges,
+    pch_rule_lines,
+    tool_lines,
+)
+from esphome.build_helpers.pch import PCH_DEFAULT_HEADERS
 from esphome.components.esp8266 import build_surgery
 from esphome.components.esp8266.boards import (
    BOARDS,
@@ -46,12 +56,9 @@ from esphome.components.esp8266.const import (
    KEY_SCANF_FLOAT,
 )
 from esphome.core import CORE, EsphomeError
-from esphome.framework_helpers import (
-    get_project_cxx_compile_flags,
-    strip_win_long_path_prefix,
-)
+from esphome.framework_helpers import get_project_cxx_compile_flags
 from esphome.helpers import mkdir_p, write_file_if_changed
-from esphome.platformio.library import SOURCE_KIND_FOR_SUFFIX, lex_build_flags
+from esphome.platformio.library import lex_build_flags

 if TYPE_CHECKING:
    from esphome.arduino8266.framework import InstalledPaths
@@ -643,14 +650,6 @@ _PLAIN_LINKER_PREFIXES = ("-T", "-Xlinker")
 _PLAIN_DRIVER_LINK_PREFIXES = ("-fuse-ld=", "--specs=", "-specs=")


-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 _stat_sig(path: Path) -> str:
    """Size and mtime cache-stamp signature for one input file.

@@ -868,34 +867,6 @@ def _generate_testing_flash_ld(
    )


-def _ninja_compile_edges(
-    lines: list[str],
-    sources: list[Path],
-    root: Path,
-    group: str,
-    flags: str = "",
-) -> list[str]:
-    """Emit compile edges for ``sources``; return the object paths."""
-    objects = []
-    for src in sources:
-        rel = src.relative_to(root).as_posix()
-        obj = f"obj/{group}/{rel}.o"
-        escaped_obj = _e(obj)
-        lines.append(
-            f"build {escaped_obj}: {SOURCE_KIND_FOR_SUFFIX[src.suffix]} {_e(src)}"
-        )
-        if flags:
-            lines.append(f"  flags = {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 _common_parent(paths: list[Path]) -> Path:
-    return Path(os.path.commonpath([str(p.parent) for p in paths]))
-
-
 class _FlagSets(NamedTuple):
    cflags: list[str]
    cxxflags: list[str]
@@ -1082,48 +1053,12 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
        + ["stdc++-exc" if config.exceptions else "stdc++", "m", "c", "gcc"]
    )

-    build_tool = Path(__file__).parent / "build_tool.py"
-
-    # $in/$out stay unquoted: ninja escapes its built-in path variables
-    # itself; only literal paths need _q().
+    cxx = (toolchain_tool(paths.toolchain, "g++"),)
    lines = [
-        "# Auto-generated by ESPHome",
-        "ninja_required_version = 1.5",
-        f"cc = {_q(toolchain_tool(paths.toolchain, 'gcc'))}",
-        f"cxx = {_q(toolchain_tool(paths.toolchain, 'g++'))}",
-        # 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 ''}",
-        "",
-        # Rule names match SOURCE_KIND_FOR_SUFFIX values (c, cxx, asm, aspp)
-        "rule c",
-        "  command = $ccache $cc -MMD -MF $out.d $cflags $flags -c $in -o $out",
-        "  depfile = $out.d",
-        "  deps = gcc",
-        "  description = CC $out",
-        "rule cxx",
-        "  command = $ccache $cxx -MMD -MF $out.d $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 $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",
-        "rule ar",
-        f"  command = $python $buildtool ar {_q(toolchain_tool(paths.toolchain, 'ar'))} $out $out.rsp",
-        "  rspfile = $out.rsp",
-        "  rspfile_content = $in_newline",
-        "  description = AR $out",
+        *tool_lines((toolchain_tool(paths.toolchain, "gcc"),), cxx, ccache),
+        *compile_rule_lines(),
+        *ar_rule_lines(toolchain_tool(paths.toolchain, "ar")),
+        *pch_rule_lines(),
        "rule link",
        "  command = $cxx -o $out $linkflags @$out.rsp $libdirflags -Wl,--start-group $archives $libflags -Wl,--end-group",
        "  rspfile = $out.rsp",
@@ -1153,16 +1088,15 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
        core_exclude |= _CORE_EXCLUDE_WAVEFORM

    archives = []
-    direct_objs: list[str] = []
    # variant_dir existence was already enforced with the include dirs
-    variant_sources = _collect_sources(variant_dir)
+    variant_sources = collect_sources(variant_dir)
    if variant_sources:
-        objs = _ninja_compile_edges(lines, variant_sources, variant_dir, "variant")
+        objs = compile_edges(lines, variant_sources, variant_dir, "variant")
        lines.append(f"build libFrameworkArduinoVariant.a: ar {' '.join(objs)}")
        archives.append("libFrameworkArduinoVariant.a")

-    core_objs = _ninja_compile_edges(
-        lines, _collect_sources(core_dir, core_exclude), core_dir, "core"
+    core_objs = compile_edges(
+        lines, collect_sources(core_dir, core_exclude), core_dir, "core"
    )
    if not core_objs:
        # An empty archive would link into a wall of undefined references
@@ -1173,37 +1107,14 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
    lines.append(f"build libFrameworkArduino.a: ar {' '.join(core_objs)}")
    archives.append("libFrameworkArduino.a")

-    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
-        lib_root = _common_parent(lib.sources)
-        objs = _ninja_compile_edges(
-            lines,
-            lib.sources,
-            lib_root,
-            f"lib/{lib.name}",
-            flags=" ".join(_shell_token(f) for f in lib.flags),
-        )
-        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)
+    lib_archives, direct_objs = library_edges(lines, libraries)
+    archives += lib_archives

    # One source of truth with the PlatformIO path: esp8266/__init__ pins
    # build_src_flags (the throw_stubs force-include); -include paths
    # resolve against the source root
-    src_parts: list[str] = []
+    src_other: list[str] = []
+    src_includes: list[str] = []
    src_it = iter(
        lex_build_flags(_pio_option("build_src_flags", ""), "build_src_flags")
    )
@@ -1214,15 +1125,33 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
                raise EsphomeError(
                    "build_src_flags has a trailing '-include' with no header"
                )
-            src_parts.append(f"-include {_q(src_dir / header)}")
+            src_includes.append(header)
+        elif is_joined_include(tok):
+            # Left in src_other it would precede the pch include
+            src_includes.append(tok[len("-include") :])
        else:
-            src_parts.append(_shell_token(tok))
-    src_extra = " ".join(src_parts)
+            src_other.append(_shell_token(tok))
+    include_flags = [f"-include {_q(src_dir / h)}" for h in src_includes]
    # One shared variable instead of repeating the flags line on every src
    # edge (hundreds of edges in a real project)
-    lines.append(f"srcflags = {src_extra}")
-    src_objs = _ninja_compile_edges(
-        lines, _collect_sources(src_dir), src_dir, "src", flags="$srcflags"
+    lines.append(f"srcflags = {' '.join(src_other + include_flags)}")
+    src_cxx_override = pch_edges(
+        lines,
+        build_dir,
+        src_dir,
+        (*src_includes, *PCH_DEFAULT_HEADERS),
+        flag_sets.cxxflags,
+        src_other,
+        (str(paths.framework), str(paths.toolchain)),
+        cxx,
+    )
+    src_objs = compile_edges(
+        lines,
+        collect_sources(src_dir),
+        src_dir,
+        "src",
+        flags="$srcflags",
+        cxx_override=src_cxx_override,
    )

    ld_deps = [f"ld/{_COMMON_LD_NAME}"]
@@ -3,7 +3,9 @@
 import json
 import logging
 from pathlib import Path
+import textwrap

+from esphome.build_helpers import pch
 from esphome.components.esp32 import (
    get_esp32_variant,
    get_excluded_builtin_components,
@@ -282,9 +284,72 @@ idf_component_register(
 target_link_options(${{COMPONENT_LIB}} PUBLIC
    {link_opts_str}
 )
+{_pch_cmake_block()}"""
+
+
+# Where CMake puts the .gch of the src component; ccache reads the checksum
+# next to it in place of the .gch
+_PCH_SUM_PATH = "build/esp-idf/src/CMakeFiles/__idf_src.dir/cmake_pch.hxx.gch.sum"
+# Where the Windows gate records its choice
+_PCH_CHOICE_VAR = "ESPHOME_PCH"
+
+
+def _pch_cmake_block() -> str:
+    """The CMake block that precompiles the core headers for the C++ sources
+    of the src component; empty when disabled."""
+    if not pch.pch_enabled():
+        return ""
+    headers = "\n".join(
+        f'    "$<$<COMPILE_LANGUAGE:CXX>:${{CMAKE_CURRENT_SOURCE_DIR}}/{header}>"'
+        for header in pch.PCH_DEFAULT_HEADERS
+    )
+    block = f"""target_precompile_headers(${{COMPONENT_LIB}} PRIVATE
+{headers}
+)"""
+    if not pch.pch_needs_gcc_check():
+        return f"\n# ESPHome precompiled header\n{block}\n"
+    # Before the first configure only CMake knows the compiler version
+    return f"""
+# ESPHome precompiled header, unless GCC bug 14940 keeps it from loading
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND ({pch.PCH_WINDOWS_CMAKE_OLD_GCC}))
+  message(STATUS "ESPHome: GCC ${{CMAKE_CXX_COMPILER_VERSION}} cannot load a precompiled header on Windows; compiling without it")
+  set({_PCH_CHOICE_VAR} OFF CACHE BOOL "ESPHome precompiled header in use" FORCE)
+else()
+  set({_PCH_CHOICE_VAR} ON CACHE BOOL "ESPHome precompiled header in use" FORCE)
+{textwrap.indent(block, "  ")}
+endif()
 """


+def _read_if_exists(path: Path) -> str:
+    return path.read_text(encoding="utf-8") if path.is_file() else ""
+
+
+def write_pch_checksum() -> None:
+    """Write the checksum ccache uses in place of the .gch: the core headers,
+    the framework version, the sdkconfig and the managed component versions."""
+    from esphome.espidf.toolchain import get_cmake_cache_value
+
+    if not pch.pch_enabled():
+        return
+    # The gate's choice, cached by configure
+    if pch.pch_needs_gcc_check() and get_cmake_cache_value(_PCH_CHOICE_VAR) != "ON":
+        return
+    pch.log_pch_in_use()
+    checksum = pch.pch_checksum(
+        CORE.relative_src_path(),
+        pch.PCH_DEFAULT_HEADERS,
+        (
+            str(idf_version()),
+            _read_if_exists(CORE.relative_build_path(f"sdkconfig.{CORE.name}")),
+            _read_if_exists(CORE.relative_build_path("dependencies.lock")),
+        ),
+    )
+    path = CORE.relative_build_path(_PCH_SUM_PATH)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    write_file_if_changed(path, checksum + "\n")
+
+
 def write_project(
    minimal: bool = False, builtin_components: list[str] | None = None
 ) -> None:
@@ -0,0 +1,303 @@
+"""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 subprocess
+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,
+    pch_edges,
+    pch_rule_lines,
+    tool_lines,
+)
+from esphome.build_helpers.pch import PCH_DEFAULT_HEADERS, pch_enabled
+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 _compiler_version(cxx: tuple[str, ...]) -> str:
+    """What the compiler says it is: its path can stay the same across an
+    update (the macOS shims in /usr/bin)."""
+    result = subprocess.run(
+        [*cxx, "--version"], capture_output=True, text=True, check=False
+    )
+    return result.stdout
+
+
+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(),
+        *pch_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_cxx_override = pch_edges(
+        lines,
+        build_dir,
+        src_dir,
+        PCH_DEFAULT_HEADERS,
+        # The arguments of a CXX override come before the flags
+        [*compilers.cxx[1:], *cxxflags],
+        (),
+        (compilers.cxx[0], _compiler_version(compilers.cxx)) if pch_enabled() else (),
+        compilers.cxx,
+    )
+    src_objs = compile_edges(
+        lines,
+        collect_sources(src_dir),
+        src_dir,
+        "src",
+        cxx_override=src_cxx_override,
+    )
+    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))
@@ -1,6 +1,8 @@
+from esphome.build_helpers.pch import pch_script_enabled
 from esphome.const import __version__
 from esphome.core import CORE
 from esphome.helpers import mkdir_p, read_file, write_file_if_changed
+from esphome.platformio.toolchain import copy_pch_script
 from esphome.writer import find_begin_end

 INI_AUTO_GENERATE_BEGIN = "; ========== AUTO GENERATED CODE BEGIN ==========="
@@ -62,6 +64,8 @@ def get_ini_content():

    # Add extra script for C++ flags
    CORE.add_platformio_option("extra_scripts", [f"pre:{CXX_FLAGS_FILE_NAME}"])
+    if pch_script_enabled():
+        CORE.add_platformio_option("extra_scripts", ["post:pch.py"])

    # Add CMake args. A user-supplied value (str or list) is deliberately
    # replaced; this option was always overwritten at FINAL priority.
@@ -106,6 +110,8 @@ def write_project():

    # Write extra script for C++ specific flags
    write_cxx_flags_script()
+    if pch_script_enabled():
+        copy_pch_script()


 CXX_FLAGS_FILE_NAME = "cxx_flags.py"
@@ -68,6 +68,15 @@ 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).

@@ -84,9 +93,39 @@ def ccache_defaults_env(cache_dir: Path) -> dict[str, str]:
            "CORE.build_path must be set before constructing the build environment"
        )
    defaults = {
-        "CCACHE_DIR": str(cache_dir),
+        # ccache expands $VAR in its settings; $$ is a literal $
+        "CCACHE_DIR": str(cache_dir).replace("$", "$$"),
        "CCACHE_NOHASHDIR": "true",
        "CCACHE_DEPEND": "1",
-        "CCACHE_BASEDIR": str(Path(CORE.build_path).resolve()),
+        "CCACHE_BASEDIR": str(Path(CORE.build_path).resolve()).replace("$", "$$"),
    }
    return {k: v for k, v in defaults.items() if k not in os.environ}
+
+
+def effective_ccache_basedir() -> str:
+    """The prefix ccache strips from hashed paths: a usable user
+    CCACHE_BASEDIR, else the resolved build path."""
+    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
+    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. The pch settings include ``time_macros``: a cached
+    object can keep an older ``__DATE__`` or ``__TIME__``.
+    """
+    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
@@ -152,6 +152,15 @@ 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]]:
@@ -7,16 +7,21 @@ 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",
 }


@@ -32,3 +37,38 @@ def native_backend() -> ModuleType | None:
            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,14 +2,17 @@

 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__)

@@ -23,11 +26,26 @@ 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 = strip_win_long_path_prefix(binary)
+        binary = absolute_tool(binary)
        if _ninja_runs(binary):
            return Path(binary)
    import_error: ImportError | None = None
@@ -49,8 +67,18 @@ def find_ninja() -> Path:


 def escape(value: Path | str) -> str:
-    """Escape a path or token for a ninja file."""
-    return str(value).replace("$", "$$").replace(":", "$:").replace(" ", "$ ")
+    """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(" ", "$ ")


 def quote_arg(tok: str) -> str:
@@ -90,3 +118,65 @@ 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)
@@ -0,0 +1,279 @@
+"""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.idedata import is_joined_include
+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_GCH_NAME,
+    PCH_SUM_NAME,
+    log_pch_in_use,
+    pch_consumer_flags,
+    pch_identity,
+    pch_usable,
+    write_pch_headers,
+)
+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 embeds 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],
+    identity: Sequence[str],
+    cxx: Sequence[Path | 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, ``identity`` names what else the compile
+    depends on, the compiler included, and ``cxx`` is what the host rule
+    asks. Returns the ``cxx_override`` for ``compile_edges``, or None
+    without a pch.
+    """
+    if not pch_usable(cxx):
+        return None
+    if any(
+        tok == "-include" or tok.startswith("--include") or is_joined_include(tok)
+        for tok in cxxflags
+    ):
+        # $cxxflags expands first and GCC only loads a .gch for the first
+        # -include
+        _LOGGER.warning(
+            "A -include in the compiler flags prevents the precompiled header from "
+            "loading; compiling without it"
+        )
+        return None
+    log_pch_in_use()
+    source = write_pch_headers(build_dir, headers)
+    write_file_if_changed(
+        build_dir / PCH_SUM_NAME,
+        pch_identity([*cxxflags, *src_flags], src_dir, tuple(headers), identity) + "\n",
+    )
+    gch = _e(PCH_GCH_NAME)
+    # The checksum file changes with anything the .gch depends on
+    lines.append(f"build {gch}: pch {_e(source)} | {_e(PCH_SUM_NAME)}")
+    if src_flags:
+        lines.append(f"  flags = {' '.join(src_flags)}")
+    lines.append(f"srccxxflags = {' '.join([*src_flags, *pch_consumer_flags()])}")
+    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
@@ -0,0 +1,248 @@
+"""Shared precompiled header policy for the build backends."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+import hashlib
+import logging
+import os
+from pathlib import Path
+import posixpath
+import re
+import subprocess
+import sys
+
+from esphome.build_helpers.ccache import effective_ccache_basedir, parse_enable_env
+from esphome.const import PLATFORM_NRF52
+from esphome.helpers import write_file_if_changed
+
+_LOGGER = logging.getLogger(__name__)
+
+# The header and its sidecars live in the build directory
+PCH_HEADER_NAME = "esphome_pch.h"
+PCH_GCH_NAME = f"{PCH_HEADER_NAME}.gch"
+# ccache hashes this instead of the .gch; also the freshness stamp
+PCH_SUM_NAME = f"{PCH_GCH_NAME}.sum"
+# The include list the .gch is compiled from
+PCH_SOURCE_NAME = "esphome_pch_src.h"
+
+# GCC can skip a .gch without a diagnostic and read the header of the same
+# name, so that header is an error. Other tools get the include list.
+PCH_GUARD_TEXT = f"""\
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTELLISENSE__)
+#error "The precompiled header was not loaded"
+#else
+#include "{PCH_SOURCE_NAME}"
+#endif
+"""
+
+# The cc1plus wrapper the PlatformIO script writes on arm64 macOS
+PCH_CC1_DIR = "pch_cc1"
+
+# What the PlatformIO script leaves in the project root, for cleanup
+PCH_ARTIFACT_NAMES = (PCH_HEADER_NAME, PCH_GCH_NAME, PCH_SUM_NAME, PCH_SOURCE_NAME)
+PCH_ARTIFACT_DIRS = (PCH_CC1_DIR,)
+
+# The core headers every backend precompiles
+PCH_DEFAULT_HEADERS = ("esphome/core/pch_prefix.h",)
+
+# PlatformIO platforms that do not take the pch script
+PCH_SCRIPT_EXCLUDED_PLATFORMS = frozenset(
+    {
+        PLATFORM_NRF52,
+    }
+)
+
+# What ccache needs to cache compiles that load a .gch
+_CCACHE_PCH_SLOPPINESS = ("pch_defines", "time_macros")
+
+# Both include forms: an angle include resolving under src/ enters the digest
+_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 pch_forced() -> bool:
+    """``ESPHOME_PCH_ENABLE=1``: wanted even where the host rule says no."""
+    return parse_enable_env("ESPHOME_PCH_ENABLE") is True
+
+
+# GCC bug 14940: before these releases the Windows loader maps a .gch only
+# at its saved address. First fixed release per major, 16 on always fixed;
+# PCH_WINDOWS_CMAKE_OLD_GCC and the pch_usable message spell the same table
+PCH_WINDOWS_GCC_FIXED = {14: (14, 4), 15: (15, 3)}
+PCH_WINDOWS_GCC_FIXED_DEFAULT = (16, 0)
+# The same rule for CMake, which alone knows the version before configure
+PCH_WINDOWS_CMAKE_OLD_GCC = (
+    "CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.4 OR "
+    "(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 15 AND "
+    "CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.3)"
+)
+
+
+def gcc_relocates_pch_on_windows(version: Sequence[int]) -> bool:
+    """Whether a GCC of this version loads a .gch on Windows."""
+    if not version:
+        return False
+    fixed = PCH_WINDOWS_GCC_FIXED.get(version[0], PCH_WINDOWS_GCC_FIXED_DEFAULT)
+    return tuple(version[:2]) >= fixed
+
+
+# GCC ends the first --version line with its version; clang names itself
+_VERSION_RE = re.compile(r"\d+(?:\.\d+)+")
+
+
+def gcc_version(cxx: Sequence[Path | str]) -> tuple[int, ...] | None:
+    """The GCC version from ``--version``: () when it cannot be read, None
+    for a compiler that is not GCC."""
+    try:
+        result = subprocess.run(
+            [*cxx, "--version"], capture_output=True, text=True, check=False
+        )
+    except OSError as err:
+        _LOGGER.debug("Cannot run %s: %s", cxx[0], err)
+        return ()
+    banner = result.stdout.partition("\n")[0]
+    if "clang" in banner.lower():
+        return None
+    found = _VERSION_RE.findall(banner)
+    return tuple(int(part) for part in found[-1].split(".")) if found else ()
+
+
+def pch_needs_gcc_check() -> bool:
+    """Windows host with the knob unset: the compiler version decides."""
+    return sys.platform == "win32" and parse_enable_env("ESPHOME_PCH_ENABLE") is None
+
+
+def pch_usable(cxx: Sequence[Path | str]) -> bool:
+    """The knob plus the host rule; ``ESPHOME_PCH_ENABLE=1`` skips the rule."""
+    if not pch_enabled():
+        return False
+    if not pch_needs_gcc_check():
+        return True
+    version = gcc_version(cxx)
+    if version is None or gcc_relocates_pch_on_windows(version):
+        return True
+    _LOGGER.info(
+        "GCC %s cannot load a precompiled header on Windows (GCC bug 14940, "
+        "fixed in 14.4, 15.3 and 16); compiling without it "
+        "(set ESPHOME_PCH_ENABLE=1 to force)",
+        ".".join(map(str, version)) or "of unknown version",
+    )
+    return False
+
+
+def pch_consumer_flags() -> list[str]:
+    """Flags a C++ src compile loads the pch with. The -include stays
+    relative: an absolute path would enter the ccache key."""
+    return ["-Winvalid-pch", "-Werror=invalid-pch", "-include", PCH_HEADER_NAME]
+
+
+def ccache_pch_env() -> dict[str, str]:
+    """What ccache needs to cache compiles that load a .gch, added to what
+    the user already set."""
+    if not pch_enabled():
+        return {}
+    sloppiness = [
+        item.strip()
+        for item in os.environ.get("CCACHE_SLOPPINESS", "").split(",")
+        if item.strip()
+    ]
+    sloppiness += [item for item in _CCACHE_PCH_SLOPPINESS if item not in sloppiness]
+    env = {"CCACHE_SLOPPINESS": ",".join(sloppiness)}
+    if "CCACHE_PCH_EXTSUM" not in os.environ:
+        env["CCACHE_PCH_EXTSUM"] = "true"
+    return env
+
+
+def pch_script_enabled() -> bool:
+    """Whether this PlatformIO build takes the pch script."""
+    from esphome.core import CORE
+
+    return pch_enabled() and CORE.target_platform not in PCH_SCRIPT_EXCLUDED_PLATFORMS
+
+
+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 write_pch_headers(build_dir: Path, include_headers: Iterable[str]) -> Path:
+    """Write the guard header and the include list; return the latter,
+    which is what the .gch compiles from."""
+    write_file_if_changed(build_dir / PCH_HEADER_NAME, PCH_GUARD_TEXT)
+    source = build_dir / PCH_SOURCE_NAME
+    write_file_if_changed(source, pch_header_text(include_headers))
+    return source
+
+
+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). No
+    #ifdef evaluation: including too much is the safe direction. Headers
+    outside ``src_dir`` are covered by the version strings of the caller.
+    """
+    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 (src_dir / rel).is_file():
+                break
+        else:
+            continue
+        if rel in seen:
+            continue
+        data = seen[rel] = (src_dir / rel).read_bytes()
+        parent = posixpath.dirname(rel)
+        stack.extend((inc.decode(), 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 of the prefix header's include closure plus ``extra``."""
+    digest = hashlib.sha256()
+    closure = _include_closure(src_dir, include_headers)
+    for name in sorted(closure):
+        digest.update(name.encode())
+        digest.update(closure[name])
+        digest.update(b"\0")
+    for item in extra:
+        digest.update(item.encode())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def pch_identity(
+    tokens: Iterable[str],
+    src_dir: Path,
+    include_headers: tuple[str, ...],
+    extra: Iterable[str],
+) -> str:
+    """The .sum digest: include closure, header text, ``extra`` and the
+    compile flags with the build path stripped, as ccache does."""
+    from esphome.core import CORE
+
+    flags = (
+        " ".join(tokens)
+        .replace(str(CORE.build_path), "")
+        .replace(effective_ccache_basedir(), "")
+    )
+    # The closure is sorted, so header order only enters via the text
+    return pch_checksum(
+        src_dir, include_headers, (pch_header_text(include_headers), *extra, flags)
+    )
+
+
+_DISABLE_HINT = " (set ESPHOME_PCH_ENABLE=0 to disable)"
+
+
+def log_pch_in_use() -> None:
+    _LOGGER.info("Compiling with a precompiled header%s", _DISABLE_HINT)
@@ -0,0 +1,180 @@
+"""Run a native build tool (cmake, ninja) and relay its output.
+
+Output is read from a pipe so it can be filtered here: a child that inherits
+our stdout writes straight to the file descriptor, past any Python wrapper.
+"""
+
+from __future__ import annotations
+
+import codecs
+from contextlib import suppress
+import logging
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import sys
+from typing import Any, TextIO
+
+from esphome.util import ANSI_ESCAPE, RedirectText, shlex_quote
+
+_LOGGER = logging.getLogger(__name__)
+
+# Windows code page identifier for UTF-8, as used by ``chcp 65001``.
+UTF8_CODEPAGE = 65001
+
+# Same pattern idf.py uses to spot ninja status lines (``is_progression``).
+_PROGRESS = re.compile(r"^\[\d+/\d+\]|.*\(\d+ \%\)$")
+_READ_SIZE = 65536
+
+
+def _get_kernel32() -> Any | None:
+    """Return the Windows kernel32 module, or None on any other platform."""
+    if sys.platform != "win32":
+        return None
+    import ctypes
+
+    return ctypes.windll.kernel32
+
+
+class Utf8Console:
+    """Keep an attached Windows console on UTF-8 while a build tool runs.
+
+    esp_idf_size draws its table with Unicode box characters, and CMake
+    re-decodes a child's output with the console code page, which garbles the
+    table on any page but UTF-8. A console already on UTF-8 is left alone so
+    an overlapping build never records UTF-8 as the page to go back to.
+    """
+
+    def __init__(self, kernel32: Any | None) -> None:
+        self._kernel32 = kernel32
+        self._codepages: tuple[int, int] | None = None
+
+    def __enter__(self) -> None:
+        kernel32 = self._kernel32
+        if kernel32 is None:
+            return
+        old_in = kernel32.GetConsoleCP()
+        old_out = kernel32.GetConsoleOutputCP()
+        # Both calls return 0 when no console is attached.
+        if not old_in or not old_out:
+            return
+        if old_in == UTF8_CODEPAGE and old_out == UTF8_CODEPAGE:
+            return
+        # Record first so a switch that fails part way is still undone.
+        self._codepages = (old_in, old_out)
+        kernel32.SetConsoleCP(UTF8_CODEPAGE)
+        kernel32.SetConsoleOutputCP(UTF8_CODEPAGE)
+
+    def __exit__(self, *exc_info: object) -> None:
+        if self._codepages is None:
+            return
+        old_in, old_out = self._codepages
+        self._codepages = None
+        self._kernel32.SetConsoleCP(old_in)
+        self._kernel32.SetConsoleOutputCP(old_out)
+
+
+def _fit_terminal(text: str) -> str:
+    """Elide the middle of ``text`` to fit the terminal, as idf.py does.
+
+    A width of 0 (a pipe, the dashboard) leaves the text whole.
+    """
+    width = shutil.get_terminal_size((0, 0)).columns
+    if not width:
+        return text
+    if width <= 3:
+        return "." * width
+    if len(text) >= width:
+        keep = (width - 3) // 2
+        return f"{text[:keep]}...{text[len(text) - keep :]}"
+    return text
+
+
+class ToolOutput(RedirectText):
+    """RedirectText that can collapse ninja status lines into one line.
+
+    With ``progress`` each ``[n/m]`` line overwrites the previous one, the
+    way idf.py shows a build.
+    """
+
+    def __init__(
+        self, out: TextIO, filter_lines: list[str] | None, progress: bool
+    ) -> None:
+        super().__init__(out, filter_lines=filter_lines)
+        self._progress = progress
+        self._on_progress_line = False
+
+    def _splits_lines(self) -> bool:
+        return self._progress or super()._splits_lines()
+
+    def _emit_line(self, line: str) -> None:
+        if self._progress and _PROGRESS.match(line):
+            if not self._is_filtered(line):
+                text = _fit_terminal(line.strip("\r\n"))
+                self._write_color_replace(f"\r{text}\x1b[K")
+                self._on_progress_line = True
+            return
+        self._end_progress_line()
+        super()._emit_line(line)
+
+    def _end_progress_line(self) -> None:
+        if self._on_progress_line:
+            self._on_progress_line = False
+            self._write_color_replace(os.linesep)
+
+    def drain(self) -> None:
+        super().drain()
+        # Called from cleanup, so a broken stream must not hide the exit code.
+        with suppress(OSError, ValueError):
+            self._end_progress_line()
+            self._out.flush()
+
+
+def run_build_tool(
+    cmd: list[str],
+    *,
+    cwd: Path,
+    env: dict[str, str],
+    filter_lines: list[str] | None = None,
+    progress: bool = False,
+    log_path: Path | None = None,
+) -> int:
+    """Run ``cmd`` and relay stdout and stderr, merged, to our stdout.
+
+    ``log_path`` also gets the full, unfiltered output without color codes, as
+    idf.py wrote its logs (its hint patterns expect plain text). Returns the
+    exit code.
+    """
+    _LOGGER.debug("Running: %s", " ".join(shlex_quote(arg) for arg in cmd))
+    _LOGGER.debug("  in directory: %s", cwd)
+    output = ToolOutput(sys.stdout, filter_lines, progress)
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+    if log_path is not None:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+    with (
+        Path(log_path or os.devnull).open("w", encoding="utf-8", newline="") as log,
+        Utf8Console(_get_kernel32()),
+        subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            close_fds=False,
+        ) as proc,
+    ):
+        try:
+            # read1 returns as soon as anything is available, so output
+            # streams while the tool runs.
+            while chunk := proc.stdout.read1(_READ_SIZE):
+                text = decoder.decode(chunk)
+                log.write(ANSI_ESCAPE.sub("", text))
+                output.write(text)
+            if tail := decoder.decode(b"", final=True):
+                log.write(ANSI_ESCAPE.sub("", tail))
+                output.write(tail)
+        finally:
+            output.drain()
+    return proc.returncode
@@ -16,8 +16,8 @@ def tools_cache_path(env_var: str, subdir: str) -> Path:
    from esphome.helpers import get_str_env

    if prefix := get_str_env(env_var, "").strip():
-        # resolve(): symlinked prefixes otherwise trip idf.py's
-        # venv-mismatch warning on every build
+        # resolve(): a symlinked prefix would otherwise record a second
+        # spelling of the same paths in the build tree
        return Path(prefix).expanduser().resolve()
    # appauthor=False keeps the Windows path short (no vendor segment);
    # deep IDF trees run into MAX_PATH otherwise
@@ -33,4 +33,14 @@ 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")
-TOOLS_CACHE_SPECS = (IDF_TOOLS_CACHE, SDK_NRF_TOOLS_CACHE, ARDUINO8266_TOOLS_CACHE)
+# The host backend installs nothing; the entry only holds its ccache dir
+HOST_TOOLS_CACHE = ("ESPHOME_HOST_PREFIX", "host")
+# PlatformIO installs into its own dirs; the entry is its ccache dir itself
+PLATFORMIO_CCACHE = ("ESPHOME_PLATFORMIO_CCACHE_DIR", "platformio-ccache")
+TOOLS_CACHE_SPECS = (
+    IDF_TOOLS_CACHE,
+    SDK_NRF_TOOLS_CACHE,
+    ARDUINO8266_TOOLS_CACHE,
+    HOST_TOOLS_CACHE,
+    PLATFORMIO_CCACHE,
+)
@@ -42,6 +42,7 @@ from esphome.cpp_generator import (  # noqa: F401
    set_cpp_standard,
    statement,
    static_const_array,
+    static_function,
    templatable,
    variable,
    with_local_variable,
@@ -85,20 +85,11 @@ async def wave_base_to_code(var: MockObj, config: ConfigType) -> None:

    await ble_client.register_ble_node(var, config)

-    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))
+    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_battery_update_interval := config.get(CONF_BATTERY_UPDATE_INTERVAL):
        cg.add(var.set_battery_update_interval(config_battery_update_interval))
@@ -87,16 +87,9 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await airthings_wave_base.wave_base_to_code(var, config)

-    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))
+    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)
    cg.add(var.set_device_type(config[CONF_DEVICE_TYPE]))
@@ -87,18 +87,8 @@ async def to_code(config: ConfigType) -> None:
    if out_of_range_mode_config := config.get(CONF_OUT_OF_RANGE_MODE):
        cg.add(var.set_out_of_range_mode(out_of_range_mode_config))

-    if raw_position_config := config.get(CONF_RAW_POSITION):
-        sens = await sensor.new_sensor(raw_position_config)
-        cg.add(var.set_raw_position_sensor(sens))
-
-    if gain_config := config.get(CONF_GAIN):
-        sens = await sensor.new_sensor(gain_config)
-        cg.add(var.set_gain_sensor(sens))
-
-    if magnitude_config := config.get(CONF_MAGNITUDE):
-        sens = await sensor.new_sensor(magnitude_config)
-        cg.add(var.set_magnitude_sensor(sens))
-
-    if status_config := config.get(CONF_STATUS):
-        sens = await sensor.new_sensor(status_config)
-        cg.add(var.set_status_sensor(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_RAW_POSITION, var.set_raw_position_sensor)
+    await sensors(CONF_GAIN, var.set_gain_sensor)
+    await sensors(CONF_MAGNITUDE, var.set_magnitude_sensor)
+    await sensors(CONF_STATUS, var.set_status_sensor)
@@ -85,18 +85,9 @@ async def to_code(config: ConfigType) -> None:

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

-    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))
+    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)
@@ -129,30 +129,15 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await spi.register_spi_device(var, config)

-    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))
+    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)
    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]))
@@ -61,14 +61,16 @@ from esphome.const import (
    DEVICE_CLASS_VIBRATION,
    DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, ID, 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 MockObjClass
+from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.types import ConfigType
 from esphome.util import Registry

 CODEOWNERS = ["@esphome/core"]
@@ -632,6 +634,13 @@ 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),
@@ -150,15 +150,10 @@ 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)
-    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))
+    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)

    for i in range(6):
        if channel_config := config.get(f"{CONF_CHANNEL}_{i + 1}"):
@@ -172,10 +167,5 @@ 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))

-    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))
+    await sensors(CONF_TOTAL_POWER, var.set_total_power_sensor)
+    await sensors(CONF_TOTAL_ENERGY, var.set_total_energy_sensor)
@@ -94,27 +94,12 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    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))
+    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)
@@ -231,24 +231,13 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    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 energy_config := config.get(CONF_ENERGY):
-        sens = await sensor.new_sensor(energy_config)
-        cg.add(var.set_energy_sensor(sens))
-    if internal_temperature_config := config.get(CONF_INTERNAL_TEMPERATURE):
-        sens = await sensor.new_sensor(internal_temperature_config)
-        cg.add(var.set_internal_temperature_sensor(sens))
-    if external_temperature_config := config.get(CONF_EXTERNAL_TEMPERATURE):
-        sens = await sensor.new_sensor(external_temperature_config)
-        cg.add(var.set_external_temperature_sensor(sens))
+    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_ENERGY, var.set_energy_sensor)
+    await sensors(CONF_INTERNAL_TEMPERATURE, var.set_internal_temperature_sensor)
+    await sensors(CONF_EXTERNAL_TEMPERATURE, var.set_external_temperature_sensor)

    # enable legacy mode
    cg.add(var.set_legacy_mode(config.get(CONF_LEGACY_MODE)))
@@ -101,21 +101,12 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    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 energy_config := config.get(CONF_ENERGY):
-        sens = await sensor.new_sensor(energy_config)
-        cg.add(var.set_energy_sensor(sens))
-    if frequency_config := config.get(CONF_FREQUENCY):
-        sens = await sensor.new_sensor(frequency_config)
-        cg.add(var.set_frequency_sensor(sens))
+    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_ENERGY, var.set_energy_sensor)
+    await sensors(CONF_FREQUENCY, var.set_frequency_sensor)
    cg.add(var.set_line_freq(config[CONF_LINE_FREQUENCY]))
    cg.add(var.set_address(config[CONF_ADDRESS]))
    cg.add(var.set_reset(config[CONF_RESET]))
@@ -7,6 +7,7 @@ from esphome.components.uart import (
    uart_ns,
 )
 from esphome.components.zephyr import zephyr_add_prj_conf
+from esphome.components.zephyr_ble_server import request_ble_l2cap_mtu
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_DEBUG,
@@ -61,6 +62,8 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    zephyr_add_prj_conf("BT_NUS", True)
+    zephyr_add_prj_conf("RING_BUFFER", True)
+    request_ble_l2cap_mtu(247)  # DLE sweet spot: one NUS frame per LL PDU
    expose_log = config[CONF_TYPE] == CONF_LOGS
    cg.add(var.set_expose_log(expose_log))
    if expose_log:
@@ -90,20 +90,14 @@ async def to_code_base(config: ConfigType) -> MockObj:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

-    if temperature_config := config.get(CONF_TEMPERATURE):
-        sens = await sensor.new_sensor(temperature_config)
-        cg.add(var.set_temperature_sensor(sens))
-        cg.add(var.set_temperature_oversampling(temperature_config[CONF_OVERSAMPLING]))
-
-    if pressure_config := config.get(CONF_PRESSURE):
-        sens = await sensor.new_sensor(pressure_config)
-        cg.add(var.set_pressure_sensor(sens))
-        cg.add(var.set_pressure_oversampling(pressure_config[CONF_OVERSAMPLING]))
-
-    if humidity_config := config.get(CONF_HUMIDITY):
-        sens = await sensor.new_sensor(humidity_config)
-        cg.add(var.set_humidity_sensor(sens))
-        cg.add(var.set_humidity_oversampling(humidity_config[CONF_OVERSAMPLING]))
+    sensors = sensor.sub_sensors(config)
+    if await sensors(CONF_TEMPERATURE, var.set_temperature_sensor):
+        oversampling = config[CONF_TEMPERATURE][CONF_OVERSAMPLING]
+        cg.add(var.set_temperature_oversampling(oversampling))
+    if await sensors(CONF_PRESSURE, var.set_pressure_sensor):
+        cg.add(var.set_pressure_oversampling(config[CONF_PRESSURE][CONF_OVERSAMPLING]))
+    if await sensors(CONF_HUMIDITY, var.set_humidity_sensor):
+        cg.add(var.set_humidity_oversampling(config[CONF_HUMIDITY][CONF_OVERSAMPLING]))

    cg.add(var.set_iir_filter(config[CONF_IIR_FILTER]))

@@ -72,18 +72,9 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await setup_bthome_mithermometer(var, config)

-    if temp_sens := config.get(CONF_TEMPERATURE):
-        sens = await sensor.new_sensor(temp_sens)
-        cg.add(var.set_temperature(sens))
-    if humi_sens := config.get(CONF_HUMIDITY):
-        sens = await sensor.new_sensor(humi_sens)
-        cg.add(var.set_humidity(sens))
-    if batl_sens := config.get(CONF_BATTERY_LEVEL):
-        sens = await sensor.new_sensor(batl_sens)
-        cg.add(var.set_battery_level(sens))
-    if batv_sens := config.get(CONF_BATTERY_VOLTAGE):
-        sens = await sensor.new_sensor(batv_sens)
-        cg.add(var.set_battery_voltage(sens))
-    if sgnl_sens := config.get(CONF_SIGNAL_STRENGTH):
-        sens = await sensor.new_sensor(sgnl_sens)
-        cg.add(var.set_signal_strength(sens))
+    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)
@@ -16,8 +16,9 @@ from esphome.const import (
    DEVICE_CLASS_RESTART,
    DEVICE_CLASS_UPDATE,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
+    SubEntities,
    entity_duplicate_validator,
    queue_entity_register,
    setup_device_class,
@@ -114,6 +115,13 @@ async def new_button(config: ConfigType, *args: SafeExpType) -> MockObj:
    return var


+def sub_buttons(
+    config: ConfigType, *, parent: MockObj | ID | None = None
+) -> SubEntities:
+    """Return a SubEntities bound to new_button."""
+    return SubEntities(new_button, config, parent)
+
+
 BUTTON_PRESS_SCHEMA = maybe_simple_id(
    {
        cv.Required(CONF_ID): cv.use_id(Button),
@@ -65,17 +65,12 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    if eco2_config := config.get(CONF_ECO2):
-        sens = await sensor.new_sensor(eco2_config)
-        cg.add(var.set_co2(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_ECO2, var.set_co2)
+    await sensors(CONF_TVOC, var.set_tvoc)

-    if tvoc_config := config.get(CONF_TVOC):
-        sens = await sensor.new_sensor(tvoc_config)
-        cg.add(var.set_tvoc(sens))
-
-    if version_config := config.get(CONF_VERSION):
-        sens = await text_sensor.new_text_sensor(version_config)
-        cg.add(var.set_version(sens))
+    text_sensors = text_sensor.sub_text_sensors(config)
+    await text_sensors(CONF_VERSION, var.set_version)

    if (baseline := config.get(CONF_BASELINE)) is not None:
        cg.add(var.set_baseline(baseline))
@@ -15,6 +15,7 @@ CONF_CLIMATE_ID = "climate_id"
 CONF_CO2_EQUIVALENT = "co2_equivalent"
 CONF_COLOR_DEPTH = "color_depth"
 CONF_COLUMNS = "columns"
+CONF_CONVERSION_RATE = "conversion_rate"
 CONF_CRC_ENABLE = "crc_enable"
 CONF_DATA_BITS = "data_bits"
 CONF_DESCRIPTION = "description"
@@ -0,0 +1 @@
+CODEOWNERS = ["@clydebarrow"]
@@ -0,0 +1,28 @@
+#include "counter_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::counter {
+
+static const char *const TAG = "counter";
+
+void CounterSensor::setup() {
+  if (this->restore_) {
+    this->pref_ = this->make_entity_preference<int64_t>();
+    this->pref_.load(&this->value_);
+  }
+  this->publish_state(static_cast<float>(this->value_));
+}
+
+void CounterSensor::set_value(int64_t value) {
+  this->value_ = value;
+  this->publish_state(static_cast<float>(value));
+  if (this->restore_)
+    this->pref_.save(&this->value_);
+}
+
+void CounterSensor::dump_config() {
+  LOG_SENSOR("", "Counter", this);
+  ESP_LOGCONFIG(TAG, "  Restore: %s", YESNO(this->restore_));
+}
+
+}  // namespace esphome::counter
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <cstdint>
+
+#include "esphome/core/component.h"
+#include "esphome/core/preferences.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome::counter {
+
+/// A counter held as a 64-bit integer. The published sensor state is a float, so it is exact only up to 2^24.
+class CounterSensor final : public sensor::Sensor, public Component {
+ public:
+  /// The counter starts at initial_value unless a stored value is restored.
+  CounterSensor(bool restore, int64_t initial_value) : value_(initial_value), restore_(restore) {}
+
+  void setup() override;
+  void dump_config() override;
+  // restore value before `on_boot` automations run
+  float get_setup_priority() const override { return setup_priority::DATA + 50.0f; }
+
+  /// Increment by one each time the given sensor publishes a state.
+  void count_updates_from(sensor::Sensor *source) {
+    source->add_on_state_callback([this](float) { this->increment(); });
+  }
+
+  /// Increment by one each time the given binary sensor changes to true.
+  template<typename T> void count_true_from(T *source) {
+    source->add_on_state_callback([this](bool state) {
+      if (state)
+        this->increment();
+    });
+  }
+
+  void set_value(int64_t value);
+  /// overflow on addition of signed numbers is undefined - use the well defined unsigned version
+  void increment(int64_t amount = 1) {
+    this->set_value(static_cast<int64_t>(static_cast<uint64_t>(this->value_) + static_cast<uint64_t>(amount)));
+  }
+
+ protected:
+  ESPPreferenceObject pref_;
+  int64_t value_;
+  bool restore_;
+};
+
+}  // namespace esphome::counter
@@ -0,0 +1,85 @@
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import binary_sensor, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BINARY_SENSOR,
+    CONF_ID,
+    CONF_INITIAL_VALUE,
+    CONF_RESTORE,
+    CONF_SENSOR,
+    CONF_VALUE,
+    ICON_COUNTER,
+)
+from esphome.types import ConfigType
+
+counter_ns = cg.esphome_ns.namespace("counter")
+CounterSensor = counter_ns.class_("CounterSensor", sensor.Sensor, cg.Component)
+
+# The lowest value is left out because its C++ literal cannot be written portably.
+INT64_MAX = 2**63 - 1
+COUNTER_RANGE = cv.int_range(min=-INT64_MAX, max=INT64_MAX)
+COUNTER_VALUE = cv.templatable(COUNTER_RANGE)
+
+
+def _not_own_source(config: ConfigType) -> ConfigType:
+    if (source := config.get(CONF_SENSOR)) is not None and source.id == config[
+        CONF_ID
+    ].id:
+        raise cv.Invalid("A counter cannot count its own updates", [CONF_SENSOR])
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    sensor.sensor_schema(
+        CounterSensor,
+        icon=ICON_COUNTER,
+        accuracy_decimals=0,
+    )
+    .extend(
+        {
+            cv.Optional(CONF_RESTORE, default=True): cv.boolean,
+            cv.Optional(CONF_INITIAL_VALUE, default=0): COUNTER_RANGE,
+            cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor),
+            cv.Optional(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA),
+    _not_own_source,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(
+        config[CONF_ID], config[CONF_RESTORE], config[CONF_INITIAL_VALUE]
+    )
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+    if (source := config.get(CONF_SENSOR)) is not None:
+        cg.add(var.count_updates_from(await cg.get_variable(source)))
+    if (source := config.get(CONF_BINARY_SENSOR)) is not None:
+        cg.add(var.count_true_from(await cg.get_variable(source)))
+
+
+automation.register_apply_action(
+    "counter.set_value",
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(CounterSensor),
+            cv.Required(CONF_VALUE): COUNTER_VALUE,
+        },
+        key=CONF_VALUE,
+    ),
+    automation.ApplyField(CONF_VALUE, "set_value", cg.int64),
+)
+
+automation.register_apply_action(
+    "counter.increment",
+    automation.maybe_simple_id(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(CounterSensor),
+            cv.Optional(CONF_VALUE, default=1): COUNTER_VALUE,
+        }
+    ),
+    automation.ApplyField(CONF_VALUE, "increment", cg.int64),
+)
@@ -98,24 +98,11 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    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 energy_config := config.get(CONF_ENERGY):
-        sens = await sensor.new_sensor(energy_config)
-        cg.add(var.set_energy_sensor(sens))
-    if apparent_power_config := config.get(CONF_APPARENT_POWER):
-        sens = await sensor.new_sensor(apparent_power_config)
-        cg.add(var.set_apparent_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))
+    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_ENERGY, var.set_energy_sensor)
+    await sensors(CONF_APPARENT_POWER, var.set_apparent_power_sensor)
+    await sensors(CONF_REACTIVE_POWER, var.set_reactive_power_sensor)
+    await sensors(CONF_POWER_FACTOR, var.set_power_factor_sensor)
@@ -1,4 +1,5 @@
 import esphome.codegen as cg
+from esphome.components.nrf52.framework import include_west_project
 from esphome.components.zephyr import zephyr_add_prj_conf
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
@@ -51,13 +52,15 @@ async def to_code(config: ConfigType) -> None:
        zephyr_add_prj_conf("HWINFO", True)
        # gdb thread support
        zephyr_add_prj_conf("DEBUG_THREAD_INFO", True)
-        # RTT
+        # RTT sources live in the segger project
+        include_west_project("segger")
        zephyr_add_prj_conf("USE_SEGGER_RTT", True)
        zephyr_add_prj_conf("RTT_CONSOLE", True)
        zephyr_add_prj_conf("LOG", True)
        zephyr_add_prj_conf("LOG_BLOCK_IN_THREAD", True)
        zephyr_add_prj_conf("LOG_BUFFER_SIZE", 4096)
        zephyr_add_prj_conf("SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL", True)
+        zephyr_add_prj_conf("PRINTK", True)
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    cg.add_define("USE_DEBUG")
@@ -106,32 +106,13 @@ CONFIG_SCHEMA = {


 async def to_code(config: ConfigType) -> None:
-    debug_component = await cg.get_variable(config[CONF_DEBUG_ID])
+    hub = await cg.get_variable(config[CONF_DEBUG_ID])

-    if free_conf := config.get(CONF_FREE):
-        sens = await sensor.new_sensor(free_conf)
-        cg.add(debug_component.set_free_sensor(sens))
-
-    if block_conf := config.get(CONF_BLOCK):
-        sens = await sensor.new_sensor(block_conf)
-        cg.add(debug_component.set_block_sensor(sens))
-
-    if fragmentation_conf := config.get(CONF_FRAGMENTATION):
-        sens = await sensor.new_sensor(fragmentation_conf)
-        cg.add(debug_component.set_fragmentation_sensor(sens))
-
-    if min_free_conf := config.get(CONF_MIN_FREE):
-        sens = await sensor.new_sensor(min_free_conf)
-        cg.add(debug_component.set_min_free_sensor(sens))
-
-    if loop_time_conf := config.get(CONF_LOOP_TIME):
-        sens = await sensor.new_sensor(loop_time_conf)
-        cg.add(debug_component.set_loop_time_sensor(sens))
-
-    if psram_conf := config.get(CONF_PSRAM):
-        sens = await sensor.new_sensor(psram_conf)
-        cg.add(debug_component.set_psram_sensor(sens))
-
-    if cpu_freq_conf := config.get(CONF_CPU_FREQUENCY):
-        sens = await sensor.new_sensor(cpu_freq_conf)
-        cg.add(debug_component.set_cpu_frequency_sensor(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_FREE, hub.set_free_sensor)
+    await sensors(CONF_BLOCK, hub.set_block_sensor)
+    await sensors(CONF_FRAGMENTATION, hub.set_fragmentation_sensor)
+    await sensors(CONF_MIN_FREE, hub.set_min_free_sensor)
+    await sensors(CONF_LOOP_TIME, hub.set_loop_time_sensor)
+    await sensors(CONF_PSRAM, hub.set_psram_sensor)
+    await sensors(CONF_CPU_FREQUENCY, hub.set_cpu_frequency_sensor)
@@ -31,11 +31,8 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config: ConfigType) -> None:
-    debug_component = await cg.get_variable(config[CONF_DEBUG_ID])
+    hub = await cg.get_variable(config[CONF_DEBUG_ID])

-    if CONF_DEVICE in config:
-        sens = await text_sensor.new_text_sensor(config[CONF_DEVICE])
-        cg.add(debug_component.set_device_info_sensor(sens))
-    if CONF_RESET_REASON in config:
-        sens = await text_sensor.new_text_sensor(config[CONF_RESET_REASON])
-        cg.add(debug_component.set_reset_reason_sensor(sens))
+    text_sensors = text_sensor.sub_text_sensors(config)
+    await text_sensors(CONF_DEVICE, hub.set_device_info_sensor)
+    await text_sensors(CONF_RESET_REASON, hub.set_reset_reason_sensor)
@@ -187,19 +187,18 @@ async def dfrobot_sen0395_settings_to_code(
            template_ = await cg.templatable(segments[7], args, cg.float_)
            cg.add(var.set_det_max4(template_))
    if CONF_OUTPUT_LATENCY in config:
-        template_ = await cg.templatable(
-            config[CONF_OUTPUT_LATENCY][CONF_DELAY_AFTER_DETECT], args, float
-        )
-        if isinstance(template_, cv.TimePeriod):
-            template_ = template_.total_milliseconds / 1000
-        cg.add(var.set_delay_after_detect(template_))
-
-        template_ = await cg.templatable(
-            config[CONF_OUTPUT_LATENCY][CONF_DELAY_AFTER_DISAPPEAR], args, float
-        )
-        if isinstance(template_, cv.TimePeriod):
-            template_ = template_.total_milliseconds / 1000
-        cg.add(var.set_delay_after_disappear(template_))
+        latency = config[CONF_OUTPUT_LATENCY]
+        for key, setter in (
+            (CONF_DELAY_AFTER_DETECT, var.set_delay_after_detect),
+            (CONF_DELAY_AFTER_DISAPPEAR, var.set_delay_after_disappear),
+        ):
+            template_ = await cg.templatable(
+                latency[key],
+                args,
+                float,
+                to_exp=lambda period: period.total_milliseconds / 1000,
+            )
+            cg.add(setter(template_))
    if CONF_SENSITIVITY in config:
        template_ = await cg.templatable(config[CONF_SENSITIVITY], args, cg.int8)
        cg.add(var.set_sensitivity(template_))
@@ -1,5 +1,6 @@
 import esphome.codegen as cg
 from esphome.components import i2c
+from esphome.components.const import CONF_CONVERSION_RATE
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_INVERTED, CONF_RESOLUTION
 from esphome.types import ConfigType
@@ -13,7 +14,6 @@ MULTI_CONF = True
 CONF_PWM = "pwm"
 CONF_DIVIDER = "divider"
 CONF_DAC = "dac"
-CONF_CONVERSION_RATE = "conversion_rate"

 CONF_EMC2101_ID = "emc2101_id"

@@ -16,6 +16,28 @@ namespace esphome::epaper_spi {
 /** Delta for when to regard as gray */
 static constexpr uint8_t COLORCONV_GRAY_THRESHOLD = 50;

+/** Rec.601 luma (0.299/0.587/0.114 weights, scaled by 256) for optimum perceptual brightness */
+constexpr uint8_t rec601_luma(Color color) {
+  return (uint8_t) ((77u * color.r + 150u * color.g + 29u * color.b + 128u) >> 8);
+}
+
+/** Map RGB color to a single monochrome bit
+ *
+ * @param color RGB color to convert from
+ * @return      1 = white, 0 = black
+ */
+constexpr uint8_t color_to_mono(Color color) { return rec601_luma(color) >= 128 ? 1 : 0; }
+
+/** Map RGB color to one of 4 discrete gray levels (2 bits per pixel)
+ *
+ * @param color RGB color to convert from
+ * @return      Gray level: 0 = black, 3 = white
+ */
+constexpr uint8_t color_to_gray4(Color color) {
+  const uint8_t level = (uint8_t) ((rec601_luma(color) + 32u) >> 6);  // quantize 0..255 to 0..3, rounded
+  return level > 3 ? 3 : level;
+}
+
 /** Map RGB color to discrete BWYR hex 4 color key
 *
 * @tparam NATIVE_COLOR  Type of native hardware color values
@@ -25,7 +47,6 @@ static constexpr uint8_t COLORCONV_GRAY_THRESHOLD = 50;
 * @param hw_yellow Native value for yellow
 * @param hw_red    Native value for red
 * @return          Converted native hardware color value
- * @internal Constexpr. Does not depend on side effects ("pure").
 */
 template<typename NATIVE_COLOR>
 constexpr NATIVE_COLOR color_to_bwyr(Color color, NATIVE_COLOR hw_black, NATIVE_COLOR hw_white, NATIVE_COLOR hw_yellow,
@@ -38,11 +59,7 @@ constexpr NATIVE_COLOR color_to_bwyr(Color color, NATIVE_COLOR hw_black, NATIVE_

  if ((max_rgb - min_rgb) < COLORCONV_GRAY_THRESHOLD) {
    // It's a shade of gray. Map to BLACK or WHITE.
-    // We split the luminance at the halfway point (382 = (255*3)/2)
-    if ((static_cast<int>(color.r) + color.g + color.b) > 382) {
-      return hw_white;
-    }
-    return hw_black;
+    return color_to_mono(color) ? hw_white : hw_black;
  }

  // --- Step 2: Check for Primary/Secondary Colors ---
@@ -96,7 +113,6 @@ constexpr NATIVE_COLOR color_to_bwr(Color color, NATIVE_COLOR hw_black, NATIVE_C
 * @param hw_green  Native value for green
 * @param hw_blue   Native value for blue
 * @return          Converted native hardware color value
- * @internal Constexpr. Does not depend on side effects ("pure").
 */
 template<typename NATIVE_COLOR>
 constexpr NATIVE_COLOR color_to_bwyrgb(Color color, NATIVE_COLOR hw_black, NATIVE_COLOR hw_white,
@@ -105,10 +121,7 @@ constexpr NATIVE_COLOR color_to_bwyrgb(Color color, NATIVE_COLOR hw_black, NATIV
  const auto [min_rgb, max_rgb] = std::minmax({color.r, color.g, color.b});

  if ((max_rgb - min_rgb) < COLORCONV_GRAY_THRESHOLD) {
-    if ((static_cast<int>(color.r) + color.g + color.b) > 382) {
-      return hw_white;
-    }
-    return hw_black;
+    return color_to_mono(color) ? hw_white : hw_black;
  }

  const bool r_on = (color.r > 128);
@@ -158,7 +171,6 @@ constexpr NATIVE_COLOR color_to_bwyrgb(Color color, NATIVE_COLOR hw_black, NATIV
 * @param hw_blue   Native value for blue
 * @param hw_orange Native value for orange
 * @return          Converted native hardware color value
- * @internal Constexpr. Does not depend on side effects ("pure").
 */
 template<typename NATIVE_COLOR>
 constexpr NATIVE_COLOR color_to_bwyrgbo(Color color, NATIVE_COLOR hw_black, NATIVE_COLOR hw_white,
@@ -167,10 +179,7 @@ constexpr NATIVE_COLOR color_to_bwyrgbo(Color color, NATIVE_COLOR hw_black, NATI
  const auto [min_rgb, max_rgb] = std::minmax({color.r, color.g, color.b});

  if ((max_rgb - min_rgb) < COLORCONV_GRAY_THRESHOLD) {
-    if ((static_cast<int>(color.r) + color.g + color.b) > 382) {
-      return hw_white;
-    }
-    return hw_black;
+    return color_to_mono(color) ? hw_white : hw_black;
  }

  const bool r_on = (color.r > 128);
@@ -1,7 +1,9 @@
+from collections.abc import Callable
 import importlib
 import pkgutil
+from typing import Any

-from esphome import core, pins
+from esphome import automation, core, pins
 import esphome.codegen as cg
 from esphome.components import display, spi
 from esphome.components.display import CONF_SHOW_TEST_CARD, validate_rotation
@@ -54,6 +56,12 @@ EPaperBase = epaper_spi_ns.class_(
 )
 Transform = epaper_spi_ns.enum("Transform")

+automation.register_apply_action(
+    "epaper_spi.full_update_next",
+    automation.maybe_simple_id({cv.Required(CONF_ID): cv.use_id(EPaperBase)}),
+    automation.ApplyCall("request_full_update()"),
+)
+
 # Import all models dynamically from the models package
 for module_info in pkgutil.iter_modules(models.__path__):
    importlib.import_module(f".models.{module_info.name}", package=__package__)
@@ -70,6 +78,23 @@ DIMENSION_SCHEMA = cv.Schema(
 TRANSFORM_OPTIONS = {CONF_MIRROR_X, CONF_MIRROR_Y, CONF_SWAP_XY}


+def _full_update_every_validator(
+    model: models.EpaperModel,
+) -> Callable[[Any], int]:
+    if model.get_default("partial_update"):
+        return cv.int_range(1, 255)
+
+    def validate(value: Any) -> int:
+        value = cv.int_range(1, 255)(value)
+        if value != 1:
+            raise cv.Invalid(
+                f"{model.name} does not support partial update; full_update_every must be 1"
+            )
+        return value
+
+    return validate
+
+
 def model_schema(config):
    model = MODELS[config[CONF_MODEL]]
    class_name = epaper_spi_ns.class_(model.class_name, EPaperBase)
@@ -96,7 +121,9 @@ def model_schema(config):
                    cv.Required(CONF_MIRROR_Y): cv.boolean,
                }
            ),
-            cv.Optional(CONF_FULL_UPDATE_EVERY, default=1): cv.int_range(1, 255),
+            cv.Optional(
+                CONF_FULL_UPDATE_EVERY, default=1
+            ): _full_update_every_validator(model),
            model.option(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
            model.option(CONF_CS_PIN): pins.gpio_output_pin_schema,
            model.option(CONF_DC_PIN, fallback=None): pins.gpio_output_pin_schema,
@@ -132,8 +159,15 @@ def customise_schema(config):
        extra=cv.ALLOW_EXTRA,
    )(config)
    model = MODELS[config[CONF_MODEL]]
+    model.check_requirements()
    config = model_schema(config)(config)
+    config = model.validate_config(config)
    width, height = model.get_dimensions(config)
+    if width % (width_multiple := model.get_default("width_multiple", 1)):
+        raise cv.Invalid(
+            f"{model.name} requires a width that is a multiple of {width_multiple}",
+            path=[CONF_DIMENSIONS],
+        )
    display.add_metadata(
        config[CONF_ID],
        width,
@@ -196,6 +196,15 @@ void EPaperBase::process_state_() {
      break;
    case EPaperState::UPDATE:
      this->do_update_();  // Calls ESPHome (current page) lambda
+      if (this->full_update_requested_) {
+        // Refresh the whole panel even if nothing was drawn
+        this->full_update_requested_ = false;
+        this->update_count_ = 0;
+        this->x_low_ = 0;
+        this->y_low_ = 0;
+        this->x_high_ = this->width_;
+        this->y_high_ = this->height_;
+      }
      if (this->x_high_ < this->x_low_ || this->y_high_ < this->y_low_) {
        this->set_state_(EPaperState::IDLE);
        return;
@@ -327,9 +336,9 @@ void HOT EPaperBase::draw_pixel_at(int x, int y, Color color) {
    return;
  const size_t byte_position = y * this->row_width_ + x / 8;
  const uint8_t bit_position = x % 8;
-  const uint8_t pixel_bit = 0x80 >> bit_position;
+  const uint8_t pixel_bit = 0x80u >> bit_position;
  const auto original = this->buffer_[byte_position];
-  if ((color_to_bit(color) == 0)) {
+  if (color_to_mono(color) == 0) {
    this->buffer_[byte_position] = original & ~pixel_bit;
  } else {
    this->buffer_[byte_position] = original | pixel_bit;
@@ -1,5 +1,6 @@
 #pragma once

+#include "colorconv.h"
 #include "esphome/components/display/display.h"
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/split_buffer/split_buffer.h"
@@ -80,15 +81,7 @@ class EPaperBase : public Display,

  DisplayType get_display_type() override { return this->display_type_; };

-  // Default implementations for monochrome displays
-  static uint8_t color_to_bit(Color color) {
-    // It's always a shade of gray. Map to BLACK or WHITE.
-    // We split the luminance at a suitable point
-    if ((color.r + color.g + color.b) >= 382) {
-      return 1;
-    }
-    return 0;
-  }
+  // Default implementation for monochrome displays
  void fill(Color color) override {
    // If clipping is active, fall back to base implementation
    if (this->get_clipping().is_set()) {
@@ -96,7 +89,7 @@ class EPaperBase : public Display,
      return;
    }

-    auto pixel_color = color_to_bit(color) ? 0xFF : 0x00;
+    auto pixel_color = color_to_mono(color) ? 0xFF : 0x00;

    // We store 8 pixels per byte
    this->buffer_.fill(pixel_color);
@@ -114,6 +107,8 @@ class EPaperBase : public Display,
  int get_width() override { return this->effective_transform_ & SWAP_XY ? this->height_ : this->width_; }
  int get_height() override { return this->effective_transform_ & SWAP_XY ? this->width_ : this->height_; }
  void draw_pixel_at(int x, int y, Color color) override;
+  // Make the next update a full one. Applied when that update starts, so one in progress is not affected.
+  void request_full_update() { this->full_update_requested_ = true; }

 protected:
  int get_height_internal() override { return this->height_; };
@@ -185,6 +180,7 @@ class EPaperBase : public Display,
  uint8_t transform_{};
  uint8_t effective_transform_{};
  uint8_t update_count_{};
+  bool full_update_requested_{};
  // these values represent the bounds of the updated buffer. Note that x_high and y_high
  // point to the pixel past the last one updated, i.e. may range up to width/height.
  uint16_t x_low_{}, y_low_{}, x_high_{}, y_high_{};
@@ -9,8 +9,8 @@ namespace esphome::epaper_spi {
 class EPaperMono : public EPaperBase {
 public:
  EPaperMono(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
-             size_t init_sequence_length)
-      : EPaperBase(name, width, height, init_sequence, init_sequence_length, DISPLAY_TYPE_BINARY) {
+             size_t init_sequence_length, DisplayType display_type = DISPLAY_TYPE_BINARY)
+      : EPaperBase(name, width, height, init_sequence, init_sequence_length, display_type) {
    this->buffer_length_ = (width + 7) / 8 * height;  // 8 pixels per byte, rounded up
  }

@@ -0,0 +1,101 @@
+#include "epaper_spi_ssd1677.h"
+
+#include <algorithm>
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome::epaper_spi {
+static constexpr const char *const TAG = "epaper_spi.ssd1677";
+
+void EPaperSSD1677::setup() {
+  EPaperMono::setup();
+  if (!this->is_failed())
+    this->init_comparison_frame_();
+}
+
+void EPaperSSD1677::init_comparison_frame_() {
+  if (!this->is_using_partial_update_())
+    return;
+  if (!this->sent_.init(this->plane_row_length_() * this->height_)) {
+    ESP_LOGW(TAG, "No memory for the comparison frame; partial updates will degrade unchanged areas");
+  }
+}
+
+void EPaperSSD1677::plane_row(size_t y, uint8_t *out) {
+  const size_t row_length = this->plane_row_length_();
+  const size_t data_idx = y * row_length;
+  for (size_t i = 0; i != row_length; i++)
+    out[i] = this->buffer_[data_idx + i];
+}
+
+// Nothing a partial update needs is kept in controller RAM any more, so skip the reset for those.
+bool EPaperSSD1677::reset() {
+  if (this->update_count_ != 0 && this->sent_.is_valid())
+    return true;
+  return EPaperMono::reset();
+}
+
+// The window always covers the whole panel, so each plane is the frame's bytes in order. Where
+// those bytes are already stored as the plane needs them (the comparison frame, and a 1-bit
+// buffer) they are written straight from the buffer, as many at a time as the time slice allows;
+// otherwise they are built a row at a time by plane_row().
+bool HOT EPaperSSD1677::transfer_data() {
+  if (!this->sent_.is_valid())
+    return EPaperMono::transfer_data();
+
+  const auto start_time = millis();
+  if (this->current_data_index_ == 0) {
+    if (this->plane_ == 0) {
+      this->x_low_ = 0;
+      this->x_high_ = this->width_;
+      this->y_low_ = 0;
+      this->y_high_ = this->height_;
+    }
+    this->set_window();
+    this->command(this->plane_ == 0 ? 0x26 : 0x24);
+  }
+  // A full update ignores 0x26, and the copy may not hold a real frame yet (first update after
+  // boot): send the new frame to both planes.
+  const bool send_copy = this->plane_ == 0 && this->update_count_ != 0;
+  const bool direct = send_copy || this->buffer_is_plane();
+  const auto &source = send_copy ? this->sent_ : this->buffer_;
+  const size_t row_length = this->plane_row_length_();
+  const size_t plane_length = row_length * this->height_;
+  // Roughly what the bus moves in one time slice, so a slice is not overrun by much
+  const size_t max_chunk = std::max<size_t>(this->data_rate_ / 8000 * MAX_TRANSFER_TIME, MAX_TRANSFER_SIZE);
+  SmallBufferWithHeapFallback<128> row_alloc(direct ? 0 : row_length);
+  this->start_data_();
+  while (this->current_data_index_ != plane_length) {
+    size_t length;
+    const uint8_t *data;
+    if (direct) {
+      data = source.get_span(this->current_data_index_, length);
+      length = std::min(length, max_chunk);
+    } else {
+      // Always at the start of a row here, since this path sends whole rows only
+      this->plane_row(this->current_data_index_ / row_length, row_alloc.get());
+      data = row_alloc.get();
+      length = row_length;
+    }
+    this->write_array(data, length);
+    if (this->plane_ == 1)
+      this->sent_.write(this->current_data_index_, data, length);
+    this->current_data_index_ += length;
+    if (this->current_data_index_ != plane_length && millis() - start_time > MAX_TRANSFER_TIME) {
+      // Let the main loop run and come back next loop
+      this->disable();
+      return false;
+    }
+  }
+  this->disable();
+  this->current_data_index_ = 0;
+  if (this->plane_ == 0) {
+    this->plane_ = 1;
+    return false;
+  }
+  this->plane_ = 0;
+  return true;
+}
+
+}  // namespace esphome::epaper_spi
@@ -0,0 +1,49 @@
+#pragma once
+
+#include "epaper_spi_mono.h"
+
+namespace esphome::epaper_spi {
+
+/**
+ * Monochrome SSD1677 with partial refreshes that leave unchanged pixels alone.
+ *
+ * A partial refresh drives each pixel from the pair (RAM 0x26 = the image on the panel,
+ * RAM 0x24 = the new image) across the whole panel; the RAM window only scopes a write.
+ * EPaperMono writes 0x26 once and afterwards only the changed window of 0x24, which relies on
+ * the controller's RAM being unchanged from one update to the next. On this controller it is not:
+ * the hardware reset at the start of each update loses it, and even without resets, keeping 0x26
+ * in step one window at a time left unchanged areas alternating between older frames. Either way
+ * unchanged pixels get driven on every partial and wash out.
+ *
+ * So before every refresh this class writes both planes over the whole panel: 0x26 from a copy of
+ * the frame last sent, 0x24 from the buffer. GxEPD2 likewise rewrites both planes after each
+ * partial on this controller. The copy is taken as the data goes out, not from the buffer, which
+ * may already hold the next frame by the time the refresh completes.
+ */
+class EPaperSSD1677 : public EPaperMono {
+ public:
+  EPaperSSD1677(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+                size_t init_sequence_length, DisplayType display_type = DISPLAY_TYPE_BINARY)
+      : EPaperMono(name, width, height, init_sequence, init_sequence_length, display_type) {}
+
+  void setup() override;
+
+ protected:
+  // Allocates the comparison frame when partial updates are enabled. Separate from setup() so it
+  // can run without a bus.
+  void init_comparison_frame_();
+  // Bytes in one row of a RAM plane: 8 pixels per byte, whatever the buffer holds.
+  size_t plane_row_length_() const { return (this->width_ + 7) / 8; }
+  // Whether the buffer already holds the frame as a RAM plane does, so it can be sent as it is.
+  // A subclass with a deeper buffer returns false and overrides plane_row().
+  virtual bool buffer_is_plane() const { return true; }
+  // Row y of the frame as a RAM plane holds it, 1 bit per pixel with 1 = white.
+  virtual void plane_row(size_t y, uint8_t *out);
+  bool reset() override;
+  bool transfer_data() override;
+
+  split_buffer::SplitBuffer sent_{};  // the frame last sent to 0x24, i.e. what the panel shows
+  uint8_t plane_{0};                  // 0 while sending 0x26, 1 while sending 0x24
+};
+
+}  // namespace esphome::epaper_spi
@@ -0,0 +1,129 @@
+#include "epaper_spi_ssd1677_gray4.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome::epaper_spi {
+
+static constexpr const char *const TAG = "epaper_spi.ssd1677_gray4";
+
+// Combine two source bytes (4 pixels each, 2 bits per pixel, most significant pixel first) into
+// one plane byte covering the same 8 pixels (1 bit per pixel), choosing high or low bit
+static uint8_t plane_byte(uint8_t first, uint8_t second, bool high_bit) {
+  uint8_t out = 0;
+  for (const uint8_t src : {first, second}) {
+    for (uint8_t shift = 6;; shift -= 2) {
+      const uint8_t level = (src >> shift) & 0x03;
+      out = (uint8_t) ((out << 1) | (high_bit ? (level >> 1) : (level & 1)));
+      if (shift == 0)
+        break;
+    }
+  }
+  return out;
+}
+
+void EPaperSSD1677Gray4::fill(Color color) {
+  if (this->get_clipping().is_set()) {
+    // Falls back to the generic per-pixel implementation for the clipped rectangle.
+    EPaperBase::fill(color);
+    return;
+  }
+  const uint8_t level = color_to_gray4(color);
+  this->buffer_.fill((uint8_t) (level | (level << 2) | (level << 4) | (level << 6)));
+  this->x_low_ = 0;
+  this->y_low_ = 0;
+  this->x_high_ = this->width_;
+  this->y_high_ = this->height_;
+}
+
+void HOT EPaperSSD1677Gray4::draw_pixel_at(int x, int y, Color color) {
+  if (!this->rotate_coordinates_(x, y))
+    return;
+  const uint8_t level = color_to_gray4(color);
+  const size_t byte_position = (size_t) y * this->row_width_ + x / 4;
+  const uint8_t shift = (uint8_t) (6 - 2 * (x % 4));  // most significant pixel first
+  const uint8_t original = this->buffer_[byte_position];
+  this->buffer_[byte_position] = (uint8_t) ((original & ~(0x03 << shift)) | (level << shift));
+}
+
+// A partial update reduces each pixel to its high bit: levels 2 and 3 are light, 0 and 1 dark.
+void EPaperSSD1677Gray4::plane_row(size_t y, uint8_t *out) {
+  const size_t src_row = y * this->row_width_;
+  for (size_t i = 0; i != this->plane_row_length_(); i++)
+    out[i] = plane_byte(this->buffer_[src_row + 2 * i], this->buffer_[src_row + 2 * i + 1], true);
+}
+
+// the high bit of every pixel's level goes to the new (bw) plane
+// (0x24), the low bit to the old (red) plane (0x26)
+bool HOT EPaperSSD1677Gray4::transfer_data() {
+  if (this->is_partial_push_())
+    return EPaperSSD1677::transfer_data();
+
+  auto start_time = millis();
+  const bool first_pass = this->send_red_;
+  if (this->current_data_index_ == 0) {
+    if (first_pass) {
+      // With partial updates enabled the window follows the changed area, but the four-level
+      // refresh drives every pixel from both planes, and the reset before it does not keep RAM.
+      this->x_low_ = 0;
+      this->x_high_ = this->width_;
+      this->y_low_ = 0;
+      this->y_high_ = this->height_;
+      this->set_window();
+    }
+    this->command(first_pass ? 0x24 : 0x26);
+    this->current_data_index_ = this->y_low_;
+  }
+  const size_t plane_row_length = (this->x_high_ - this->x_low_) / 8;
+  // Stack-backed for every panel width in practice; only a custom `dimensions:` far wider than any
+  // supported panel would fall back to the heap.
+  SmallBufferWithHeapFallback<128> bytes_to_send_alloc(plane_row_length);
+  uint8_t *bytes_to_send = bytes_to_send_alloc.get();
+  ESP_LOGV(TAG, "Writing %u bytes at line %zu at %ums", plane_row_length, this->current_data_index_,
+           (unsigned) millis());
+  this->start_data_();
+  while (this->current_data_index_ != this->y_high_) {
+    const size_t src_row = this->current_data_index_ * this->row_width_ + this->x_low_ / 4;
+    for (size_t i = 0; i != plane_row_length; i++) {
+      const uint8_t plane = plane_byte(this->buffer_[src_row + 2 * i], this->buffer_[src_row + 2 * i + 1], first_pass);
+      // The OTP grayscale waveform treats data as inverted relative to monochrome
+      bytes_to_send[i] = (uint8_t) ~plane;
+      // What the next partial update compares against: the high bits, as a black-and-white frame.
+      if (first_pass && this->sent_.is_valid())
+        this->sent_[this->current_data_index_ * plane_row_length + i] = plane;
+    }
+    ++this->current_data_index_;
+    this->write_array(bytes_to_send, plane_row_length);
+    if (millis() - start_time > MAX_TRANSFER_TIME) {
+      // Let the main loop run and come back next loop
+      this->disable();
+      return false;
+    }
+  }
+
+  this->disable();
+  this->current_data_index_ = 0;
+  if (first_pass) {
+    this->send_red_ = false;
+    return false;
+  }
+  this->send_red_ = true;
+  return true;
+}
+
+void EPaperSSD1677Gray4::refresh_screen(bool partial) {
+  if (this->is_partial_push_()) {
+    ESP_LOGV(TAG, "Black-and-white partial refresh");
+    // The border follows the LUT selected in 0x3C. The model's setting (sent with the init
+    // sequence) picks the LUT that is white under the four-level waveform's inverted data; under
+    // the black-and-white waveform that LUT drives black and the border darkens, so use LUT1.
+    this->cmd_data(0x3C, {0x01});
+    EPaperSSD1677::refresh_screen(true);
+    return;
+  }
+  ESP_LOGV(TAG, "Four-level refresh");
+  this->cmd_data(0x1A, {0x67, 0x00});  // force temperature by OTP
+  this->cmd_data(0x22, {0xD7});        // four-level update sequence, panel's OTP waveform
+  this->command(0x20);                 // master activation
+}
+
+}  // namespace esphome::epaper_spi
@@ -0,0 +1,49 @@
+#pragma once
+
+#include "colorconv.h"
+#include "epaper_spi_ssd1677.h"
+
+namespace esphome::epaper_spi {
+
+/**
+ * Four-level grayscale for SSD1677 panels.
+ *
+ * The SSD1677 has two independent 1-bit RAM planes, normally used for a
+ * black/white and a red plane. This class writes image data to both,
+ * splitting each pixel's 2-bit gray level across them, and triggers the
+ * panel's own OTP grayscale waveform instead of the normal monochrome update
+ * sequence. No custom LUT upload needed for any currently supported panel,
+ * the OTP waveform is used instead.
+ *
+ * The framebuffer therefore packs 2 bits per pixel (4 per byte, most
+ * significant pixel first) instead of EPaperMono's 1 bit.
+ *
+ * The grayscale waveform has no partial form: master activation redraws the whole panel
+ * regardless of the RAM window. So a full update is a four-level refresh, and when partial updates
+ * are enabled (full_update_every > 1, which the model only allows on explicit request) a partial
+ * update is EPaperSSD1677's black-and-white one, each pixel reduced to light or dark. The partial
+ * waveform also drives unchanged pixels towards black or white, so from the first partial update
+ * the whole panel loses its gray levels until the next full update.
+ */
+class EPaperSSD1677Gray4 : public EPaperSSD1677 {
+ public:
+  EPaperSSD1677Gray4(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+                     size_t init_sequence_length)
+      : EPaperSSD1677(name, width, height, init_sequence, init_sequence_length, DISPLAY_TYPE_GRAYSCALE) {
+    this->row_width_ = (width + 3) / 4;  // 4 pixels per byte
+    this->buffer_length_ = (size_t) this->row_width_ * height;
+  }
+
+  void fill(Color color) override;
+  void draw_pixel_at(int x, int y, Color color) override;
+
+ protected:
+  // A partial update if partial updates are enabled and this is not a full one.
+  bool is_partial_push_() const { return this->update_count_ != 0 && this->sent_.is_valid(); }
+  bool buffer_is_plane() const override { return false; }
+  void plane_row(size_t y, uint8_t *out) override;
+  void refresh_screen(bool partial) override;
+  bool transfer_data() override;
+};
+
+}  // namespace esphome::epaper_spi
@@ -2,7 +2,9 @@ from typing import Any, Self

 import esphome.config_validation as cv
 from esphome.const import CONF_DIMENSIONS, CONF_HEIGHT, CONF_WIDTH
+from esphome.core import CORE
 from esphome.cpp_generator import MockObj
+from esphome.types import ConfigType


 class EpaperModel:
@@ -48,6 +50,16 @@ class EpaperModel:
        """
        return {}

+    def validate_config(self, config: ConfigType) -> ConfigType:
+        """
+        Validate the configuration as a whole, once the schema has been applied.
+        The base implementation accepts it unchanged; specific models override this for
+        rules that span several options.
+        :param config: The validated configuration
+        :return: The configuration, possibly updated
+        """
+        return config
+
    async def to_code(self, var: MockObj, config: dict) -> dict:
        """
        Generate model-specific code for the options added by add_options().
@@ -89,3 +101,26 @@ class EpaperModel:
        defaults = self.defaults.copy()
        defaults.update(kwargs)
        return self.__class__(name, initsequence=tuple(initsequence), **defaults)
+
+    def check_requirements(self) -> None:
+        """
+        Raise a friendly error if any component this model requires is not configured.
+
+        This runs during schema validation (before ID references are resolved) so that a
+        model whose default pins live on a pin expander reports the missing expander clearly
+        instead of a cryptic "Couldn't find ID" from the unresolved pin reference.
+        """
+        if requirements := self.get_default("requires", set()):
+            # ``raw_config`` is populated before any component schema runs during a real
+            # validation, so presence of a required component is simply a top-level key.
+            # When it is absent (e.g. a unit test that invokes the schema directly) there
+            # is no config to check against, so skip.
+            global_config = CORE.raw_config
+            if global_config is None:
+                return
+            missing = {x for x in requirements if x not in global_config}
+            if missing:
+                reqstr = ", ".join(f"'{x}'" for x in sorted(missing))
+                raise cv.Invalid(
+                    f"{self.name} requires component{'s' if len(missing) > 1 else ''} {reqstr} to be configured"
+                )
@@ -10,7 +10,9 @@ from . import EpaperModel

 class JD79660(EpaperModel):
    def __init__(self, name, class_name="EPaperJD79660", fast_update=None, **kwargs):
-        super().__init__(name, class_name, **kwargs)
+        # Only a fast_update sequence lets the driver do anything but a full refresh
+        kwargs.setdefault("partial_update", fast_update is not None)
+        super().__init__(name, class_name=class_name, **kwargs)
        self.fast_update = fast_update

    def option(self, name, fallback=cv.UNDEFINED) -> cv.Optional | cv.Required:
@@ -1,12 +1,56 @@
-from esphome.const import CONF_DATA_RATE
+from typing import Any
+
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA_RATE, CONF_FULL_UPDATE_EVERY
+from esphome.types import ConfigType

 from . import EpaperModel

+CONF_BORDER_WAVEFORM = "border_waveform"
+CONF_MONOCHROME_PARTIAL_UPDATES = "monochrome_partial_updates"
+
+# partial_update value for models whose partial updates are black and white only
+MONOCHROME = "monochrome"
+

 class SSD1677(EpaperModel):
-    def __init__(self, name, class_name="EPaperMono", data_rate="20MHz", **defaults):
+    def __init__(
+        self,
+        name: str,
+        class_name: str = "EPaperSSD1677",
+        data_rate: str = "20MHz",
+        border_waveform: int = 0x01,
+        **defaults: Any,
+    ) -> None:
        defaults[CONF_DATA_RATE] = data_rate
-        super().__init__(name, class_name, **defaults)
+        defaults[CONF_BORDER_WAVEFORM] = border_waveform
+        defaults.setdefault("partial_update", True)
+        super().__init__(name, class_name=class_name, **defaults)
+
+    def get_config_options(self) -> dict:
+        options = {
+            self.option(CONF_BORDER_WAVEFORM): cv.hex_uint8_t,
+        }
+        if self.get_default("partial_update") == MONOCHROME:
+            options[cv.Optional(CONF_MONOCHROME_PARTIAL_UPDATES, default=False)] = (
+                cv.boolean
+            )
+        return options
+
+    def validate_config(self, config: ConfigType) -> ConfigType:
+        if (
+            self.get_default("partial_update") == MONOCHROME
+            and config[CONF_FULL_UPDATE_EVERY] > 1
+            and not config[CONF_MONOCHROME_PARTIAL_UPDATES]
+        ):
+            raise cv.Invalid(
+                f"{self.name} can only update partially in black and white, and a partial "
+                "update reduces the whole panel to black and white until the next full "
+                f"update. Set '{CONF_MONOCHROME_PARTIAL_UPDATES}: true' to accept this, "
+                "or leave full_update_every at 1",
+                path=[CONF_FULL_UPDATE_EVERY],
+            )
+        return config

    # fmt: off
    def get_init_sequence(self, config: dict):
@@ -15,13 +59,14 @@ class SSD1677(EpaperModel):
            (0x18, 0x80),    # Select internal Temp sensor
            (0x0C, 0xAE, 0xC7, 0xC3, 0xC0, 0x80),  # inrush current level 2
            (0x01, (height - 1) % 256, (height - 1) // 256, 0x02),    # Set gate limit (number of rows-1)
-            (0x3C, 0x01),    # Set border waveform
+            (0x3C, config[CONF_BORDER_WAVEFORM]),    # Set border waveform
            (0x11, 3),      # Set transform
        )


 ssd1677 = SSD1677("ssd1677")

+
 wave_4_26 = ssd1677.extend(
    "waveshare-4.26in",
    width=800,
@@ -52,7 +97,8 @@ ssd1677.extend(
    mirror_x=True,
 )

-ssd1677.extend(
+# Sticky - monochrome version
+seeed_sticky = ssd1677.extend(
    "seeed-reterminal-sticky",
    width=800,
    height=480,
@@ -63,4 +109,15 @@ ssd1677.extend(
    reset_pin=17,
    busy_pin=18,
    data_rate="10MHz",
+    requires={"psram"},
+)
+
+# Sticky - 4 level grayscale; partial updates only in black and white, on request
+seeed_sticky.extend(
+    "seeed-reterminal-sticky-gray4",
+    class_name="EPaperSSD1677Gray4",
+    border_waveform=0x00,
+    partial_update=MONOCHROME,
+    # each plane byte is built from two whole buffer bytes
+    width_multiple=8,
 )
@@ -6,7 +6,8 @@ from . import EpaperModel
 class SSD1683(EpaperModel):
    def __init__(self, name, class_name="EPaperSSD1683", data_rate="20MHz", **defaults):
        defaults[CONF_DATA_RATE] = data_rate
-        super().__init__(name, class_name, **defaults)
+        defaults.setdefault("partial_update", True)
+        super().__init__(name, class_name=class_name, **defaults)

    # fmt: off
    def get_init_sequence(self, config: dict):
@@ -32,7 +32,8 @@ class UC8179(EpaperModel):
        **defaults: Any,
    ) -> None:
        defaults.setdefault(CONF_DATA_RATE, data_rate)
-        super().__init__(name, class_name, **defaults)
+        defaults.setdefault("partial_update", True)
+        super().__init__(name, class_name=class_name, **defaults)

    def get_init_sequence(self, config: dict) -> tuple:
        """Generate the initialization sequence for UC8179 mono displays.
@@ -6,8 +6,12 @@ from . import EpaperModel


 class WaveshareModel(EpaperModel):
-    def __init__(self, name, lut, lut_partial=None, **defaults):
-        super().__init__(name, "EpaperWaveshare", **defaults)
+    def __init__(
+        self, name, lut, lut_partial=None, class_name="EpaperWaveshare", **defaults
+    ):
+        # A partial LUT is what lets EpaperWaveshare do partial refresh
+        defaults.setdefault("partial_update", lut_partial is not None)
+        super().__init__(name, class_name=class_name, **defaults)
        self.lut = lut
        self.lut_partial = lut_partial

@@ -30,7 +30,7 @@ static const gpio_hal_context_t GPIO_HAL = {.dev = GPIO_HAL_GET_HW(GPIO_PORT_0)}
 bool ESP32InternalGPIOPin::isr_service_installed = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

 static gpio_mode_t flags_to_mode(gpio::Flags flags) {
-  flags = (gpio::Flags)(flags & ~(gpio::FLAG_PULLUP | gpio::FLAG_PULLDOWN));
+  flags = flags & (gpio::FLAG_INPUT | gpio::FLAG_OUTPUT | gpio::FLAG_OPEN_DRAIN);
  if (flags == gpio::FLAG_INPUT)
    return GPIO_MODE_INPUT;
  if (flags == gpio::FLAG_OUTPUT)
@@ -474,12 +474,17 @@ def final_validation(config: ConfigType) -> None:

    # Check if hosted bluetooth is being used
    if "esp32_hosted" in full_config:
+        from esphome.components.esp32_hosted import uses_esp_hosted_3x
+
        add_idf_sdkconfig_option("CONFIG_BT_CLASSIC_ENABLED", False)
        add_idf_sdkconfig_option("CONFIG_BT_BLE_ENABLED", True)
        add_idf_sdkconfig_option("CONFIG_BT_BLUEDROID_ENABLED", True)
        add_idf_sdkconfig_option("CONFIG_BT_CONTROLLER_DISABLED", True)
-        add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID", True)
-        add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_BLUEDROID_HCI_VHCI", True)
+        if uses_esp_hosted_3x():
+            add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_HOST_FEAT_BT", True)
+        else:
+            add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID", True)
+            add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_BLUEDROID_HCI_VHCI", True)

    # Check if BLE Client is needed (via esp32_ble_tracker or esp32_ble_client)
    has_ble_client = (
@@ -6,16 +6,21 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
 #include <esp_bt.h>
 #else
 #include "esphome/components/watchdog/watchdog.h"
 #include <cinttypes>
 extern "C" {
 #include <esp_hosted.h>
+#ifndef CONFIG_ESP_HOSTED_HOST_FEAT_BT
 #include <esp_hosted_misc.h>
 #include <esp_hosted_bluedroid.h>
+#endif
 }
+#ifdef CONFIG_ESP_HOSTED_HOST_FEAT_BT
+#include <esp_hosted_bt_host_stack.h>
+#endif
 #endif
 #include <esp_bt_device.h>
 #include <esp_bt_main.h>
@@ -35,7 +40,7 @@ namespace esphome::esp32_ble {

 static const char *const TAG = "esp32_ble";

-#ifdef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifdef CONFIG_BT_CONTROLLER_DISABLED
 // Bringing up the remote BT controller issues synchronous RPCs to the
 // co-processor with 5 second response timeouts, and the default task watchdog
 // is also 5 seconds. If the co-processor firmware does not answer (for example
@@ -43,8 +48,9 @@ static const char *const TAG = "esp32_ble";
 // device before the RPC could return an error, causing a boot loop. Raise the
 // watchdog for the duration of the bring-up so failures surface as error
 // returns instead. 60 seconds covers the worst case: transport reconnect
-// (up to ~20s), version preflight (1s), controller init/enable (5s each) and
-// the bluedroid host bring-up over the hosted HCI transport.
+// (up to ~20s), version preflight (1s), the controller init retry window
+// (5s of 5s RPCs), controller enable (5s) and the bluedroid host bring-up
+// over the hosted HCI transport.
 static constexpr uint32_t HOSTED_BT_WDT_TIMEOUT_MS = 60000;
 #endif

@@ -202,10 +208,10 @@ void ESP32BLE::advertising_init_() {

 bool ESP32BLE::ble_setup_() {
  esp_err_t err;
-#ifdef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifdef CONFIG_BT_CONTROLLER_DISABLED
  watchdog::WatchdogManager wdt(HOSTED_BT_WDT_TIMEOUT_MS);
 #endif
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
    // start bt controller
    if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE) {
@@ -239,8 +245,7 @@ bool ESP32BLE::ble_setup_() {
  }

  // Fast preflight (1 second RPC timeout): verifies the co-processor answers
-  // RPCs at all before the 5 second timeout BT controller RPCs below, and
-  // before hosted_hci_bluedroid_open(), which aborts if the transport is down.
+  // RPCs at all before the 5 second timeout BT controller RPCs below.
  esp_hosted_coprocessor_fwver_t fw_ver{};
  if (esp_hosted_get_coprocessor_fwversion(&fw_ver) != ESP_OK) {
    ESP_LOGE(TAG, "Co-processor not responding; BLE disabled. Update its firmware with the esp32_hosted "
@@ -249,6 +254,19 @@ bool ESP32BLE::ble_setup_() {
  }
  ESP_LOGD(TAG, "Co-processor firmware %" PRIu32 ".%" PRIu32 ".%" PRIu32, fw_ver.major1, fw_ver.minor1, fw_ver.patch1);

+#ifdef CONFIG_ESP_HOSTED_HOST_FEAT_BT
+  esp_hosted_bt_host_stack_cfg_t bt_cfg{};
+  bt_cfg.stack = ESP_HOSTED_BT_HOST_STACK_BLUEDROID;
+  bt_cfg.bring_up_controller = true;
+  bt_cfg.controller_ready_timeout_ms = EH_BT_CTRL_DEFAULT_READY_TIMEOUT_MS;
+  if (esp_hosted_bt_host_stack_setup(&bt_cfg) != ESP_OK) {
+    ESP_LOGE(TAG,
+             "BT controller bring-up failed; co-processor firmware %" PRIu32 ".%" PRIu32 ".%" PRIu32
+             " may lack BT support. Update it with the esp32_hosted update component; BLE disabled",
+             fw_ver.major1, fw_ver.minor1, fw_ver.patch1);
+    return false;
+  }
+#else
  if (esp_hosted_bt_controller_init() != ESP_OK) {
    ESP_LOGE(TAG,
             "BT controller init failed; co-processor firmware %" PRIu32 ".%" PRIu32 ".%" PRIu32
@@ -273,6 +291,7 @@ bool ESP32BLE::ble_setup_() {
      .register_host_callback = hosted_hci_bluedroid_register_host_callback,
  };
  esp_bluedroid_attach_hci_driver(&operations);
+#endif
 #endif

  err = esp_bluedroid_init();
@@ -393,7 +412,7 @@ bool ESP32BLE::ble_setup_() {
 }

 bool ESP32BLE::ble_dismantle_() {
-#ifdef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifdef CONFIG_BT_CONTROLLER_DISABLED
  // Same 5 second RPCs as the bring-up path; see HOSTED_BT_WDT_TIMEOUT_MS
  watchdog::WatchdogManager wdt(HOSTED_BT_WDT_TIMEOUT_MS);
 #endif
@@ -416,7 +435,7 @@ bool ESP32BLE::ble_dismantle_() {
    ESP_LOGD(TAG, "Already deinitialized");
  }

-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_IDLE) {
    // stop bt controller
    if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_ENABLED) {
@@ -440,6 +459,11 @@ bool ESP32BLE::ble_dismantle_() {
      return false;
    }
  }
+#elif defined(CONFIG_ESP_HOSTED_HOST_FEAT_BT)
+  if (esp_hosted_bt_host_stack_teardown() != ESP_OK) {
+    ESP_LOGE(TAG, "esp_hosted_bt_host_stack_teardown failed");
+    return false;
+  }
 #else
  if (esp_hosted_bt_controller_disable() != ESP_OK) {
    ESP_LOGE(TAG, "esp_hosted_bt_controller_disable failed");
@@ -3,7 +3,7 @@

 #ifdef USE_ESP32

-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
 #include <esp_bt.h>
 #endif
 #include <esp_bt_main.h>
@@ -35,7 +35,7 @@ void ESP32BLEBeacon::dump_config() {
    }
  }
  *bpos = '\0';
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  ESP_LOGCONFIG(TAG,
                "  UUID: %s, Major: %u, Minor: %u, Min Interval: %ums, Max Interval: %ums, Measured Power: %d"
                ", TX Power: %ddBm",
@@ -81,7 +81,7 @@ void ESP32BLEBeacon::on_advertise_() {
  ibeacon_adv_data.ibeacon_vendor.measured_power = static_cast<uint8_t>(this->measured_power_);

  esp_err_t err;
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  ESP_LOGD(TAG, "Setting BLE TX power");
  err = esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_ADV, this->tx_power_);
  if (err != ESP_OK) {
@@ -5,7 +5,7 @@

 #ifdef USE_ESP32

-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
 #include <esp_bt.h>
 #endif
 #include <esp_gap_ble_api.h>
@@ -47,7 +47,7 @@ class ESP32BLEBeacon final : public Component {
  void set_min_interval(uint16_t val) { this->min_interval_ = val; }
  void set_max_interval(uint16_t val) { this->max_interval_ = val; }
  void set_measured_power(int8_t val) { this->measured_power_ = val; }
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  void set_tx_power(esp_power_level_t val) { this->tx_power_ = val; }
 #endif
  void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
@@ -61,7 +61,7 @@ class ESP32BLEBeacon final : public Component {
  uint16_t min_interval_{};
  uint16_t max_interval_{};
  int8_t measured_power_{};
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  esp_power_level_t tx_power_{};
 #endif
  esp_ble_adv_params_t ble_adv_params_;
@@ -10,7 +10,7 @@
 #include <nvs_flash.h>
 #include <freertos/FreeRTOSConfig.h>
 #include <esp_bt_main.h>
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
 #include <esp_bt.h>
 #endif
 #include <freertos/task.h>
@@ -7,7 +7,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
 #include <esp_bt.h>
 #endif
 #include <esp_bt_defs.h>
@@ -635,7 +635,7 @@ void ESP32BLETracker::log_unexpected_state_(const char *operation, ScannerState

 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
 void ESP32BLETracker::update_coex_preference_(bool force_ble) {
-#ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#ifndef CONFIG_BT_CONTROLLER_DISABLED
  if (force_ble && !this->coex_prefer_ble_) {
    ESP_LOGD(TAG, "Setting coexistence to Bluetooth to make connection.");
    this->coex_prefer_ble_ = true;
@@ -645,7 +645,7 @@ void ESP32BLETracker::update_coex_preference_(bool force_ble) {
    this->coex_prefer_ble_ = false;
    esp_coex_preference_set(ESP_COEX_PREFER_BALANCE);  // Reset to default
  }
-#endif  // CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
+#endif  // CONFIG_BT_CONTROLLER_DISABLED
 }
 #endif

@@ -1,5 +1,6 @@
 import os
 from pathlib import Path
+import re

 from esphome import pins
 from esphome.components import esp32
@@ -7,15 +8,22 @@ from esphome.components.const import CONF_SLOT, CONF_USE_PSRAM
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CLK_PIN,
+    CONF_COMPONENTS,
    CONF_CS_PIN,
+    CONF_FRAMEWORK,
    CONF_FREQUENCY,
    CONF_MISO_PIN,
    CONF_MOSI_PIN,
+    CONF_NAME,
+    CONF_REF,
    CONF_RESET_PIN,
    CONF_TYPE,
    CONF_VARIANT,
+    KEY_ESP32,
 )
+from esphome.core import CORE
 from esphome.cpp_generator import add_define
+import esphome.final_validate as fv
 from esphome.types import ConfigType

 CODEOWNERS = ["@swoboda1337"]
@@ -23,6 +31,9 @@ DEPENDENCIES = ["esp32"]
 # esp32_ble raises the task watchdog around the remote BT controller bring-up
 AUTO_LOAD = ["watchdog"]

+# 3.x is opt-in via a pin under esp32.framework.components (needs ESP-IDF 5.5)
+ESP_HOSTED_COMPONENT = "espressif/esp_hosted"
+
 CONF_ACTIVE_HIGH = "active_high"
 CONF_BUS_WIDTH = "bus_width"
 CONF_CMD_PIN = "cmd_pin"
@@ -145,6 +156,34 @@ CONFIG_SCHEMA = cv.typed_schema(
 )


+# Version specs that stay within one major (exact, ^, ~, ~=); other ranges are 3.x
+_PINNED_MAJOR = re.compile(r"^(?:==|\^|~=|~)?(\d+)(?:\.(?:\d+|\*))*$")
+
+
+def user_esp_hosted_major() -> int | None:
+    """Major version of a user-pinned esp_hosted, or None without a pin."""
+    try:
+        full_config = fv.full_config.get()
+    except LookupError:
+        full_config = CORE.config
+    esp32_config = full_config.get(KEY_ESP32) or {}
+    for component in esp32_config.get(CONF_FRAMEWORK, {}).get(CONF_COMPONENTS, []):
+        if component.get(CONF_NAME) != ESP_HOSTED_COMPONENT:
+            continue
+        ref = component.get(CONF_REF, "").strip()
+        if not ref:
+            return 2
+        if match := _PINNED_MAJOR.match(ref):
+            return int(match.group(1))
+        return 3
+    return None
+
+
+def uses_esp_hosted_3x() -> bool:
+    """Whether the user pinned esp_hosted 3.x."""
+    return (major := user_esp_hosted_major()) is not None and major >= 3
+
+
 def _final_validate(config: ConfigType) -> None:
    # The esp_hosted releases compatible with older ESP-IDF versions crash at
    # boot with a heap double free in the SDIO RX path (fixed in esp_hosted
@@ -155,12 +194,34 @@ def _final_validate(config: ConfigType) -> None:
            "Remove the framework version from your configuration to use the "
            "recommended version, or pin a version at or above 5.3."
        )
+    if (major := user_esp_hosted_major()) is None or major < 3:
+        return
+    if idf_ver < cv.Version(5, 5, 0):
+        raise cv.Invalid(
+            f"esp_hosted 3.x requires ESP-IDF 5.5 or newer, got {idf_ver}. "
+            f"Remove the {ESP_HOSTED_COMPONENT} pin from esp32.framework."
+            "components to stay on the 2.x line, or use ESP-IDF 5.5 or newer."
+        )
+    if not config[CONF_ACTIVE_HIGH]:
+        raise cv.Invalid(
+            "esp_hosted 3.x always parks the reset line high with a low pulse, so "
+            "'active_high: false' cannot be expressed on it. Remove the "
+            f"{ESP_HOSTED_COMPONENT} pin from esp32.framework.components to stay "
+            "on the 2.x line."
+        )
+    if config[CONF_TYPE] == "sdio" and config[CONF_BUS_WIDTH] == 1:
+        raise cv.Invalid(
+            "esp_hosted 3.x cannot be built with a 1-bit SDIO bus "
+            "(espressif/esp-hosted-mcu#245). Remove the "
+            f"{ESP_HOSTED_COMPONENT} pin from esp32.framework.components to stay "
+            "on the 2.x line, or use a 4-bit bus."
+        )


 FINAL_VALIDATE_SCHEMA = _final_validate


-def _configure_sdio(config: ConfigType) -> None:
+def _configure_sdio_2x(config: ConfigType) -> None:
    slot = config[CONF_SLOT]
    esp32.add_idf_sdkconfig_option(
        f"CONFIG_ESP_HOSTED_SDIO_SLOT_{slot}",
@@ -202,7 +263,42 @@ def _configure_sdio(config: ConfigType) -> None:
    )


-def _configure_spi(config: ConfigType) -> None:
+def _configure_sdio_3x(config: ConfigType) -> None:
+    esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_HOST_TRANSPORT_BUS_SDIO", True)
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_SDIO_SLOT_{config[CONF_SLOT]}",
+        True,
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_HOST_SDIO_BUS_WIDTH_{config[CONF_BUS_WIDTH]}",
+        True,
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SDIO_PIN_CLK", config[CONF_CLK_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SDIO_PIN_CMD", config[CONF_CMD_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SDIO_PIN_D0", config[CONF_D0_PIN]
+    )
+    if config[CONF_BUS_WIDTH] == 4:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_HOST_SDIO_PIN_D1", config[CONF_D1_PIN]
+        )
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_HOST_SDIO_PIN_D2", config[CONF_D2_PIN]
+        )
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_HOST_SDIO_PIN_D3", config[CONF_D3_PIN]
+        )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SDIO_CLK_KHZ",
+        int(config[CONF_SDIO_FREQUENCY] // 1000),
+    )
+
+
+def _configure_spi_2x(config: ConfigType) -> None:
    esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_SPI_HOST_INTERFACE", True)
    # SPI mode is set via per-variant choice options
    variant = config[CONF_VARIANT]
@@ -250,11 +346,53 @@ def _configure_spi(config: ConfigType) -> None:
        esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_DR_ACTIVE_LOW", True)


-async def to_code(config: ConfigType) -> None:
-    add_define("USE_ESP32_HOSTED")
-    transport = config[CONF_TYPE]
-    transport_prefix = "SDIO" if transport == "sdio" else "SPI"
+def _configure_spi_3x(config: ConfigType) -> None:
+    esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_HOST_TRANSPORT_BUS_SPI", True)
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SPI_MODE", config[CONF_SPI_MODE]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SPI_CLK_MHZ", int(config[CONF_FREQUENCY] // 1e6)
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SPI_MOSI_GPIO", config[CONF_MOSI_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SPI_MISO_GPIO", config[CONF_MISO_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SPI_CLK_GPIO", config[CONF_CLK_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_SPI_CS_GPIO", config[CONF_CS_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_HANDSHAKE_GPIO", config[CONF_HANDSHAKE_PIN]
+    )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_DATA_READY_GPIO", config[CONF_DATA_READY_PIN]
+    )
+    # Handshake and data_ready polarity
+    if config[CONF_HANDSHAKE_ACTIVE_HIGH]:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_SPI_HANDSHAKE_ACTIVE_HIGH", True
+        )
+    else:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_SPI_HANDSHAKE_ACTIVE_LOW", True
+        )
+    if config[CONF_DATA_READY_ACTIVE_HIGH]:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_SPI_DATAREADY_ACTIVE_HIGH", True
+        )
+    else:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_SPI_DATAREADY_ACTIVE_LOW", True
+        )

+
+def _configure_2x(config: ConfigType) -> None:
+    transport_prefix = "SDIO" if config[CONF_TYPE] == "sdio" else "SPI"
    # Reset polarity
    if config[CONF_ACTIVE_HIGH]:
        esp32.add_idf_sdkconfig_option(
@@ -274,24 +412,11 @@ async def to_code(config: ConfigType) -> None:
        f"CONFIG_SLAVE_IDF_TARGET_{config[CONF_VARIANT]}",  # NOLINT
        True,
    )
-
-    # Transport-specific configuration
-    if transport == "sdio":
-        _configure_sdio(config)
+    if config[CONF_TYPE] == "sdio":
+        _configure_sdio_2x(config)
    else:
-        _configure_spi(config)
-
-    # ESP-NOW-over-hosted shim: only the radio-less ESP32-P4 host needs it (see
-    # the note by _MAX_CUSTOM_MSG_HANDLERS). Enabled for every P4 host, not
-    # gated on the `espnow` component being present: the shim is tiny and the
-    # esp_now_* symbols/CustomRpc calls it defines require these Kconfig options
-    # to link whenever esp_now_hosted.cpp compiles (which is on any P4 host), so
-    # coupling the two keeps the build consistent. When `espnow` is absent the
-    # symbols are simply unused and never register a callback at runtime.
+        _configure_spi_2x(config)
    if esp32.get_esp32_variant() == esp32.VARIANT_ESP32P4:
-        add_define("USE_ESP_NOW_HOSTED")
-        # esp_now_hosted.cpp includes esp_now.h, which esp_wifi provides
-        esp32.include_builtin_idf_component("esp_wifi")
        # esp-hosted's CustomRpc ("peer data transfer") path — off by default.
        esp32.add_idf_sdkconfig_option(
            "CONFIG_ESP_HOSTED_ENABLE_PEER_DATA_TRANSFER", True
@@ -299,18 +424,64 @@ async def to_code(config: ConfigType) -> None:
        esp32.add_idf_sdkconfig_option(
            "CONFIG_ESP_HOSTED_MAX_CUSTOM_MSG_HANDLERS", _MAX_CUSTOM_MSG_HANDLERS
        )
-
    # Place the transport mempool in PSRAM. Required on memory-tight host
    # configurations (e.g. P4 with a large LVGL UI) where the internal-RAM
    # mempool allocation fails at boot with `sdio_mempool_create` assert.
    if config[CONF_USE_PSRAM]:
        esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_MEMPOOL_PREFER_SPIRAM", True)

+
+def _configure_3x(config: ConfigType) -> None:
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_HOST_RESET_GPIO", config[CONF_RESET_PIN]
+    )
+    # Co-processor variant
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_CP_TARGET_{config[CONF_VARIANT]}",
+        True,
+    )
+    if config[CONF_TYPE] == "sdio":
+        _configure_sdio_3x(config)
+    else:
+        _configure_spi_3x(config)
+    if esp32.get_esp32_variant() == esp32.VARIANT_ESP32P4:
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_HOST_FEAT_PEER_DATA", True)
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_HOST_FEAT_PEER_DATA_MAX_CUSTOM_MSG_HANDLERS",
+            _MAX_CUSTOM_MSG_HANDLERS,
+        )
+    if config[CONF_USE_PSRAM]:
+        esp32.add_idf_sdkconfig_option("CONFIG_EH_HOST_PORT_DMA_PREFER_SPIRAM", True)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_DFLT_TASK_FROM_SPIRAM", True)
+
+
+async def to_code(config: ConfigType) -> None:
+    add_define("USE_ESP32_HOSTED")
+    use_3x = uses_esp_hosted_3x()
+
+    if use_3x:
+        _configure_3x(config)
+    else:
+        _configure_2x(config)
+
+    # ESP-NOW-over-hosted shim: only the radio-less ESP32-P4 host needs it (see
+    # the note by _MAX_CUSTOM_MSG_HANDLERS). Enabled for every P4 host, not
+    # gated on the `espnow` component being present: the shim is tiny and the
+    # esp_now_* symbols/CustomRpc calls it defines require the peer-data Kconfig
+    # options (set above) to link whenever esp_now_hosted.cpp compiles (which is
+    # on any P4 host), so coupling the two keeps the build consistent. When
+    # `espnow` is absent the symbols are simply unused and never register a
+    # callback at runtime.
+    if esp32.get_esp32_variant() == esp32.VARIANT_ESP32P4:
+        add_define("USE_ESP_NOW_HOSTED")
+        # esp_now_hosted.cpp includes esp_now.h, which esp_wifi provides
+        esp32.include_builtin_idf_component("esp_wifi")
+
    # Library versions; this component set requires ESP-IDF 5.3 or newer,
    # which is enforced at validation time.
    idf_ver = esp32.idf_version()
    os.environ["ESP_IDF_VERSION"] = f"{idf_ver.major}.{idf_ver.minor}"
-    esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.6.3")
+    esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.6.5")
    esp32.add_idf_component(name="espressif/wifi_remote_over_eppp", ref="0.3.3")
    esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.5")
    esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.13")
@@ -26,6 +26,8 @@ static const char *const TAG = "esp32_hosted.update";

 // Older coprocessor firmware versions have a 1500-byte limit per RPC call
 constexpr size_t CHUNK_SIZE = 1500;
+// OTA begin blocks while the coprocessor erases its partition
+constexpr uint32_t OTA_WDT_TIMEOUT_MS = 60000;

 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
 // Interval/timeout IDs (uint32_t to avoid string comparison)
@@ -336,7 +338,11 @@ bool Esp32HostedUpdate::stream_firmware_to_coprocessor_() {
  ESP_LOGI(TAG, "Firmware size: %zu bytes", total_size);

  // Begin OTA on coprocessor
-  esp_err_t err = esp_hosted_slave_ota_begin();  // NOLINT
+  esp_err_t err;
+  {
+    watchdog::WatchdogManager wdt(OTA_WDT_TIMEOUT_MS);
+    err = esp_hosted_slave_ota_begin();  // NOLINT
+  }
  if (err != ESP_OK) {
    ESP_LOGE(TAG, "Failed to begin OTA: %s", esp_err_to_name(err));
    container->end();
@@ -425,7 +431,11 @@ bool Esp32HostedUpdate::write_embedded_firmware_to_coprocessor_() {

  ESP_LOGI(TAG, "Starting OTA update (%zu bytes)", this->firmware_size_);

-  esp_err_t err = esp_hosted_slave_ota_begin();  // NOLINT
+  esp_err_t err;
+  {
+    watchdog::WatchdogManager wdt(OTA_WDT_TIMEOUT_MS);
+    err = esp_hosted_slave_ota_begin();  // NOLINT
+  }
  if (err != ESP_OK) {
    ESP_LOGE(TAG, "Failed to begin OTA: %s", esp_err_to_name(err));
    this->status_set_error(LOG_STR("Failed to begin OTA"));
@@ -472,8 +482,6 @@ void Esp32HostedUpdate::perform(bool force) {
  this->update_info_.has_progress = false;
  this->publish_state();

-  watchdog::WatchdogManager watchdog(60000);
-
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
  if (!this->stream_firmware_to_coprocessor_())
 #else
@@ -111,22 +111,32 @@ def set_core_data(config: ConfigType) -> ConfigType:

 _TOOLCHAINS = (Toolchain.PLATFORMIO, Toolchain.ARDUINO)
 _validate_toolchain = cv.toolchain_enum(_TOOLCHAINS)
-_resolve_toolchain = cv.resolve_toolchain("ESP8266", _TOOLCHAINS, Toolchain.PLATFORMIO)
+_resolve_toolchain = cv.resolve_toolchain("ESP8266", _TOOLCHAINS, Toolchain.ARDUINO)
+
+
+def _warn_platformio_toolchain(config: ConfigType) -> ConfigType:
+    # Remove before 2027.4.0
+    if CORE.using_toolchain_platformio:
+        _LOGGER.warning(
+            "The 'platformio' toolchain for ESP8266 is deprecated and will be "
+            "removed in ESPHome 2027.4.0; the native 'arduino' toolchain is the "
+            "default."
+        )
+    return config


 def _validate_native_toolchain(config: ConfigType) -> ConfigType:
    """Constraints of the native (non-PlatformIO) Arduino toolchain."""
    if not CORE.using_toolchain_arduino:
        return config
-    from esphome.arduino8266.framework import MIN_FRAMEWORK_VERSION
+    from esphome.arduino8266.framework import framework_release

    conf = config[CONF_FRAMEWORK]
    version = cv.Version.parse(conf[CONF_VERSION])
-    if version < MIN_FRAMEWORK_VERSION:
-        raise cv.Invalid(
-            "'toolchain: arduino' requires framework version "
-            f"{MIN_FRAMEWORK_VERSION} or newer"
-        )
+    try:
+        framework_release(version)
+    except EsphomeError as err:
+        raise cv.Invalid(str(err), path=[CONF_FRAMEWORK, CONF_VERSION]) from err
    # platform_version is a PlatformIO concept; drop it, warning when a
    # custom pin is discarded
    if (
@@ -137,6 +147,8 @@ def _validate_native_toolchain(config: ConfigType) -> ConfigType:
            "'platform_version' is ignored by 'toolchain: arduino'; the native "
            "toolchain downloads the framework and compiler directly"
        )
+    # The native path fetches its own build; source may only be the
+    # PlatformIO default the schema filled in
    if conf[CONF_SOURCE] != _format_framework_arduino_version(version):
        raise cv.Invalid(
            "'toolchain: arduino' does not support a custom framework source; "
@@ -174,16 +186,27 @@ def get_download_types(storage_json: StorageJSON) -> list[dict[str, str]]:
    ]


+def _framework_package_version(ver: cv.Version) -> str:
+    """Map an Arduino core version to its PlatformIO registry package version
+    (3.1.2 -> 3.30102.0; the leading 3 is the package major)."""
+    if ver.major > 3:
+        raise EsphomeError(
+            f"Arduino core {ver} is not supported yet; "
+            "the newest known core series is 3.x"
+        )
+    if ver.major < 3:
+        raise EsphomeError(
+            f"Arduino core {ver} is not supported; ESPHome requires core 3.x"
+        )
+    return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
+
+
 def _format_framework_arduino_version(ver: cv.Version) -> str:
    # format the given arduino (https://github.com/esp8266/Arduino/releases) version to
    # a PIO platformio/framework-arduinoespressif8266 value
    # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
-    # Same encoding the native toolchain uses for its package download, so a
-    # custom-source check against this value cannot drift from what it fetches.
-    from esphome.arduino8266.framework import framework_package_version
-
    try:
-        return f"~{framework_package_version(ver)}"
+        return f"~{_framework_package_version(ver)}"
    except EsphomeError as err:
        # Anchor the 4.x rejection to the framework version line instead of
        # aborting with a bare traceback-level error
@@ -194,7 +217,8 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
 #  * New framework historically have had some regressions, especially for WiFi.
 #    The new version needs to be thoroughly validated before changing the
 #    recommended version as otherwise a bunch of devices could be bricked
-#  * For all constants below, update platformio.ini (in this repo)
+#  * For all constants below, update platformio.ini (in this repo) and
+#    FRAMEWORK_RELEASES in esphome/arduino8266/framework.py

 # The default/recommended arduino framework version
 #  - https://github.com/esp8266/Arduino/releases
@@ -306,6 +330,7 @@ CONFIG_SCHEMA = cv.All(
        }
    ),
    _resolve_toolchain,
+    _warn_platformio_toolchain,
    _validate_native_toolchain,
    set_core_data,
 )
@@ -314,8 +339,8 @@ CONFIG_SCHEMA = cv.All(
 def check_rosetta() -> None:
    """Fail fast when the x86_64 ESP8266 toolchain cannot run on this Mac.

-    There is no native arm64 build of the xtensa-lx106 toolchain; on Apple
-    Silicon it runs under Rosetta 2, which macOS updates can remove.
+    PlatformIO's xtensa-lx106 toolchain has no arm64 build; on Apple Silicon
+    it runs under Rosetta 2, which macOS updates can remove.
    """
    if not IS_MACOS or platform.machine() != "arm64":
        return
@@ -330,9 +355,10 @@ def check_rosetta() -> None:
        return  # arch(1) unavailable; let the build proceed
    if result.returncode != 0:
        raise EsphomeError(
-            "ESP8266 builds on Apple Silicon Macs use an Intel (x86_64) "
-            "compiler that requires Rosetta 2, which is not installed on "
-            "this system. Install it with:\n"
+            "ESP8266 builds with PlatformIO on Apple Silicon Macs use an Intel "
+            "(x86_64) compiler that requires Rosetta 2, which is not installed "
+            "on this system. Either set 'toolchain: arduino' under 'esp8266:', "
+            "which needs no Rosetta, or install it with:\n"
            "  softwareupdate --install-rosetta --agree-to-license"
        )

@@ -8,6 +8,8 @@ namespace esphome::esp8266 {
 static const char *const TAG = "esp8266";

 static int flags_to_mode(gpio::Flags flags, uint8_t pin) {
+  flags =
+      flags & (gpio::FLAG_INPUT | gpio::FLAG_OUTPUT | gpio::FLAG_OPEN_DRAIN | gpio::FLAG_PULLUP | gpio::FLAG_PULLDOWN);
  if (flags == gpio::FLAG_OUTPUT || flags == (gpio::FLAG_OUTPUT | gpio::FLAG_INPUT)) {
    return OUTPUT;
  }
@@ -10,6 +10,9 @@
 #include <lwip/dns.h>
 #include <cinttypes>
 #include "esp_event.h"
+#ifdef USE_PSRAM
+#include <esp_psram.h>
+#endif

 // IDF 6.0 moved per-chip PHY/MAC drivers to the Espressif Component Registry;
 // they are no longer included via esp_eth.h and need explicit includes.
@@ -71,6 +74,32 @@ static const char *const TAG = "ethernet";
 // PHY register size for hex logging
 static constexpr size_t PHY_REG_SIZE = 2;

+// Dual wifi + ethernet SPI builds: the one place internal RAM is short and lwip's other buffers are
+// already in PSRAM. Not with L2 TAP, whose filter lives in the glue's input path this replaces.
+#if defined(USE_PSRAM) && defined(USE_ETHERNET_SPI) && defined(USE_WIFI) && !defined(CONFIG_ESP_NETIF_L2_TAP)
+#define USE_ETHERNET_RX_PSRAM
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - reported by dump_config()
+static bool rx_psram_installed = false;
+
+// ESP-IDF ethernet drivers malloc() every received frame in internal RAM, where it stays until lwIP
+// hands it to the application. Move it to PSRAM; if that fails the frame is passed on where it is.
+static esp_err_t eth_input_to_psram(esp_eth_handle_t handle, uint8_t *buffer, uint32_t length, void *priv) {
+  auto *copy = static_cast<uint8_t *>(heap_caps_malloc(length, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
+  if (copy != nullptr) {
+    memcpy(copy, buffer, length);
+    free(buffer);  // NOLINT(cppcoreguidelines-no-malloc) - allocated by the driver with malloc()
+    buffer = copy;
+  } else {
+    static bool warned = false;  // once, this runs per frame in the driver's task
+    if (!warned) {
+      warned = true;
+      ESP_LOGW(TAG, "PSRAM allocation failed, frame kept in internal RAM (reported once)");
+    }
+  }
+  return esp_netif_receive(static_cast<esp_netif_t *>(priv), buffer, length, nullptr);
+}
+#endif
+
 void EthernetComponent::log_error_and_mark_failed_(esp_err_t err, const char *message) {
  ESP_LOGE(TAG, "%s: (%d) %s", message, err, esp_err_to_name(err));
  this->mark_failed();
@@ -453,6 +482,16 @@ void EthernetComponent::ethernet_lazy_init_() {
  /* attach Ethernet driver to TCP/IP stack */
  err = esp_netif_attach(this->eth_netif_, esp_eth_new_netif_glue(this->eth_handle_));
  ESPHL_ERROR_CHECK(err, "ETH netif attach error");
+#ifdef USE_ETHERNET_RX_PSRAM
+  // The glue frees every receive buffer with free(), so the replacement buffer must come from the heap
+  if (esp_psram_is_initialized()) {
+    err = esp_eth_update_input_path(this->eth_handle_, eth_input_to_psram, this->eth_netif_);
+    rx_psram_installed = err == ESP_OK;
+    if (!rx_psram_installed) {
+      ESP_LOGW(TAG, "PSRAM RX path not installed: %s", esp_err_to_name(err));
+    }
+  }
+#endif

  // Register user defined event handers
  err = esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, &EthernetComponent::eth_event_handler, nullptr);
@@ -630,6 +669,13 @@ void EthernetComponent::dump_config() {
                this->clk_pin_, this->mdc_pin_, this->mdio_pin_, this->phy_addr_);
 #endif
  ESP_LOGCONFIG(TAG, "  Type: %s", eth_type);
+#ifdef USE_ETHERNET_RX_PSRAM
+  // Only known once the driver is up; with enable_on_boot: false that is after this dump
+  if (this->ethernet_initialized_) {
+    ESP_LOGCONFIG(TAG, "  RX frames: %s",
+                  rx_psram_installed ? LOG_STR_LITERAL("PSRAM") : LOG_STR_LITERAL("internal RAM"));
+  }
+#endif
 }

 network::IPAddresses EthernetComponent::get_ip_addresses() {
@@ -31,12 +31,8 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config):
-    parent = await cg.get_variable(config[CONF_ID])
+    hub = await cg.get_variable(config[CONF_ID])

-    if CONF_PUMP_STATE in config:
-        sens = await binary_sensor.new_binary_sensor(config[CONF_PUMP_STATE])
-        cg.add(parent.set_is_dosing(sens))
-
-    if CONF_IS_PAUSED in config:
-        sens = await binary_sensor.new_binary_sensor(config[CONF_IS_PAUSED])
-        cg.add(parent.set_is_paused(sens))
+    binary_sensors = binary_sensor.sub_binary_sensors(config)
+    await binary_sensors(CONF_PUMP_STATE, hub.set_is_dosing)
+    await binary_sensors(CONF_IS_PAUSED, hub.set_is_paused)
@@ -76,28 +76,12 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config):
-    parent = await cg.get_variable(config[CONF_ID])
+    hub = await cg.get_variable(config[CONF_ID])

-    if CONF_CURRENT_VOLUME_DOSED in config:
-        sens = await sensor.new_sensor(config[CONF_CURRENT_VOLUME_DOSED])
-        cg.add(parent.set_current_volume_dosed(sens))
-
-    if CONF_LAST_VOLUME_REQUESTED in config:
-        sens = await sensor.new_sensor(config[CONF_LAST_VOLUME_REQUESTED])
-        cg.add(parent.set_last_volume_requested(sens))
-
-    if CONF_TOTAL_VOLUME_DOSED in config:
-        sens = await sensor.new_sensor(config[CONF_TOTAL_VOLUME_DOSED])
-        cg.add(parent.set_total_volume_dosed(sens))
-
-    if CONF_ABSOLUTE_TOTAL_VOLUME_DOSED in config:
-        sens = await sensor.new_sensor(config[CONF_ABSOLUTE_TOTAL_VOLUME_DOSED])
-        cg.add(parent.set_absolute_total_volume_dosed(sens))
-
-    if CONF_PUMP_VOLTAGE in config:
-        sens = await sensor.new_sensor(config[CONF_PUMP_VOLTAGE])
-        cg.add(parent.set_pump_voltage(sens))
-
-    if CONF_MAX_FLOW_RATE in config:
-        sens = await sensor.new_sensor(config[CONF_MAX_FLOW_RATE])
-        cg.add(parent.set_max_flow_rate(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_CURRENT_VOLUME_DOSED, hub.set_current_volume_dosed)
+    await sensors(CONF_LAST_VOLUME_REQUESTED, hub.set_last_volume_requested)
+    await sensors(CONF_TOTAL_VOLUME_DOSED, hub.set_total_volume_dosed)
+    await sensors(CONF_ABSOLUTE_TOTAL_VOLUME_DOSED, hub.set_absolute_total_volume_dosed)
+    await sensors(CONF_PUMP_VOLTAGE, hub.set_pump_voltage)
+    await sensors(CONF_MAX_FLOW_RATE, hub.set_max_flow_rate)
@@ -24,12 +24,8 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config):
-    parent = await cg.get_variable(config[CONF_ID])
+    hub = await cg.get_variable(config[CONF_ID])

-    if CONF_DOSING_MODE in config:
-        sens = await text_sensor.new_text_sensor(config[CONF_DOSING_MODE])
-        cg.add(parent.set_dosing_mode(sens))
-
-    if CONF_CALIBRATION_STATUS in config:
-        sens = await text_sensor.new_text_sensor(config[CONF_CALIBRATION_STATUS])
-        cg.add(parent.set_calibration_status(sens))
+    text_sensors = text_sensor.sub_text_sensors(config)
+    await text_sensors(CONF_DOSING_MODE, hub.set_dosing_mode)
+    await text_sensors(CONF_CALIBRATION_STATUS, hub.set_calibration_status)
@@ -177,33 +177,14 @@ async def to_code(config: ConfigType) -> None:

    cg.add(var.set_protocol_version(config[CONF_PROTOCOL_VERSION]))

-    if CONF_INVERTER_STATUS in config:
-        sens = await sensor.new_sensor(config[CONF_INVERTER_STATUS])
-        cg.add(var.set_inverter_status_sensor(sens))
-
-    if CONF_FREQUENCY in config:
-        sens = await sensor.new_sensor(config[CONF_FREQUENCY])
-        cg.add(var.set_grid_frequency_sensor(sens))
-
-    if CONF_ACTIVE_POWER in config:
-        sens = await sensor.new_sensor(config[CONF_ACTIVE_POWER])
-        cg.add(var.set_grid_active_power_sensor(sens))
-
-    if CONF_PV_ACTIVE_POWER in config:
-        sens = await sensor.new_sensor(config[CONF_PV_ACTIVE_POWER])
-        cg.add(var.set_pv_active_power_sensor(sens))
-
-    if CONF_ENERGY_PRODUCTION_DAY in config:
-        sens = await sensor.new_sensor(config[CONF_ENERGY_PRODUCTION_DAY])
-        cg.add(var.set_today_production_sensor(sens))
-
-    if CONF_TOTAL_ENERGY_PRODUCTION in config:
-        sens = await sensor.new_sensor(config[CONF_TOTAL_ENERGY_PRODUCTION])
-        cg.add(var.set_total_energy_production_sensor(sens))
-
-    if CONF_INVERTER_MODULE_TEMP in config:
-        sens = await sensor.new_sensor(config[CONF_INVERTER_MODULE_TEMP])
-        cg.add(var.set_inverter_module_temp_sensor(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_INVERTER_STATUS, var.set_inverter_status_sensor)
+    await sensors(CONF_FREQUENCY, var.set_grid_frequency_sensor)
+    await sensors(CONF_ACTIVE_POWER, var.set_grid_active_power_sensor)
+    await sensors(CONF_PV_ACTIVE_POWER, var.set_pv_active_power_sensor)
+    await sensors(CONF_ENERGY_PRODUCTION_DAY, var.set_today_production_sensor)
+    await sensors(CONF_TOTAL_ENERGY_PRODUCTION, var.set_total_energy_production_sensor)
+    await sensors(CONF_INVERTER_MODULE_TEMP, var.set_inverter_module_temp_sensor)

    for i, phase in enumerate([CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C]):
        if phase not in config:
@@ -229,65 +229,24 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await modbus.register_modbus_client_device(var, config)

-    if CONF_FREQUENCY in config:
-        sens = await sensor.new_sensor(config[CONF_FREQUENCY])
-        cg.add(var.set_frequency_sensor(sens))
-
-    if CONF_ACTIVE_POWER in config:
-        sens = await sensor.new_sensor(config[CONF_ACTIVE_POWER])
-        cg.add(var.set_active_power_sensor(sens))
-
-    if CONF_REACTIVE_POWER in config:
-        sens = await sensor.new_sensor(config[CONF_REACTIVE_POWER])
-        cg.add(var.set_reactive_power_sensor(sens))
-
-    if CONF_ENERGY_PRODUCTION_DAY in config:
-        sens = await sensor.new_sensor(config[CONF_ENERGY_PRODUCTION_DAY])
-        cg.add(var.set_today_production_sensor(sens))
-
-    if CONF_TOTAL_ENERGY_PRODUCTION in config:
-        sens = await sensor.new_sensor(config[CONF_TOTAL_ENERGY_PRODUCTION])
-        cg.add(var.set_total_energy_production_sensor(sens))
-
-    if CONF_TOTAL_GENERATION_TIME in config:
-        sens = await sensor.new_sensor(config[CONF_TOTAL_GENERATION_TIME])
-        cg.add(var.set_total_generation_time_sensor(sens))
-
-    if CONF_TODAY_GENERATION_TIME in config:
-        sens = await sensor.new_sensor(config[CONF_TODAY_GENERATION_TIME])
-        cg.add(var.set_today_generation_time_sensor(sens))
-
-    if CONF_INVERTER_MODULE_TEMP in config:
-        sens = await sensor.new_sensor(config[CONF_INVERTER_MODULE_TEMP])
-        cg.add(var.set_inverter_module_temp_sensor(sens))
-
-    if CONF_INVERTER_INNER_TEMP in config:
-        sens = await sensor.new_sensor(config[CONF_INVERTER_INNER_TEMP])
-        cg.add(var.set_inverter_inner_temp_sensor(sens))
-
-    if CONF_INVERTER_BUS_VOLTAGE in config:
-        sens = await sensor.new_sensor(config[CONF_INVERTER_BUS_VOLTAGE])
-        cg.add(var.set_inverter_bus_voltage_sensor(sens))
-
-    if CONF_INSULATION_OF_PV_N_TO_GROUND in config:
-        sens = await sensor.new_sensor(config[CONF_INSULATION_OF_PV_N_TO_GROUND])
-        cg.add(var.set_insulation_pv_n_to_ground_sensor(sens))
-
-    if CONF_GFCI_VALUE in config:
-        sens = await sensor.new_sensor(config[CONF_GFCI_VALUE])
-        cg.add(var.set_gfci_value_sensor(sens))
-
-    if CONF_DCI_OF_R in config:
-        sens = await sensor.new_sensor(config[CONF_DCI_OF_R])
-        cg.add(var.set_dci_of_r_sensor(sens))
-
-    if CONF_DCI_OF_S in config:
-        sens = await sensor.new_sensor(config[CONF_DCI_OF_S])
-        cg.add(var.set_dci_of_s_sensor(sens))
-
-    if CONF_DCI_OF_T in config:
-        sens = await sensor.new_sensor(config[CONF_DCI_OF_T])
-        cg.add(var.set_dci_of_t_sensor(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_FREQUENCY, var.set_frequency_sensor)
+    await sensors(CONF_ACTIVE_POWER, var.set_active_power_sensor)
+    await sensors(CONF_REACTIVE_POWER, var.set_reactive_power_sensor)
+    await sensors(CONF_ENERGY_PRODUCTION_DAY, var.set_today_production_sensor)
+    await sensors(CONF_TOTAL_ENERGY_PRODUCTION, var.set_total_energy_production_sensor)
+    await sensors(CONF_TOTAL_GENERATION_TIME, var.set_total_generation_time_sensor)
+    await sensors(CONF_TODAY_GENERATION_TIME, var.set_today_generation_time_sensor)
+    await sensors(CONF_INVERTER_MODULE_TEMP, var.set_inverter_module_temp_sensor)
+    await sensors(CONF_INVERTER_INNER_TEMP, var.set_inverter_inner_temp_sensor)
+    await sensors(CONF_INVERTER_BUS_VOLTAGE, var.set_inverter_bus_voltage_sensor)
+    await sensors(
+        CONF_INSULATION_OF_PV_N_TO_GROUND, var.set_insulation_pv_n_to_ground_sensor
+    )
+    await sensors(CONF_GFCI_VALUE, var.set_gfci_value_sensor)
+    await sensors(CONF_DCI_OF_R, var.set_dci_of_r_sensor)
+    await sensors(CONF_DCI_OF_S, var.set_dci_of_s_sensor)
+    await sensors(CONF_DCI_OF_T, var.set_dci_of_t_sensor)

    for i, phase in enumerate([CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C]):
        if phase not in config:
@@ -107,18 +107,11 @@ async def to_code(config: ConfigType) -> None:
    cf1 = await cg.gpio_pin_expression(config[CONF_CF1_PIN])
    cg.add(var.set_cf1_pin(cf1))

-    if CONF_VOLTAGE in config:
-        sens = await sensor.new_sensor(config[CONF_VOLTAGE])
-        cg.add(var.set_voltage_sensor(sens))
-    if CONF_CURRENT in config:
-        sens = await sensor.new_sensor(config[CONF_CURRENT])
-        cg.add(var.set_current_sensor(sens))
-    if CONF_POWER in config:
-        sens = await sensor.new_sensor(config[CONF_POWER])
-        cg.add(var.set_power_sensor(sens))
-    if CONF_ENERGY in config:
-        sens = await sensor.new_sensor(config[CONF_ENERGY])
-        cg.add(var.set_energy_sensor(sens))
+    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_ENERGY, var.set_energy_sensor)
    cg.add(var.set_current_resistor(config[CONF_CURRENT_RESISTOR]))
    cg.add(var.set_voltage_divider(config[CONF_VOLTAGE_DIVIDER]))
    cg.add(var.set_initial_mode(INITIAL_MODES[config[CONF_INITIAL_MODE]]))
@@ -79,20 +79,11 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    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 apparent_power_config := config.get(CONF_APPARENT_POWER):
-        sens = await sensor.new_sensor(apparent_power_config)
-        cg.add(var.set_apparent_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))
+    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_APPARENT_POWER, var.set_apparent_power_sensor)
+    await sensors(CONF_POWER_FACTOR, var.set_power_factor_sensor)
    cg.add(var.set_current_resistor(config[CONF_CURRENT_RESISTOR]))
    cg.add(var.set_voltage_divider(config[CONF_VOLTAGE_DIVIDER]))
@@ -92,17 +92,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    if CONF_PM_1_0 in config:
-        sens = await sensor.new_sensor(config[CONF_PM_1_0])
-        cg.add(var.set_pm_1_0_sensor(sens))
-
-    if CONF_PM_2_5 in config:
-        sens = await sensor.new_sensor(config[CONF_PM_2_5])
-        cg.add(var.set_pm_2_5_sensor(sens))
-
-    if CONF_PM_10_0 in config:
-        sens = await sensor.new_sensor(config[CONF_PM_10_0])
-        cg.add(var.set_pm_10_0_sensor(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_PM_1_0, var.set_pm_1_0_sensor)
+    await sensors(CONF_PM_2_5, var.set_pm_2_5_sensor)
+    await sensors(CONF_PM_10_0, var.set_pm_10_0_sensor)

    # Remove before 2026.12.0
    if CONF_AQI in config:
@@ -136,15 +136,8 @@ async def to_code(config: ConfigType) -> None:
    cg.add(var.set_oversampling(config[CONF_OVERSAMPLING]))
    cg.add(var.set_datarate(auto_data_rate(config)))
    cg.add(var.set_range(config[CONF_RANGE]))
-    if CONF_FIELD_STRENGTH_X in config:
-        sens = await sensor.new_sensor(config[CONF_FIELD_STRENGTH_X])
-        cg.add(var.set_x_sensor(sens))
-    if CONF_FIELD_STRENGTH_Y in config:
-        sens = await sensor.new_sensor(config[CONF_FIELD_STRENGTH_Y])
-        cg.add(var.set_y_sensor(sens))
-    if CONF_FIELD_STRENGTH_Z in config:
-        sens = await sensor.new_sensor(config[CONF_FIELD_STRENGTH_Z])
-        cg.add(var.set_z_sensor(sens))
-    if CONF_HEADING in config:
-        sens = await sensor.new_sensor(config[CONF_HEADING])
-        cg.add(var.set_heading_sensor(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_FIELD_STRENGTH_X, var.set_x_sensor)
+    await sensors(CONF_FIELD_STRENGTH_Y, var.set_y_sensor)
+    await sensors(CONF_FIELD_STRENGTH_Z, var.set_z_sensor)
+    await sensors(CONF_HEADING, var.set_heading_sensor)
@@ -1,6 +1,9 @@
 #include "hoermann_hcp.h"

+#include <algorithm>
+
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

 namespace esphome::hoermann_hcp {
@@ -60,6 +63,61 @@ static bool is_moving(DoorState state) {
  }
 }

+#ifdef USE_HOERMANN_HCP_IDENTITY
+// The command byte of a status poll. Only its answer can carry a request.
+static constexpr uint8_t STATUS_COMMAND = 0x03;
+// A status answer with this code in the low byte of its second register asks the bus controller for a value,
+// named in the high byte of the third.
+static constexpr uint8_t ANSWER_REQUEST = 0x22;
+static constexpr uint8_t REQUEST_SERIAL = 0x05;
+static constexpr uint8_t REQUEST_FIRMWARE = 0x06;
+// Each request goes out in one answer, up to this many times, this far apart.
+static constexpr uint8_t IDENTITY_MAX_ATTEMPTS = 3;
+static constexpr uint32_t IDENTITY_RETRY_MS = 30000;
+// The value comes back as a payload transfer: this command in the low byte of the first command register, a sub
+// code in the high byte of the second, the payload from the third on.
+static constexpr uint8_t TRANSFER_COMMAND = 0x04;
+static constexpr uint8_t TRANSFER_SUB_SERIAL = 0x0C;
+static constexpr uint8_t TRANSFER_SUB_FIRMWARE = 0x0D;
+static constexpr uint8_t TRANSFER_ACK = 0xFD;
+static constexpr size_t TRANSFER_PAYLOAD_REG = 2;
+// Marks the first half of the serial number in the counter byte, and is not part of the count.
+static constexpr uint8_t COUNTER_FIRST_HALF = 0x80;
+// Older motors (index B1 seen) send the whole serial number in one frame, without the half marker. It is as long
+// as a second half, so one copy path serves both.
+static constexpr size_t SERIAL_SINGLE_FRAME_REGS = 6;
+static_assert(SERIAL_SINGLE_FRAME_REGS == SERIAL_SECOND_HALF_REGS, "one copy path serves both serial frames");
+
+// Registers hold two payload bytes each, high byte first.
+static void copy_payload(const modbus::RegisterValues &registers, size_t count, char *out) {
+  for (size_t i = 0; i < count; i++) {
+    const uint16_t value = registers[TRANSFER_PAYLOAD_REG + i];
+    out[2 * i] = static_cast<char>(value >> 8);
+    out[2 * i + 1] = static_cast<char>(value);
+  }
+}
+
+// Length of the printable text at the start, without trailing spaces. The padding after it varies.
+static size_t text_length(const char *text, size_t len) {
+  size_t at = 0;
+  while (at < len && text[at] >= 0x20 && text[at] <= 0x7E)
+    at++;
+  while (at > 0 && text[at - 1] == ' ')
+    at--;
+  return at;
+}
+
+static void terminate_text(char *text, size_t len) { text[text_length(text, len)] = '\0'; }
+
+// dump_config() is replayed to remote log clients, so they see the outcome of the exchange at boot.
+static void log_identity_value(text_sensor::TextSensor *sensor) {
+  if (sensor != nullptr) {
+    ESP_LOGCONFIG(TAG, "    Value: %s",
+                  sensor->has_state() ? sensor->get_state().c_str() : LOG_STR_LITERAL("not received"));
+  }
+}
+#endif
+
 void HoermannHcp::update() {
  const uint32_t now = millis();
  // Time out the connection flag if the bus controller stopped polling.
@@ -91,6 +149,9 @@ void HoermannHcp::update() {
    ESP_LOGW(TAG, "Door did not report the lamp changing, giving up on the toggle");
    this->forget_light_toggles_();
  }
+#ifdef USE_HOERMANN_HCP_IDENTITY
+  this->publish_identity_();
+#endif
  if (this->changed_) {
    this->changed_ = false;
    this->state_callback_.call();
@@ -102,6 +163,12 @@ void HoermannHcp::dump_config() {
                "Hoermann HCP bridge:\n"
                "  Modbus server address: 0x%02X",
                this->get_address());
+#ifdef USE_HOERMANN_HCP_IDENTITY
+  LOG_TEXT_SENSOR("  ", "Serial Number", this->serial_number_text_sensor_);
+  log_identity_value(this->serial_number_text_sensor_);
+  LOG_TEXT_SENSOR("  ", "Firmware Version", this->version_text_sensor_);
+  log_identity_value(this->version_text_sensor_);
+#endif
 }

 modbus::ResponseStatus HoermannHcp::on_read_holding_registers(uint16_t start_address, uint16_t number_of_registers,
@@ -113,6 +180,14 @@ modbus::ResponseStatus HoermannHcp::on_read_holding_registers(uint16_t start_add

  this->record_response_();

+#ifdef USE_HOERMANN_HCP_IDENTITY
+  // Acknowledge the transfer taken by the write half of this frame.
+  if (this->transfer_answer_counter_ != NO_TRANSFER_ANSWER) {
+    this->push_transfer_answer_(registers, number_of_registers);
+    return {};
+  }
+#endif
+
  // 0x17 read half: STATE_REG is read back right after COMMAND_REG was written, so echo the stored message
  // counter (high byte) and command (low byte). The read length identifies which internal block is requested.
  const uint16_t counter = this->command_reg_value_ & 0xFF00;
@@ -125,6 +200,9 @@ modbus::ResponseStatus HoermannHcp::on_read_holding_registers(uint16_t start_add
      registers.push_back(static_cast<uint16_t>(0x0001 | command));
      this->push_command_registers_(registers);
      push_zeros(registers, 4);
+#ifdef USE_HOERMANN_HCP_IDENTITY
+      this->add_identity_request_(registers, command);
+#endif
      break;
    case 2:
      // Empty command request.
@@ -156,6 +234,9 @@ modbus::ResponseStatus HoermannHcp::on_write_registers(uint16_t start_address,
    // command byte back from STATE_REG. The hub always runs the write before the read within one request.
    this->record_response_();
    this->command_reg_value_ = registers[0];
+#ifdef USE_HOERMANN_HCP_IDENTITY
+    this->transfer_answer_counter_ = this->take_identity_transfer_(registers);
+#endif
    return {};
  }

@@ -217,6 +298,155 @@ void HoermannHcp::push_command_registers_(modbus::RegisterValues &registers) {
  registers.push_back(command->released_value_2);
 }

+#ifdef USE_HOERMANN_HCP_IDENTITY
+void HoermannHcp::add_identity_request_(modbus::RegisterValues &registers, uint16_t command) {
+  if (static_cast<uint8_t>(this->command_reg_value_) != STATUS_COMMAND)
+    return;
+  // Like Hoermann's own bus accessory, only after one ordinary answer.
+  if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_IDLE) {
+    if (this->serial_number_text_sensor_ != nullptr || this->version_text_sensor_ != nullptr)
+      this->arm_identity_request_(IdentityPhase::IDENTITY_PHASE_SERIAL);
+    return;
+  }
+  // Uses the registers of a key press, so it waits while one is pending.
+  if (this->next_command_ != nullptr || registers[2] != 0 || registers[3] != 0 || !this->take_identity_request_())
+    return;
+  registers[1] = static_cast<uint16_t>(ANSWER_REQUEST | command);
+  registers[2] = encode_uint16(this->identity_request_(), 0);
+}
+
+void HoermannHcp::arm_identity_request_(IdentityPhase phase) {
+  this->identity_phase_ = phase;
+  this->identity_attempts_ = 0;
+}
+
+bool HoermannHcp::take_identity_request_() {
+  const uint8_t request = this->identity_request_();
+  if (request == 0)
+    return false;
+  const uint32_t now = millis();
+  if (this->identity_attempts_ != 0 && now - this->identity_asked_at_ <= IDENTITY_RETRY_MS)
+    return false;
+  if (this->identity_attempts_ >= IDENTITY_MAX_ATTEMPTS) {
+    this->identity_unanswered_ = request;
+    if (request == REQUEST_SERIAL) {
+      // Still ask for the firmware version, and drop a leftover first half.
+      this->serial_number_[0] = '\0';
+      this->arm_identity_request_(IdentityPhase::IDENTITY_PHASE_FIRMWARE);
+    } else {
+      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_DONE;
+    }
+    return false;
+  }
+  this->identity_attempts_++;
+  this->identity_asked_at_ = now;
+  return true;
+}
+
+uint8_t HoermannHcp::take_identity_transfer_(const modbus::RegisterValues &registers) {
+  if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_IDLE || registers.size() < TRANSFER_PAYLOAD_REG ||
+      static_cast<uint8_t>(registers[0]) != TRANSFER_COMMAND)
+    return NO_TRANSFER_ANSWER;
+  const uint8_t counter = static_cast<uint8_t>(registers[0] >> 8);
+  const uint8_t sub_code = static_cast<uint8_t>(registers[1] >> 8);
+  if (sub_code != TRANSFER_SUB_SERIAL && sub_code != TRANSFER_SUB_FIRMWARE)
+    return NO_TRANSFER_ANSWER;
+  // Acknowledged whether kept or not, as Hoermann's own bus accessory does. What was not kept is asked for again.
+  const uint8_t answer = counter & ~COUNTER_FIRST_HALF;
+  // Only an answer to the request that went out is kept.
+  const uint8_t request = sub_code == TRANSFER_SUB_SERIAL ? REQUEST_SERIAL : REQUEST_FIRMWARE;
+  if (this->identity_attempts_ == 0 || this->identity_request_() != request)
+    return answer;
+
+  const size_t payload_regs = registers.size() - TRANSFER_PAYLOAD_REG;
+  if (request == REQUEST_FIRMWARE) {
+    const size_t regs = std::min(payload_regs, FIRMWARE_REGS);
+    copy_payload(registers, regs, this->firmware_version_);
+    if (regs == FIRMWARE_REGS && text_length(this->firmware_version_, 2 * regs) != 0) {
+      terminate_text(this->firmware_version_, 2 * regs);
+      // Clear an earlier unreadable answer, so this one is shown.
+      this->firmware_unreadable_ = false;
+      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_DONE;
+      return answer;
+    }
+    // Left as received for update() to log.
+    this->firmware_unreadable_ = true;
+    this->firmware_unreadable_len_ = 2 * regs;
+    // A short answer is asked for again; unreadable text would come back the same.
+    if (regs == FIRMWARE_REGS)
+      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_DONE;
+    return answer;
+  }
+  if ((counter & COUNTER_FIRST_HALF) != 0) {
+    // Even a half too short to keep says the number comes in two halves; a first half already kept stays kept.
+    if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_SERIAL)
+      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_SERIAL_SPLIT;
+    if (payload_regs >= SERIAL_FIRST_HALF_REGS) {
+      copy_payload(registers, SERIAL_FIRST_HALF_REGS, this->serial_number_);
+      this->identity_phase_ = IdentityPhase::IDENTITY_PHASE_SERIAL_SECOND_HALF;
+    }
+    return answer;
+  }
+  // Without a half marker seen, the frame is the whole number; after one, it can only be the second half.
+  if (this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_SERIAL_SPLIT || payload_regs < SERIAL_SINGLE_FRAME_REGS)
+    return answer;
+  const size_t at =
+      this->identity_phase_ == IdentityPhase::IDENTITY_PHASE_SERIAL_SECOND_HALF ? 2 * SERIAL_FIRST_HALF_REGS : 0;
+  copy_payload(registers, SERIAL_SINGLE_FRAME_REGS, this->serial_number_ + at);
+  terminate_text(this->serial_number_, at + 2 * SERIAL_SINGLE_FRAME_REGS);
+  this->serial_unreadable_ = this->serial_number_[0] == '\0';
+  this->arm_identity_request_(IdentityPhase::IDENTITY_PHASE_FIRMWARE);
+  return answer;
+}
+
+void HoermannHcp::push_transfer_answer_(modbus::RegisterValues &registers, uint16_t number_of_registers) {
+  const uint16_t answer[] = {encode_uint16(this->transfer_answer_counter_, 0),
+                             encode_uint16(TRANSFER_COMMAND, TRANSFER_ACK)};
+  this->transfer_answer_counter_ = NO_TRANSFER_ANSWER;
+  for (uint16_t i = 0; i < number_of_registers; i++)
+    registers.push_back(i < 2 ? answer[i] : 0x0000);
+}
+
+void HoermannHcp::publish_identity_() {
+  // Buffers are cleared once published, so each value goes out once. The serial number is whole once the firmware
+  // version is requested.
+  if (this->serial_number_text_sensor_ != nullptr && this->identity_request_() != REQUEST_SERIAL &&
+      this->serial_number_[0] != '\0') {
+    this->serial_number_text_sensor_->publish_state(this->serial_number_);
+    this->serial_number_[0] = '\0';
+  }
+  if (this->serial_unreadable_) {
+    this->serial_unreadable_ = false;
+    ESP_LOGW(TAG, "Unreadable serial number");
+  }
+  // Checked first: the buffer then holds raw bytes, not text.
+  if (this->firmware_unreadable_) {
+    this->firmware_unreadable_ = false;
+    const uint8_t len = this->firmware_unreadable_len_;
+    // All zeros: the motor does not report a version (index B1 seen).
+    if (len == 2 * FIRMWARE_REGS &&
+        std::all_of(this->firmware_version_, this->firmware_version_ + len, [](char c) { return c == '\0'; })) {
+      ESP_LOGD(TAG, "Motor does not report its firmware version");
+    } else {
+      char hex[format_hex_size(2 * FIRMWARE_REGS)];
+      ESP_LOGW(TAG, "Unreadable firmware version (%u bytes): %s", len,
+               format_hex_to(hex, reinterpret_cast<const uint8_t *>(this->firmware_version_), len));
+    }
+    this->firmware_version_[0] = '\0';
+  }
+  if (this->version_text_sensor_ != nullptr && this->firmware_version_[0] != '\0') {
+    this->version_text_sensor_->publish_state(this->firmware_version_);
+    this->firmware_version_[0] = '\0';
+  }
+  if (this->identity_unanswered_ != 0) {
+    ESP_LOGW(TAG, "No usable %s received",
+             this->identity_unanswered_ == REQUEST_SERIAL ? LOG_STR_LITERAL("serial number")
+                                                          : LOG_STR_LITERAL("firmware version"));
+    this->identity_unanswered_ = 0;
+  }
+}
+#endif
+
 void HoermannHcp::on_position_reg_(uint16_t value) {
  // Low byte: current position.
  const uint8_t position = static_cast<uint8_t>(value);
@@ -371,6 +601,9 @@ void HoermannHcp::set_valid_(bool valid) {
  this->forget_light_toggles_();
  // The lamp can be switched at the door while the bus is quiet, so what was last read is no longer trusted.
  this->set_light_seen_(false);
+  // The same holds for the door. The next broadcast is decoded even if it repeats the last one.
+  this->door_state_seen_ = false;
+  this->prev_state_reg_ = 0xFFFF;
  this->short_broadcast_logged_ = false;
 }

@@ -410,6 +643,11 @@ void HoermannHcp::forget_light_toggles_() {
 }

 void HoermannHcp::set_door_state_(DoorState state) {
+  // The first state may equal the default, so being seen is a change of its own.
+  if (!this->door_state_seen_) {
+    this->door_state_seen_ = true;
+    this->changed_ = true;
+  }
  if (this->door_state_ == state)
    return;
  this->door_state_ = state;
@@ -4,7 +4,11 @@

 #include "esphome/components/modbus/modbus.h"
 #include "esphome/core/component.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
+#ifdef USE_HOERMANN_HCP_IDENTITY
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif

 namespace esphome::hoermann_hcp {

@@ -21,6 +25,28 @@ enum class DoorState : uint8_t {
  STOPPED,
 };

+#ifdef USE_HOERMANN_HCP_IDENTITY
+// Payload registers of each value, two bytes each.
+static constexpr size_t SERIAL_FIRST_HALF_REGS = 7;
+static constexpr size_t SERIAL_SECOND_HALF_REGS = 6;
+static constexpr size_t FIRMWARE_REGS = 6;
+// Counter of the transfer the read half of the frame acknowledges. Real counters have the 0x80 half marker
+// stripped, so this value never occurs.
+static constexpr uint8_t NO_TRANSFER_ANSWER = 0xFF;
+
+// Where the identity exchange stands. The low nibble is the code the motor is asked with, 0 while nothing is
+// outstanding. Like Hoermann's own bus accessory, the first status answer stays ordinary. Older motors (index B1
+// seen) send the whole serial number in one frame, without the half marker.
+enum class IdentityPhase : uint8_t {
+  IDENTITY_PHASE_IDLE = 0x00,
+  IDENTITY_PHASE_DONE = 0x10,
+  IDENTITY_PHASE_SERIAL = 0x05,              // A plain frame is the whole serial number.
+  IDENTITY_PHASE_SERIAL_SPLIT = 0x15,        // A half marker was seen, so a plain frame can only be the second half.
+  IDENTITY_PHASE_SERIAL_SECOND_HALF = 0x25,  // The first half is in.
+  IDENTITY_PHASE_FIRMWARE = 0x06,
+};
+#endif
+
 // A HCP command is a simulated key press: the pressed value is presented to the bus controller, then after a
 // short delay the released value. Each half also carries a second register, which names the buttons that do
 // not fit into the first.
@@ -35,6 +61,12 @@ struct HoermannHcpCommand {
 };

 class HoermannHcp : public PollingComponent, public modbus::ModbusServerDevice {
+#ifdef USE_HOERMANN_HCP_IDENTITY
+  // The motor is asked for these only when one of them is configured.
+  SUB_TEXT_SENSOR(serial_number)
+  SUB_TEXT_SENSOR(version)
+#endif
+
 public:
  void update() override;
  void dump_config() override;
@@ -63,6 +95,9 @@ class HoermannHcp : public PollingComponent, public modbus::ModbusServerDevice {
  bool toggle_light();

  DoorState get_door_state() const { return this->door_state_; }
+  // False until a broadcast has carried a state the door is known to report. Bus traffic alone makes the
+  // connection valid, so get_door_state() would still be its default.
+  bool is_door_state_known() const { return this->door_state_seen_; }
  float get_current_position() const { return this->current_position_; }
  bool is_valid() const { return this->valid_; }
  bool is_light_on() const { return this->light_on_; }
@@ -95,6 +130,21 @@ class HoermannHcp : public PollingComponent, public modbus::ModbusServerDevice {
  void on_position_reg_(uint16_t value);
  void on_state_reg_(uint16_t value);
  void on_light_reg_(uint16_t value);
+#ifdef USE_HOERMANN_HCP_IDENTITY
+  // Puts a due request into a status answer.
+  void add_identity_request_(modbus::RegisterValues &registers, uint16_t command);
+  void arm_identity_request_(IdentityPhase phase);
+  uint8_t identity_request_() const { return static_cast<uint8_t>(this->identity_phase_) & 0x0F; }
+  // True when the request is due, counting the attempt. Gives up after the last one.
+  bool take_identity_request_();
+  // Takes a value the motor hands over as a payload transfer. Returns the counter to acknowledge it with, kept or
+  // not, or NO_TRANSFER_ANSWER when the frame was something else.
+  uint8_t take_identity_transfer_(const modbus::RegisterValues &registers);
+  // Acknowledges the transfer taken by the write half of the same frame.
+  void push_transfer_answer_(modbus::RegisterValues &registers, uint16_t number_of_registers);
+  // Runs from update(), outside the bus callbacks.
+  void publish_identity_();
+#endif

  void set_valid_(bool valid);
  void set_door_state_(DoorState state);
@@ -145,7 +195,24 @@ class HoermannHcp : public PollingComponent, public modbus::ModbusServerDevice {
  bool changed_{false};
  bool light_on_{false};
  bool light_seen_{false};
+  bool door_state_seen_{false};
  bool short_broadcast_logged_{false};
+
+#ifdef USE_HOERMANN_HCP_IDENTITY
+  uint32_t identity_asked_at_{0};
+  IdentityPhase identity_phase_{IdentityPhase::IDENTITY_PHASE_IDLE};
+  uint8_t identity_attempts_{0};
+  // The request given up on, for update() to report.
+  uint8_t identity_unanswered_{0};
+  uint8_t transfer_answer_counter_{NO_TRANSFER_ANSWER};
+  // Length of an unreadable firmware version left in firmware_version_.
+  uint8_t firmware_unreadable_len_{0};
+  // A serial number arrived without text, for update() to log.
+  bool serial_unreadable_{false};
+  bool firmware_unreadable_{false};
+  char serial_number_[2 * (SERIAL_FIRST_HALF_REGS + SERIAL_SECOND_HALF_REGS) + 1]{};
+  char firmware_version_[2 * FIRMWARE_REGS + 1]{};
+#endif
 };

 }  // namespace esphome::hoermann_hcp
@@ -0,0 +1,50 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_VERSION, ENTITY_CATEGORY_DIAGNOSTIC, ICON_CHIP
+from esphome.types import ConfigType
+
+from .. import CONF_HOERMANN_HCP_ID, HoermannHcp, hoermann_hcp_ns
+
+DEPENDENCIES = ["hoermann_hcp"]
+
+CONF_DOOR_STATE = "door_state"
+CONF_SERIAL_NUMBER = "serial_number"
+
+HoermannHcpDoorStateTextSensor = hoermann_hcp_ns.class_(
+    "HoermannHcpDoorStateTextSensor", text_sensor.TextSensor, cg.Component
+)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_HOERMANN_HCP_ID): cv.use_id(HoermannHcp),
+            cv.Optional(CONF_DOOR_STATE): text_sensor.text_sensor_schema(
+                HoermannHcpDoorStateTextSensor, icon="mdi:garage"
+            ).extend(cv.COMPONENT_SCHEMA),
+            cv.Optional(CONF_SERIAL_NUMBER): text_sensor.text_sensor_schema(
+                icon="mdi:data-matrix", entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+            ),
+            cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
+                icon=ICON_CHIP, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+            ),
+        }
+    ),
+    cv.has_at_least_one_key(CONF_DOOR_STATE, CONF_SERIAL_NUMBER, CONF_VERSION),
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    parent = await cg.get_variable(config[CONF_HOERMANN_HCP_ID])
+    if (conf := config.get(CONF_DOOR_STATE)) is not None:
+        var = await text_sensor.new_text_sensor(conf, parent)
+        await cg.register_component(var, conf)
+    # Only the identity sensors need the exchange with the motor compiled in.
+    if CONF_SERIAL_NUMBER in config or CONF_VERSION in config:
+        cg.add_define("USE_HOERMANN_HCP_IDENTITY")
+    if (conf := config.get(CONF_SERIAL_NUMBER)) is not None:
+        sens = await text_sensor.new_text_sensor(conf)
+        cg.add(parent.set_serial_number_text_sensor(sens))
+    if (conf := config.get(CONF_VERSION)) is not None:
+        sens = await text_sensor.new_text_sensor(conf)
+        cg.add(parent.set_version_text_sensor(sens))
@@ -0,0 +1,49 @@
+#include "hoermann_hcp_text_sensor.h"
+
+#include <cstring>
+
+#include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
+
+namespace esphome::hoermann_hcp {
+
+static const char *const TAG = "hoermann_hcp.text_sensor";
+
+// Indexed by DoorState. Each fits the 15 characters std::string keeps inline, so publishing never allocates.
+PROGMEM_STRING_TABLE(DoorStateStrings, "Open", "Opening", "Closed", "Closing", "Half open", "Moving to vent",
+                     "Vent position", "Moving to half", "Stopped");
+static_assert(DoorStateStrings::COUNT == static_cast<size_t>(DoorState::STOPPED) + 1,
+              "DoorStateStrings must list every DoorState in order");
+
+void HoermannHcpDoorStateTextSensor::setup() {
+  this->parent_->add_on_state_callback([this]() { this->update_from_state_(); });
+  // A state decoded before the callback was added would otherwise wait for the next change.
+  this->update_from_state_();
+}
+
+void HoermannHcpDoorStateTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Hoermann HCP Door State", this); }
+
+void HoermannHcpDoorStateTextSensor::update_from_state_() {
+  // The last state stays while the bus controller is gone, and is published again once it is back.
+  if (!this->parent_->is_valid()) {
+    this->published_ = false;
+    return;
+  }
+  if (!this->parent_->is_door_state_known())
+    return;
+  // Any hub change runs this, so only a new door state is published.
+  const DoorState state = this->parent_->get_door_state();
+  if (this->published_ && state == this->published_state_)
+    return;
+  this->published_ = true;
+  this->published_state_ = state;
+  char text[16];
+  ESPHOME_strncpy_P(text,
+                    reinterpret_cast<ESPHOME_PGM_P>(
+                        DoorStateStrings::get_progmem_str(static_cast<uint8_t>(state), DoorStateStrings::LAST_INDEX)),
+                    sizeof(text));
+  text[sizeof(text) - 1] = '\0';
+  this->publish_state(text);
+}
+
+}  // namespace esphome::hoermann_hcp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "esphome/components/text_sensor/text_sensor.h"
+#include "esphome/core/component.h"
+#include "../hoermann_hcp.h"
+
+namespace esphome::hoermann_hcp {
+
+class HoermannHcpDoorStateTextSensor : public text_sensor::TextSensor, public Component {
+ public:
+  explicit HoermannHcpDoorStateTextSensor(HoermannHcp *parent) : parent_(parent) {}
+
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  void update_from_state_();
+
+  HoermannHcp *const parent_;
+  DoorState published_state_{DoorState::CLOSED};
+  bool published_{false};
+};
+
+}  // namespace esphome::hoermann_hcp
@@ -1,3 +1,5 @@
+import sys
+
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -8,9 +10,9 @@ from esphome.const import (
    KEY_TARGET_PLATFORM,
    PLATFORM_HOST,
    ThreadModel,
+    Toolchain,
 )
-from esphome.core import CORE
-from esphome.platformio.toolchain import copy_ccache_script
+from esphome.core import CORE, EsphomeError
 from esphome.types import ConfigType

 from .const import KEY_HOST
@@ -37,7 +39,9 @@ CONFIG_SCHEMA = cv.All(
            cv.Optional(CONF_MAC_ADDRESS, default="98:35:69:ab:f6:79"): cv.mac_address,
        }
    ),
-    cv.require_platformio_toolchain("host"),
+    # The host builds with the machine's own compiler through ninja; there
+    # is no PlatformIO backend, so a CLI --toolchain must name this one
+    cv.resolve_toolchain("host", (Toolchain.HOST,), Toolchain.HOST),
    set_core_data,
 )

@@ -48,16 +52,23 @@ async def to_code(config: ConfigType) -> None:
    # The prefs file finds stored preferences by key, so key migration is possible
    cg.add_define("USE_PREFERENCE_KEY_LOOKUP")
    cg.add_define("USE_ESPHOME_HOST_MAC_ADDRESS", config[CONF_MAC_ADDRESS].parts)
-    cg.add_build_flag("-std=gnu++20")
+    cg.set_cpp_standard("gnu++20")
    cg.add_define("ESPHOME_BOARD", "host")
    cg.add_define("ESPHOME_VARIANT", "HOST")
    cg.add_define(ThreadModel.MULTI_ATOMICS)
-    cg.add_platformio_option("platform", "platformio/native")
-    cg.add_platformio_option("lib_ldf_mode", "off")
-    cg.add_platformio_option("lib_compat_mode", "strict")
-    cg.add_platformio_option("extra_scripts", ["pre:ccache.py"])


-# Called by writer.py
-def copy_files() -> None:
-    copy_ccache_script()
+# Called by __main__.compile_program; True means this platform built the
+# program itself instead of falling through to the PlatformIO toolchain.
+def run_compile(args: object, config: ConfigType) -> bool:
+    from esphome.host import toolchain
+
+    if sys.platform == "win32":
+        # Here, not in validation: `esphome config` must keep working
+        raise EsphomeError(
+            "The host platform uses POSIX interfaces and does not build on "
+            "Windows; use WSL or a Linux or macOS machine"
+        )
+    if toolchain.run_compile(config, CORE.verbose) != 0:
+        raise EsphomeError("Host build failed")
+    return True
@@ -67,17 +67,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    if CONF_TEMPERATURE in config:
-        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
-        cg.add(var.set_temperature(sens))
-
-    if CONF_HUMIDITY in config:
-        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
-        cg.add(var.set_humidity(sens))
-
-    if CONF_HEATER in config:
-        sens = await sensor.new_sensor(config[CONF_HEATER])
-        cg.add(var.set_heater(sens))
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_TEMPERATURE, var.set_temperature)
+    await sensors(CONF_HUMIDITY, var.set_humidity)
+    await sensors(CONF_HEATER, var.set_heater)

    cg.add(var.set_sensor_model(config[CONF_MODEL]))

--- a/Show More
+++ b/Show More