Point at can_proceed() for handshake-dependent flags

Keep writing the flag after setup, log that it stops working in 2027.3.0
Soften the set_internal() limitations wording
2026-09-10 14:57:32 +00:00 · 2026-09-10 09:01:09 -05:00 · 2026-09-10 09:00:37 -05:00 · 2026-09-10 08:56:35 -05:00 · 2026-09-10 08:54:55 -05:00 · 2026-09-10 08:51:42 -05:00
116 changed files with 2723 additions and 9443 deletions
@@ -1,39 +0,0 @@
-name: Cache Arduino ESP8266
-description: >
-  Resolve the pinned Arduino core and xtensa toolchain versions and cache the
-  native ESP8266 install (~110 MB framework + toolchain; no ccache store, the
-  seed job saves before any compile runs). Exports
-  ESPHOME_ARDUINO8266_PREFIX to the job so every later step installs into
-  the cached path; the Python venv must already be restored. Mirrors
-  cache-esp-idf: only dev-branch pushes write the shared cache, everything
-  else restores.
-runs:
-  using: composite
-  steps:
-    - name: Resolve the native toolchain cache key
-      # Versions are pinned in code, not a hashable file; resolve them so a
-      # bump changes the cache key. Assignment form so errexit catches a
-      # resolver failure.
-      id: version
-      shell: bash
-      run: |
-        # One owner for the install prefix: exported here and referenced by
-        # the cache steps below via env, so the caller's install and the
-        # cached path cannot diverge.
-        echo "ESPHOME_ARDUINO8266_PREFIX=$HOME/.esphome-arduino8266" >> "$GITHUB_ENV"
-        . venv/bin/activate
-        key=$(python -c 'from esphome.components.esp8266 import RECOMMENDED_ARDUINO_FRAMEWORK_VERSION as f; from esphome.arduino8266.framework import TOOLCHAIN_VERSION as t; print(f"{f}-{t}")')
-        [ -n "$key" ] || exit 1
-        echo "key=$key" >> "$GITHUB_OUTPUT"
-    - name: Cache the native toolchain (write on dev)
-      if: github.ref == 'refs/heads/dev'
-      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-      with:
-        path: ${{ env.ESPHOME_ARDUINO8266_PREFIX }}
-        key: ${{ runner.os }}-esp8266-native-${{ steps.version.outputs.key }}
-    - name: Restore the native toolchain (off dev)
-      if: github.ref != 'refs/heads/dev'
-      uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-      with:
-        path: ${{ env.ESPHOME_ARDUINO8266_PREFIX }}
-        key: ${{ runner.os }}-esp8266-native-${{ steps.version.outputs.key }}
@@ -102,8 +102,6 @@ jobs:
      device-builder: ${{ steps.determine.outputs.device-builder }}
      esp32-platformio: ${{ steps.determine.outputs.esp32-platformio }}
      esp32-platformio-components: ${{ steps.determine.outputs.esp32-platformio-components }}
-      esp8266-native: ${{ steps.determine.outputs.esp8266-native }}
-      esp8266-native-components: ${{ steps.determine.outputs.esp8266-native-components }}
      changed-components: ${{ steps.determine.outputs.changed-components }}
      changed-components-with-tests: ${{ steps.determine.outputs.changed-components-with-tests }}
      directly-changed-components-with-tests: ${{ steps.determine.outputs.directly-changed-components-with-tests }}
@@ -167,8 +165,6 @@ jobs:
          echo "device-builder=$(echo "$output" | jq -r '.device_builder')" >> $GITHUB_OUTPUT
          echo "esp32-platformio=$(echo "$output" | jq -r '.esp32_platformio')" >> $GITHUB_OUTPUT
          echo "esp32-platformio-components=$(echo "$output" | jq -r '.esp32_platformio_components')" >> $GITHUB_OUTPUT
-          echo "esp8266-native=$(echo "$output" | jq -r '.esp8266_native')" >> $GITHUB_OUTPUT
-          echo "esp8266-native-components=$(echo "$output" | jq -r '.esp8266_native_components')" >> $GITHUB_OUTPUT
          echo "changed-components=$(echo "$output" | jq -c '.changed_components')" >> $GITHUB_OUTPUT
          echo "changed-components-with-tests=$(echo "$output" | jq -c '.changed_components_with_tests')" >> $GITHUB_OUTPUT
          echo "directly-changed-components-with-tests=$(echo "$output" | jq -c '.directly_changed_components_with_tests')" >> $GITHUB_OUTPUT
@@ -187,32 +183,6 @@ jobs:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}

-  seed-esp8266-native-cache:
-    name: Seed the esp8266 native toolchain cache
-    runs-on: ubuntu-24.04
-    needs:
-      - common
-    # PR-branch cache saves are invisible to other PRs, so dev pushes seed
-    # the shared entry test-esp8266-native restores. 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
@@ -1267,7 +1237,7 @@ jobs:

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

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

-  test-esp8266-native:
-    name: Test esp8266 components with the native toolchain
-    runs-on: ubuntu-24.04
-    needs:
-      - common
-      - determine-jobs
-    if: github.event_name == 'pull_request' && needs.determine-jobs.outputs.esp8266-native == 'true'
-    env:
-      # Computed by script/determine-jobs.py (ESP8266_NATIVE_TEST_COMPONENTS)
-      TEST_COMPONENTS: ${{ needs.determine-jobs.outputs.esp8266-native-components }}
-    steps:
-      - name: Check out code from GitHub
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
-
-      - name: Cache the native toolchain
-        uses: ./.github/actions/cache-arduino8266
-
-      - name: Run native toolchain compile test
-        run: |
-          . venv/bin/activate
-
-          echo "Testing components: $TEST_COMPONENTS"
-          echo ""
-
-          # ESP8266 Arduino built directly (no PlatformIO); compile validates
-          # config first, so a separate config pass is redundant.
-          python3 script/test_build_components.py -e compile -t esp8266-ard -c "$TEST_COMPONENTS" -f --toolchain arduino --fail-on-no-tests
-
  device-builder:
    name: Test downstream esphome/device-builder
    runs-on: ubuntu-24.04
@@ -1672,7 +1608,6 @@ jobs:
    needs:
      - common
      - seed-apt-cache
-      - seed-esp8266-native-cache
      - determine-jobs
      - ci-custom
      - pylint
@@ -1688,7 +1623,6 @@ jobs:
      - clang-tidy-esp32-variants
      - test-build-components-split
      - test-esp32-platformio
-      - test-esp8266-native
      - device-builder
      - memory-impact-target-branch
      - memory-impact-pr-branch
@@ -33,7 +33,7 @@ jobs:
        and will be closed if no further activity occurs within 7 days.

        If you are the author of this PR, please leave a comment if you want
-        to keep it open. Also, please rebase your PR onto the latest dev
+        to keep it open. Also, please merge the latest dev branch into your
        branch to ensure that it's up to date with the latest changes.

        Thank you for your contribution!
@@ -817,9 +817,7 @@ def write_cpp_file() -> int:
        from esphome.build_gen import espidf

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

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

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

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

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

@@ -1961,39 +1962,15 @@ def command_update_all(args: ArgsProtocol) -> int | None:
    return run_multiple_configs(files, build_command)


-# Native build backend per (target platform, toolchain). Keyed here rather
-# than through a platform hook so the serial upload/logs fast path never
-# imports the platform component package (see the esp32 variant comment in
-# upload_using_esptool); the platform half comes from CORE.data the same way.
-_NATIVE_TOOLCHAIN_MODULES = {
-    ("esp32", Toolchain.ESP_IDF): "esphome.espidf.toolchain",
-    ("esp8266", Toolchain.ARDUINO): "esphome.arduino8266.toolchain",
-}
-
-
-def _native_toolchain_module():
-    """The native build backend module for the resolved toolchain."""
-    if not CORE.using_native_toolchain:
-        return None
-    key = (CORE.target_platform, CORE.toolchain)
-    if (module_path := _NATIVE_TOOLCHAIN_MODULES.get(key)) is None:
-        # Degrading to the PlatformIO path would build with the wrong backend
-        raise EsphomeError(
-            f"Toolchain '{CORE.toolchain.value}' has no native build backend "
-            f"module for platform {CORE.target_platform}"
-        )
-    return importlib.import_module(module_path)
-
-
 def command_idedata(args: ArgsProtocol, config: ConfigType) -> int:
    import json

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

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

-    # Refuse an unsupported toolchain before paying for a full compile
-    native_toolchain = _native_toolchain_module()
-    if native_toolchain is None and not CORE.using_toolchain_platformio:
-        _LOGGER.error(
-            "analyze-memory is not supported with the '%s' toolchain on %s; "
-            "re-run with --toolchain platformio",
-            CORE.toolchain.value if CORE.toolchain else "unresolved",
-            CORE.target_platform,
-        )
-        return 1
-
    # Always compile to ensure fresh data (fast if no changes - just relinks)
    exit_code = write_cpp(config)
    if exit_code != 0:
@@ -2054,31 +2020,13 @@ 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()
-        for tool in (objdump, readelf):
-            if not tool.is_file():
-                # The analyzer would silently fall back to host binutils,
-                # which cannot read the target ELF. clean-all is heavy for
-                # ESP-IDF, so suggest a recompile first.
-                _LOGGER.error(
-                    "%s is missing; the toolchain install may be incomplete "
-                    "(recompile, or run 'esphome clean-all' if it persists)",
-                    tool,
-                )
-                return 1
-        objdump_path = str(objdump)
-        readelf_path = str(readelf)
+    if CORE.using_toolchain_esp_idf:
+        from esphome.espidf import toolchain

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

@@ -19,7 +19,6 @@ from typing import NamedTuple

 from esphome.build_helpers.ccache import ccache_defaults_env
 from esphome.build_helpers.ninja import find_ninja
-from esphome.build_helpers.pch import ccache_pch_env
 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
@@ -157,6 +156,4 @@ def ccache_env(ccache: str | None) -> dict[str, str]:
    """
    if ccache is None:
        return {}
-    env = ccache_defaults_env(get_arduino8266_tools_path() / "ccache")
-    env.update(ccache_pch_env())
-    return env
+    return ccache_defaults_env(get_arduino8266_tools_path() / "ccache")
@@ -1,329 +0,0 @@
-"""Native Arduino ESP8266 build driver (the PlatformIO ``run`` equivalent)."""
-
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-import subprocess
-from typing import Any
-
-from esphome.arduino8266 import framework
-from esphome.build_helpers.ccache import resolve_ccache_path
-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_if_changed
-from esphome.types import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
-
-# ESP8266 user RAM (matches upload.maximum_ram_size in every board manifest)
-_MAX_RAM_SIZE = 81920
-
-
-def _warn_ignored_platformio_options() -> None:
-    """Warn for component-added platformio options the native build drops.
-
-    The consumed set is exported by core/config.py next to the routing that
-    stores these options, so the two cannot drift; YAML upload_speed never
-    reaches CORE.platformio_options here.
-    """
-    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")
-
-
-def get_build_dir() -> Path:
-    return CORE.relative_pioenvs_path(CORE.name)
-
-
-def get_elf_path() -> Path:
-    return get_build_dir() / "firmware.elf"
-
-
-def _toolchain_tool(name: str) -> Path:
-    return framework.toolchain_tool(framework.get_toolchain_path(), name)
-
-
-def get_factory_firmware_path() -> Path:
-    """The image to serial-flash at 0x0 (same bytes as firmware.bin: the
-    8266 factory copy exists for artifact-contract parity, not content)."""
-    return get_build_dir() / "firmware.factory.bin"
-
-
-def get_addr2line_path() -> Path:
-    return _toolchain_tool("addr2line")
-
-
-def get_objdump_path() -> Path:
-    return _toolchain_tool("objdump")
-
-
-def get_readelf_path() -> Path:
-    return _toolchain_tool("readelf")
-
-
-def run_compile(config: ConfigType, verbose: bool) -> int:
-    from esphome.build_gen import arduino8266 as build_gen
-
-    _warn_ignored_platformio_options()
-    paths = framework.check_and_install(CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION])
-    # Resolved once per build: the resolution probes PATH and spawns the
-    # runnability check, and three consumers need the same answer
-    ccache = resolve_ccache_path()
-    ninja_changed = build_gen.write_project(paths, ccache)
-
-    build_dir = get_build_dir()
-    env = framework.get_build_env(paths.toolchain, ccache)
-
-    # Regenerate the compile DB before the build (a pure function of
-    # build.ninja); skip only when it is at least as fresh as build.ninja
-    # (an interrupted previous run may have rewritten the manifest without
-    # regenerating the DB).
-    compdb = build_dir / "compile_commands.json"
-    compdb_stamp = build_dir / ".compile_commands.stamp"
-    ninja_file = build_dir / "build.ninja"
-    # Freshness rides a stamp: the DB itself is written through
-    # write_file_if_changed (its mtime feeds get_idedata's cache), so a
-    # regeneration with identical content would stay "stale" forever
-    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(paths.ninja, build_dir, env)
-        compdb_stamp.touch()
-
-    cmd = [str(paths.ninja)]
-    if verbose:
-        cmd.append("-v")
-    if jobs := config[CONF_ESPHOME].get(CONF_COMPILE_PROCESS_LIMIT):
-        cmd += ["-j", str(jobs)]
-    # Explicit targets, not the default statement: a generator defect that
-    # drops them fails loudly with "unknown target" instead of a green
-    # no-op run that leaves stale artifacts in place
-    targets = ["firmware.factory.bin", "firmware.ota.bin"]
-    cmd += targets
-
-    # A dry-run probe keeps a no-op rebuild quiet: ninja would only print
-    # "no work to do". A freshly rewritten manifest all but guarantees work,
-    # so skip the probe (and its full stat pass) on that path. cwd instead
-    # of -C also drops the "Entering directory" banner on real builds.
-    skip_build = False
-    if not ninja_changed:
-        probe = subprocess.run(
-            [str(paths.ninja), "-n", *targets],
-            cwd=build_dir,
-            env=env,
-            capture_output=True,
-            text=True,
-            check=False,
-            close_fds=False,
-        )
-        if probe.stderr.strip():
-            # A load-time diagnostic (e.g. "multiple rules generate X")
-            # flags a generator bug; the skip branch would otherwise
-            # swallow it forever
-            _LOGGER.warning("ninja: %s", probe.stderr.strip())
-        if probe.returncode != 0:
-            # An unknown target here is the defective-manifest case; fall
-            # through to the real build so the error prints attributably
-            _LOGGER.debug("ninja probe failed; running the full build")
-        skip_build = probe.returncode == 0 and "no work to do" in probe.stdout
-    if skip_build:
-        _LOGGER.debug("ninja: nothing to rebuild")
-    else:
-        _LOGGER.debug("Running: %s", " ".join(cmd))
-        rc = subprocess.run(
-            cmd, cwd=build_dir, env=env, check=False, close_fds=False
-        ).returncode
-        if rc != 0:
-            return rc
-
-    # ninja already refused a manifest missing the explicit targets above;
-    # existence covers the remaining hole (a rule that ran but wrote
-    # elsewhere). The factory/ota copies are what upload and OTA consume.
-    build_dir_artifacts = (
-        get_elf_path(),
-        build_dir / "firmware.bin",
-        get_factory_firmware_path(),
-        build_dir / "firmware.ota.bin",
-    )
-    for artifact in build_dir_artifacts:
-        if not artifact.is_file():
-            _LOGGER.error("Build produced no %s", artifact)
-            return 1
-
-    if not _print_size_summary(build_dir, paths):
-        # The cause was already warned; name the consequence so a build
-        # contributing no RAM/Flash metric is visible to CI harnesses
-        _LOGGER.warning("Firmware size summary unavailable for this build")
-    from esphome.build_helpers.idedata import warn_if_idedata_missing
-
-    warn_if_idedata_missing(lambda: get_idedata(ccache))
-    return 0
-
-
-def _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_if_changed keeps the mtime stable on no-op builds so the
-    # idedata cache in get_idedata() stays valid.
-    write_file_if_changed(compdb, result.stdout)
-
-
-def _parse_app_size(build_dir: Path, paths: framework.InstalledPaths) -> int | None:
-    """Read the app flash budget (irom0_0_seg length) from the linker script."""
-    from esphome.build_gen.arduino8266 import get_flash_ld_path
-    from esphome.components.esp8266.build_surgery import segment_length
-
-    # Warnings, not debug: without the app size the Flash summary line is
-    # dropped and CI's memory-impact extraction loses its flash metric.
-    ld_path = get_flash_ld_path(build_dir, paths)
-    try:
-        ld_text = ld_path.read_text(encoding="utf-8")
-    except (OSError, UnicodeDecodeError) as err:
-        # UnicodeDecodeError: a truncated/corrupt script must degrade to
-        # the same warning, never abort an already-linked build
-        _LOGGER.warning("Cannot read linker script for the Flash summary: %s", err)
-        return None
-    app_size = segment_length(ld_text, "irom0_0_seg")
-    if app_size is None:
-        _LOGGER.warning("irom0_0_seg not found in %s; skipping Flash summary", ld_path)
-        return None
-    if app_size == 0:
-        _LOGGER.warning(
-            "irom0_0_seg has zero length in %s; skipping Flash summary", ld_path
-        )
-        return None
-    return app_size
-
-
-def _print_size_summary(build_dir: Path, paths: framework.InstalledPaths) -> bool:
-    """Print the PlatformIO-shaped RAM/Flash lines; False when skipped.
-
-    The exact shape (including the bar) is parsed by
-    ``script/ci_memory_impact_extract.py``; ``print_size_line`` matches it.
-    """
-    from esphome.build_helpers.size_summary import print_size_line
-
-    size_tool = _toolchain_tool("size")
-    try:
-        result = subprocess.run(
-            [str(size_tool), "-A", "-d", str(get_elf_path())],
-            capture_output=True,
-            text=True,
-            check=False,
-            close_fds=False,
-        )
-    except OSError as err:
-        # The summary is a bonus artifact like idedata; a truncated
-        # toolchain extraction must not discard an already-linked build
-        _LOGGER.warning("Could not summarize firmware size: %s", err)
-        return False
-    if result.returncode != 0:
-        _LOGGER.warning("Could not summarize firmware size: %s", result.stderr)
-        return False
-    sections: dict[str, int] = {}
-    for line in result.stdout.splitlines():
-        parts = line.split()
-        if len(parts) >= 2 and parts[0].startswith("."):
-            try:
-                sections[parts[0]] = int(parts[1])
-            except ValueError:
-                # An unparsed RAM/Flash section trips the missing-sections
-                # guard below, so no total is built on a dropped value
-                _LOGGER.warning("Unparsable size output for section %s", parts[0])
-    if missing := set(_RAM_SECTIONS + _FLASH_SECTIONS) - set(sections):
-        # A defaulted 0 would print a confidently wrong total for CI's metric
-        _LOGGER.warning(
-            "Size output is missing section(s) %s; skipping the size summary",
-            ", ".join(sorted(missing)),
-        )
-        return False
-    # Resolve the flash budget before printing anything: a RAM line without
-    # its Flash line would let CI's memory-impact extraction sum the two
-    # metrics over different build counts (_parse_app_size already warned).
-    app_size = _parse_app_size(build_dir, paths)
-    if not app_size:
-        return False
-    ram = sum(sections[s] for s in _RAM_SECTIONS)
-    flash = sum(sections[s] for s in _FLASH_SECTIONS)
-    print_size_line("RAM", ram, _MAX_RAM_SIZE)
-    print_size_line("Flash", flash, app_size)
-    return True
-
-
-# Sentinel: "resolve for me"; None is a real value meaning disabled.
-_CCACHE_UNRESOLVED: Any = object()
-
-
-def get_idedata(ccache: str | None = _CCACHE_UNRESOLVED) -> dict | None:
-    """Derive idedata from the build's compile_commands.json.
-
-    Same contract as ``espidf.toolchain.get_idedata``: the fields IDE
-    integrations, clang-tidy, and the memory analyzer expect.
-    """
-    from esphome.build_helpers.idedata import load_or_build_idedata
-
-    if ccache is _CCACHE_UNRESOLVED:
-        # Deliberately uncached: env/PATH can change between builds in a
-        # long-lived host process
-        ccache = resolve_ccache_path()
-    return load_or_build_idedata(
-        get_build_dir() / "compile_commands.json",
-        get_elf_path(),
-        # Suffixed so a platformio->arduino->platformio round trip on one
-        # config never serves the other toolchain's cache shape
-        CORE.relative_internal_path("idedata", f"{CORE.name}.arduino.json"),
-        # The compile DB's commands carry the same ccache prefix the ninja
-        # rules were generated with
-        launcher=str(ccache) if ccache else None,
-    )
@@ -4,14 +4,6 @@ import json
 import logging
 from pathlib import Path

-from esphome.build_helpers import pch
-from esphome.build_helpers.pch import (
-    PCH_DEFAULT_HEADERS,
-    PCH_HEADER_NAME,
-    mark_pch_emitted,
-    pch_enabled,
-    pch_header_text,
-)
 from esphome.components.esp32 import (
    get_esp32_variant,
    get_excluded_builtin_components,
@@ -287,67 +279,9 @@ idf_component_register(
 target_link_options(${{COMPONENT_LIB}} PUBLIC
    {link_opts_str}
 )
-{_pch_cmake()}"""
-
-
-def _pch_cmake() -> str:
-    """The src component's precompiled-header block (C++ TUs only).
-
-    The -include stays relative (resolved from the compiler cwd, the build
-    dir); an absolute path would poison ccache keys.
-    """
-    if not pch_enabled():
-        return ""
-    return f"""
-# ESPHome precompiled header (see esphome/build_helpers/pch.py).
-# OBJECT_DEPENDS is on the header, not the .gch: pch-baked headers drop
-# out of TU depfiles, and prepare_pch() touches the header on rebuild.
-target_compile_options(${{COMPONENT_LIB}} PRIVATE
-    "$<$<COMPILE_LANGUAGE:CXX>:-Winvalid-pch>"
-    "$<$<COMPILE_LANGUAGE:CXX>:-include>"
-    "$<$<COMPILE_LANGUAGE:CXX>:{PCH_HEADER_NAME}>"
-)
-set_source_files_properties(${{app_sources}} PROPERTIES
-    OBJECT_DEPENDS "${{CMAKE_BINARY_DIR}}/{PCH_HEADER_NAME}")
 """


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

-    if pch_enabled():
-        write_file_if_changed(
-            CORE.relative_build_path("build", PCH_HEADER_NAME),
-            pch_header_text(PCH_DEFAULT_HEADERS),
-        )
-        # Consumers carry the -include; gate the ccache relaxation on it
-        mark_pch_emitted()
-
    # Snapshot the exclusion set so has_outdated_files() can trigger a
    # discovery reconfigure when it changes. Excluded components never
    # register in project_description.json, so re-including one (e.g. a
@@ -87,19 +87,6 @@ def ccache_defaults_env(cache_dir: Path) -> dict[str, str]:
        "CCACHE_DIR": str(cache_dir),
        "CCACHE_NOHASHDIR": "true",
        "CCACHE_DEPEND": "1",
-        # A user value wins via the filter below
-        "CCACHE_BASEDIR": effective_ccache_basedir(),
+        "CCACHE_BASEDIR": str(Path(CORE.build_path).resolve()),
    }
    return {k: v for k, v in defaults.items() if k not in os.environ}
-
-
-def effective_ccache_basedir() -> str:
-    """The prefix ccache rewrites out of hashed paths: a user CCACHE_BASEDIR
-    wins, else the resolved build path (matching ccache_defaults_env)."""
-    from esphome.core import CORE
-
-    raw = os.environ.get("CCACHE_BASEDIR")
-    if raw is not None and Path(raw).is_absolute() and len(Path(raw).parts) > 1:
-        return raw
-    # Unset or degenerate ("", "/", relative): fall back to the build path
-    return str(Path(CORE.build_path).resolve())
@@ -11,7 +11,6 @@ consumers (IDE integration, clang-tidy) expect:

 from __future__ import annotations

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

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

+_LOGGER = logging.getLogger(__name__)

-def warn_if_idedata_missing(get_idedata: Callable[[], dict | None]) -> None:
-    """Run an idedata generator, downgrading any failure to a warning.
-
-    Shared by the native backends: the firmware already built, so a missing
-    or broken idedata must not fail a successful build.
-    """
-    try:
-        if get_idedata() is None:
-            _LOGGER.warning("No idedata was generated for this build")
-    except IDEDATA_BEST_EFFORT_ERRORS as err:
-        _LOGGER.warning(
-            "Could not generate idedata: %s (IDE, clang-tidy, and "
-            "memory-analysis data will be unavailable for this build)",
-            err,
-        )
-        if isinstance(err, (EsphomeError, OSError)):
-            # Routine environmental failures keep the detail at debug
-            _LOGGER.debug("Idedata failure detail", exc_info=True)
-        else:
-            # LookupError/ValueError/RuntimeError smell like a parsing bug;
-            # a permanently masked traceback would hide it on every build
-            _LOGGER.warning("Idedata failure detail", exc_info=True)
-
-
-# C++ translation-unit suffixes.
-CXX_SOURCE_SUFFIXES = (".cpp", ".cc", ".cxx")
+# C++ translation-unit suffixes used to identify ESPHome source files.
+_CXX_SUFFIXES = (".cpp", ".cc")
 # Suffixes of input/output files that appear bare on the command line (and so
 # must not be mistaken for compiler flags).
-_INPUT_FILE_SUFFIXES = (*CXX_SOURCE_SUFFIXES, ".c", ".o", ".S", ".s")
+_INPUT_FILE_SUFFIXES = (*_CXX_SUFFIXES, ".c", ".o", ".S", ".s")
 # Path marker identifying an ESPHome source translation unit.
 _ESPHOME_SRC_MARKER = "/src/esphome/"

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


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

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


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

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

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


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


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

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

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


@@ -311,7 +256,7 @@ def _cache_usable(cached: object) -> bool:
    if not isinstance(cached, dict) or "cc_path" not in cached:
        return False
    cxx_path = cached.get("cxx_path")
-    if not isinstance(cxx_path, str) or is_launcher(cxx_path):
+    if not isinstance(cxx_path, str) or _is_launcher(cxx_path):
        return False
    includes = cached.get("includes")
    return isinstance(includes, dict) and isinstance(includes.get("build"), list)
@@ -359,7 +304,7 @@ def load_or_build_idedata(
 def reject_launcher_compiler(cxx_path: str) -> None:
    """Reject a compile DB naming a launcher (ccache) as the compiler; it
    must never be probed, cached, or consumed."""
-    if is_launcher(cxx_path):
+    if _is_launcher(cxx_path):
        raise EsphomeError(
            f"compile_commands.json names the launcher {cxx_path} as the "
            "compiler; the compile database is unusable"
@@ -1,423 +0,0 @@
-"""Shared precompiled-header policy for the build backends.
-
-The prefix either mirrors the TUs' own force-includes (ESP8266) or is a
-curated core-header set (ESP-IDF). ``esphome: includes:`` sources receive
-it too; Arduino.h visibility there is intended (esphome#8693).
-"""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-import hashlib
-import json
-import logging
-import os
-from pathlib import Path
-import posixpath
-import re
-import stat
-import subprocess
-
-from esphome.build_helpers.ccache import effective_ccache_basedir, parse_enable_env
-from esphome.build_helpers.idedata import (
-    CXX_SOURCE_SUFFIXES,
-    expand_response_files,
-    is_launcher,
-    split_command,
-)
-
-_DOMAIN = "pch"
-
-
-@dataclass
-class _PCHData:
-    emitted: bool = False
-
-
-def _pch_data() -> _PCHData:
-    from esphome.core import CORE
-
-    if _DOMAIN not in CORE.data:
-        CORE.data[_DOMAIN] = _PCHData()
-    return CORE.data[_DOMAIN]
-
-
-def mark_pch_emitted() -> None:
-    """Record that this build's consumers reference the pch."""
-    _pch_data().emitted = True
-
-
-_LOGGER = logging.getLogger(__name__)
-
-# The header and its .gch/.sum sidecars live in the build directory.
-PCH_HEADER_NAME = "esphome_pch.h"
-
-# Every artifact the pch machinery can leave behind, for cleanup.
-PCH_ARTIFACT_NAMES = (
-    PCH_HEADER_NAME,
-    f"{PCH_HEADER_NAME}.gch",
-    f"{PCH_HEADER_NAME}.gch.sum",
-    f"{PCH_HEADER_NAME}.gch.failed",
-)
-
-# The core defines header every backend anchors its prefix on.
-PCH_CORE_HEADER = "esphome/core/defines.h"
-
-# Prefix-header contents for backends that inject a curated set (rather
-# than mirroring the TUs' own force-includes), defines.h first so USE_*
-# macros exist for the rest. Deliberately hard-coded: frequency-derived
-# sets measured no better and kept selecting headers that cannot compile
-# standalone (X-macro, platform-variant). Every entry must be safe to
-# include first in an empty TU. Caveat: application.h/automation.h become
-# ambiently visible, so a TU missing those #includes still builds on such
-# backends; ESPHOME_PCH_ENABLE=0 restores the strict view.
-PCH_DEFAULT_HEADERS = (
-    PCH_CORE_HEADER,
-    "esphome/core/component.h",
-    "esphome/core/helpers.h",
-    "esphome/core/log.h",
-    "esphome/core/application.h",
-    "esphome/core/automation.h",
-)
-
-# ccache cannot hash through a .gch; CCACHE_PCH_EXTSUM makes it hash the
-# .sum sidecar instead of the .gch bytes, which are not reproducible.
-# Keep in sync with the literals in platformio/pch.py.script.
-_CCACHE_PCH_ENV = {
-    "CCACHE_SLOPPINESS": "pch_defines,time_macros",
-    "CCACHE_PCH_EXTSUM": "true",
-}
-
-# Both include forms: an angle include resolving under src/ must enter the
-# digest too; ones that do not resolve simply end the walk
-# Compiler failures that clear on their own must not latch the .failed marker
-_TRANSIENT_ERRORS = ("No space left", "Cannot allocate", "Resource temporarily")
-
-_INCLUDE_RE = re.compile(rb'^\s*#\s*include\s+["<]([^">]+)[">]', re.MULTILINE)
-
-
-def pch_enabled() -> bool:
-    """Precompiled-header knob: default on, ``ESPHOME_PCH_ENABLE=0`` opts out."""
-    return parse_enable_env("ESPHOME_PCH_ENABLE") is not False
-
-
-def ccache_pch_env() -> dict[str, str]:
-    """Settings ccache needs to cache compiles that consume the .gch;
-    empty unless this build actually emitted one. User-set values win.
-    Native backends export these process-wide; only time_macros affects
-    non-pch TUs."""
-    if not (pch_enabled() and _pch_data().emitted):
-        return {}
-    extsum = os.environ.get("CCACHE_PCH_EXTSUM")
-    if extsum is not None and extsum.strip().lower() not in ("1", "true", "yes", "on"):
-        # ccache then hashes the non-reproducible .gch bytes: permanent misses
-        _LOGGER.warning("CCACHE_PCH_EXTSUM=%s disables pch caching", extsum)
-    env = {k: v for k, v in _CCACHE_PCH_ENV.items() if k not in os.environ}
-    user_sloppiness = os.environ.get("CCACHE_SLOPPINESS")
-    if user_sloppiness is not None and (
-        missing := [
-            t
-            for t in ("pch_defines", "time_macros")
-            if t not in {tok.strip() for tok in user_sloppiness.split(",")}
-        ]
-    ):
-        # Without these ccache declines every pch-consuming compile
-        env["CCACHE_SLOPPINESS"] = ",".join((user_sloppiness, *missing))
-        _LOGGER.warning(
-            "Adding %s to CCACHE_SLOPPINESS so ccache can cache compiles "
-            "that use the precompiled header",
-            ",".join(missing),
-        )
-    return env
-
-
-def pch_extra_scripts() -> list[str]:
-    """The extra_scripts entries a PlatformIO platform registers for the
-    pch; empty when disabled (the script itself has no enable check)."""
-    return ["post:pch.py"] if pch_enabled() else []
-
-
-def pch_header_text(include_headers: Iterable[str]) -> str:
-    """The prefix-header source: exactly these includes, in order."""
-    return "".join(f'#include "{name}"\n' for name in include_headers)
-
-
-def _resolves(path: Path) -> bool:
-    """False when missing; other stat failures propagate (identity unknown,
-    unlike is_file(), which would silently drop the header)."""
-    try:
-        return stat.S_ISREG(path.stat().st_mode)
-    except (FileNotFoundError, NotADirectoryError):
-        return False
-
-
-def _include_closure(src_dir: Path, roots: Iterable[str]) -> dict[str, bytes]:
-    """Include closure of ``roots``: src-relative name -> contents.
-
-    Resolution mirrors the compiler (includer's dir, then src root); names
-    outside ``src_dir`` end the walk and are versioned by the caller. No
-    #ifdef evaluation: over-approximating is the safe direction.
-    """
-    seen: dict[str, bytes] = {}
-    stack: list[tuple[str, str]] = [(name, "") for name in roots]
-    while stack:
-        name, from_dir = stack.pop()
-        for candidate in (f"{from_dir}/{name}" if from_dir else name, name):
-            rel = posixpath.normpath(candidate)
-            if not rel.startswith("..") and _resolves(src_dir / rel):
-                break
-        else:
-            continue
-        if rel in seen:
-            continue
-        try:
-            data = (src_dir / rel).read_bytes()
-        except OSError as err:
-            # A marker would truncate the transitive walk; fail closed
-            _LOGGER.warning("Could not read %s for the pch checksum: %s", rel, err)
-            raise
-        seen[rel] = data
-        parent = posixpath.dirname(rel)
-        stack.extend(
-            # surrogateescape: a non-UTF-8 name just fails to resolve
-            (inc.decode(errors="surrogateescape"), parent)
-            for inc in _INCLUDE_RE.findall(data)
-        )
-    return seen
-
-
-def pch_checksum(
-    src_dir: Path, include_headers: Iterable[str], extra: Iterable[str]
-) -> str:
-    """Digest standing in for the .gch in ccache's hash: the include closure
-    of the prefix header plus caller-supplied identity strings (versioned
-    install paths, flags). Raises OSError when a header's identity cannot
-    be established at all; callers must then compile without a pch."""
-    digest = hashlib.sha256()
-    closure = _include_closure(src_dir, include_headers)
-    for name in sorted(closure):
-        digest.update(name.encode(errors="surrogateescape"))
-        digest.update(closure[name])
-        digest.update(b"\0")
-    for item in extra:
-        digest.update(item.encode(errors="surrogateescape"))
-        digest.update(b"\0")
-    return digest.hexdigest()
-
-
-# Tokens dropped when retargeting a TU's flags at the prefix header
-# (the pch compile must not touch depfiles)
-_PCH_STRIP_FLAGS_WITH_ARG = frozenset({"-o", "-c", "-MT", "-MF", "-MQ"})
-_PCH_STRIP_FLAGS = frozenset({"-MD", "-MMD", "-MP", "-MM", "-M"})
-
-
-def pch_compile_command(
-    build_dir: Path, header: Path, gch: Path
-) -> tuple[list[str], Path] | None:
-    """The exact src C++ flags from compile_commands.json retargeted at the
-    header, with the directory they resolve against (relative -I paths must
-    be expanded and executed from the same root); None (logged) when no
-    configured C++ TU is available yet."""
-    from esphome.core import CORE
-
-    try:
-        entries = json.loads(
-            (build_dir / "compile_commands.json").read_text(encoding="utf-8")
-        )
-    except (OSError, json.JSONDecodeError) as err:
-        # Configure already succeeded, so an unusable DB is a real anomaly
-        _LOGGER.warning("No usable compile database, skipping pch: %s", err)
-        return None
-    if not isinstance(entries, list):
-        _LOGGER.warning("Malformed compile database, skipping pch")
-        return None
-    # CMake may spell paths through a symlink differently than CORE does
-    # (macOS /tmp vs /private/tmp), so compare resolved paths
-    src_root = Path(CORE.relative_src_path()).resolve()
-    entry = next(
-        (
-            e
-            for e in entries
-            if isinstance(e, dict)
-            and isinstance(e.get("file"), str)
-            and e["file"].endswith(CXX_SOURCE_SUFFIXES)
-            and Path(e["file"]).resolve().is_relative_to(src_root)
-        ),
-        None,
-    )
-    if entry is None:
-        _LOGGER.warning("No src C++ entry in the compile database, skipping pch")
-        return None
-    directory = entry.get("directory")
-    cmd_dir = Path(directory) if isinstance(directory, str) and directory else build_dir
-    command = entry.get("command")
-    tokens = expand_response_files(
-        split_command(command if isinstance(command, str) else ""), cmd_dir
-    )
-    # A DB recorded with ccache enabled prefixes the compiler with the
-    # launcher; the .gch must be compiled directly
-    if tokens and is_launcher(tokens[0]):
-        tokens = tokens[1:]
-    if not tokens:
-        # "arguments"-style or empty entries must skip, not spawn "-x ..."
-        _LOGGER.warning("Compile database entry has no usable command, skipping pch")
-        return None
-    args: list[str] = []
-    arg_it = iter(tokens)
-    for tok in arg_it:
-        if tok in _PCH_STRIP_FLAGS_WITH_ARG:
-            next(arg_it, None)
-            continue
-        if tok in _PCH_STRIP_FLAGS:
-            continue
-        if tok == "-include":
-            # Drop only the injected prefix; user force-includes must reach
-            # the .gch compile or GCC rejects it over the macro mismatch
-            inc = next(arg_it, "")
-            if not inc.endswith(PCH_HEADER_NAME):
-                args.extend(("-include", inc))
-            continue
-        args.append(tok)
-    return [*args, "-x", "c++-header", "-c", str(header), "-o", str(gch)], cmd_dir
-
-
-def _log_pch_in_use() -> None:
-    # The only place a user can discover the knob; emitted only once a
-    # .gch is actually fresh or being built
-    _LOGGER.info(
-        "Compiling with a precompiled header (set ESPHOME_PCH_ENABLE=0 to disable)"
-    )
-
-
-def _read_stamp(path: Path) -> str:
-    """A corrupt sidecar must read as stale, not kill the pch forever."""
-    try:
-        return path.read_text(encoding="utf-8").strip()
-    except (OSError, UnicodeDecodeError):
-        return ""
-
-
-def discard_pch(build_dir: Path) -> None:
-    """Remove the pch sidecars so a stale .gch is never consumed.
-
-    Bumps the header only when a .gch was actually removed: TUs compiled
-    against it have incomplete depfiles, while a repeat failure with no
-    .gch must not force a full rebuild every build.
-    """
-    header = build_dir / PCH_HEADER_NAME
-    gch = Path(f"{header}.gch")
-    had_gch = gch.is_file()
-    gch.unlink(missing_ok=True)
-    Path(f"{gch}.sum").unlink(missing_ok=True)
-    if had_gch and header.is_file():
-        os.utime(header)
-
-
-def prepare_pch(
-    build_dir: Path, include_headers: tuple[str, ...], extra: Iterable[str]
-) -> None:
-    """Compile ``build_dir``'s .gch from compile_commands.json flags and
-    write its ccache .sum.
-
-    The .sum doubles as the freshness stamp and folds in the compile
-    command, so a flag-only change rebuilds the .gch; ``extra`` carries
-    backend identity (framework version, sdkconfig, ...). A failed
-    compile falls back to the plain header include.
-    """
-    from esphome.core import CORE
-
-    header = build_dir / PCH_HEADER_NAME
-    gch = Path(f"{header}.gch")
-    sum_path = Path(f"{gch}.sum")
-    cmd_and_dir = pch_compile_command(build_dir, header, gch)
-    if cmd_and_dir is None:
-        # Freshness cannot be validated; a leftover .gch must not be consumed
-        discard_pch(build_dir)
-        return
-    cmd, cmd_dir = cmd_and_dir
-    # Strip like ccache's rewriting (user CCACHE_BASEDIR wins); the raw
-    # build path covers unresolved (symlinked) spellings
-    cmd_id = (
-        " ".join(cmd)
-        .replace(effective_ccache_basedir(), "")
-        .replace(str(CORE.build_path), "")
-    )
-    try:
-        checksum = pch_checksum(
-            CORE.relative_src_path(),
-            include_headers,
-            (
-                # The closure is sorted, so root order only enters via the text
-                pch_header_text(include_headers),
-                *extra,
-                cmd_id,
-            ),
-        )
-    except (OSError, UnicodeError) as err:
-        # Identity unknown: a stale cache entry must never be served
-        _LOGGER.warning(
-            "Could not establish the pch identity; compiling without it: %s", err
-        )
-        discard_pch(build_dir)
-        return
-    if gch.is_file() and _read_stamp(sum_path) == checksum:
-        _log_pch_in_use()
-        return
-    failed_marker = Path(f"{gch}.failed")
-    if _read_stamp(failed_marker) == checksum:
-        _LOGGER.info(
-            "Precompiled header disabled after an earlier failure; delete %s to retry",
-            failed_marker,
-        )
-        return
-    _log_pch_in_use()
-    try:
-        result = subprocess.run(
-            cmd,
-            cwd=cmd_dir,
-            # C locale keeps diagnostics matchable by _TRANSIENT_ERRORS
-            env={**os.environ, "LC_ALL": "C"},
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=300,
-        )
-        error = None
-        if result.returncode < 0:
-            # Killed by a signal (OOM, ^C): environmental, do not latch
-            _LOGGER.warning(
-                "Precompiled header compile was killed (signal %d); retrying "
-                "next build",
-                -result.returncode,
-            )
-            discard_pch(build_dir)
-            return
-        if result.returncode != 0:
-            error = result.stderr.strip() or f"exit code {result.returncode}"
-        elif not gch.is_file():
-            error = "compiler produced no .gch"
-    except (OSError, subprocess.SubprocessError) as err:
-        # Transient (timeout, spawn/IO): warn and retry next build, no marker
-        _LOGGER.warning("Precompiled header compile did not run: %s", err)
-        discard_pch(build_dir)
-        return
-    if error is not None:
-        _LOGGER.warning(
-            "Precompiled header failed; compiling without it: %s", error[:400]
-        )
-        # This path latches, so keep the full compiler output recoverable
-        _LOGGER.debug("Full pch compile output: %s", error)
-        discard_pch(build_dir)
-        if any(m in error for m in _TRANSIENT_ERRORS):
-            # Resource exhaustion clears on its own; retry next build
-            return
-        # Skip retries until a header/flag/backend-identity/command change
-        failed_marker.write_text(checksum + "\n", encoding="utf-8")
-        os.utime(header)
-        return
-    failed_marker.unlink(missing_ok=True)
-    sum_path.write_text(checksum + "\n", encoding="utf-8")
-    # Consumers depend on the header (depfiles cannot see through a .gch);
-    # bump it so users of the previous .gch recompile
-    os.utime(header)
@@ -58,6 +58,9 @@ esp_err_t AudioReader::add_sink(const std::weak_ptr<ring_buffer::RingBuffer> &ou
  if (current_audio_file_ != nullptr) {
    // A transfer buffer isn't ncessary for a local file
    this->file_ring_buffer_ = output_ring_buffer.lock();
+    if (this->file_ring_buffer_ == nullptr) {
+      return ESP_ERR_INVALID_STATE;
+    }
    return ESP_OK;
  }

@@ -51,14 +51,14 @@ void AudioTransferBuffer::increase_buffer_length(size_t bytes) { this->buffer_le

 void AudioTransferBuffer::clear_buffered_data() {
  this->buffer_length_ = 0;
-  if (this->ring_buffer_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    this->ring_buffer_->reset();
  }
 }

 void AudioSinkTransferBuffer::clear_buffered_data() {
  this->buffer_length_ = 0;
-  if (this->ring_buffer_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    this->ring_buffer_->reset();
  }
 #ifdef USE_SPEAKER
@@ -69,7 +69,7 @@ void AudioSinkTransferBuffer::clear_buffered_data() {
 }

 bool AudioTransferBuffer::has_buffered_data() const {
-  if (this->ring_buffer_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
  }
  return (this->available() > 0);
@@ -144,7 +144,7 @@ size_t AudioSourceTransferBuffer::transfer_data_from_source(TickType_t ticks_to_
  size_t bytes_to_read = AudioTransferBuffer::free();
  size_t bytes_read = 0;
  if (bytes_to_read > 0) {
-    if (this->ring_buffer_.use_count() > 0) {
+    if (this->ring_buffer_ != nullptr) {
      bytes_read = this->ring_buffer_->read((void *) this->get_buffer_end(), bytes_to_read, ticks_to_wait);
    }

@@ -161,7 +161,7 @@ size_t AudioSinkTransferBuffer::transfer_data_to_sink(TickType_t ticks_to_wait,
      bytes_written = this->speaker_->play(this->data_start_, this->available(), ticks_to_wait);
    } else
 #endif
-        if (this->ring_buffer_.use_count() > 0) {
+        if (this->ring_buffer_ != nullptr) {
      bytes_written =
          this->ring_buffer_->write_without_replacement((void *) this->data_start_, this->available(), ticks_to_wait);
    } else if (this->sink_callback_ != nullptr) {
@@ -186,7 +186,7 @@ bool AudioSinkTransferBuffer::has_buffered_data() const {
    return (this->speaker_->has_buffered_data() || (this->available() > 0));
  }
 #endif
-  if (this->ring_buffer_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
  }
  return (this->available() > 0);
@@ -44,7 +44,7 @@ bool DeepSleepComponent::prepare_to_sleep_() {
          this->status_set_warning();
          ESP_LOGV(TAG, "Waiting for pin to switch state to enter deep sleep...");
        }
-        this->next_enter_deep_sleep_ = true;
+        this->defer_sleep_();
        return false;
      }
    }
@@ -17,6 +17,7 @@ void DeepSleepComponent::setup() {

 void DeepSleepComponent::schedule_sleep_() {
  this->next_enter_deep_sleep_ = false;
+  this->disable_loop();
  const optional<uint32_t> run_duration = get_run_duration_();
  if (run_duration.has_value()) {
    ESP_LOGI(TAG, "Scheduling in %" PRIu32 " ms", *run_duration);
@@ -45,7 +46,7 @@ void DeepSleepComponent::loop() {

 void DeepSleepComponent::begin_sleep(bool manual) {
  if (this->prevent_ && !manual) {
-    this->next_enter_deep_sleep_ = true;
+    this->defer_sleep_();
    return;
  }

@@ -190,6 +190,11 @@ class DeepSleepComponent final : public Component {
  void schedule_sleep_();
  bool should_teardown_();

+  void defer_sleep_() {
+    this->next_enter_deep_sleep_ = true;
+    this->enable_loop();
+  }
+
 #ifdef USE_BK72XX
  bool pin_prevents_sleep_(WakeUpPinItem &pin_item) const;
  bool get_real_pin_state_(InternalGPIOPin &pin) const { return (pin.digital_read() ^ pin.is_inverted()); }
@@ -100,7 +100,7 @@ bool DeepSleepComponent::prepare_to_sleep_() {
      this->status_set_warning();
      ESP_LOGW(TAG, "Waiting for wakeup pin state change");
    }
-    this->next_enter_deep_sleep_ = true;
+    this->defer_sleep_();
    return false;
  }
  return true;
@@ -3,10 +3,8 @@ from pathlib import Path
 import platform
 import re
 import subprocess
-import time
 from typing import Any

-from esphome.build_helpers.pch import pch_extra_scripts
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -16,7 +14,6 @@ from esphome.const import (
    CONF_FRAMEWORK,
    CONF_PLATFORM_VERSION,
    CONF_SOURCE,
-    CONF_TOOLCHAIN,
    CONF_VERSION,
    KEY_CORE,
    KEY_FRAMEWORK_VERSION,
@@ -24,7 +21,6 @@ from esphome.const import (
    KEY_TARGET_PLATFORM,
    PLATFORM_ESP8266,
    ThreadModel,
-    Toolchain,
 )
 from esphome.core import (
    CORE,
@@ -35,13 +31,12 @@ from esphome.core import (
 )
 from esphome.core.config import BOARD_MAX_LENGTH
 from esphome.helpers import IS_MACOS, copy_file_if_changed
-from esphome.platformio.toolchain import copy_ccache_script, copy_pch_script
+from esphome.platformio.toolchain import copy_ccache_script
 from esphome.storage_json import StorageJSON
 from esphome.types import ConfigType

-from .boards import BOARDS, ESP8266_BOARD_BUILD, board_ld_script
+from .boards import BOARDS, board_ld_script
 from .const import (
-    BUILD_FLASH_MODES,
    CONF_EARLY_PIN_INIT,
    CONF_ENABLE_SERIAL,
    CONF_ENABLE_SERIAL1,
@@ -49,7 +44,6 @@ from .const import (
    KEY_BOARD,
    KEY_ESP8266,
    KEY_PIN_INITIAL_STATES,
-    KEY_SCANF_FLOAT,
    KEY_SERIAL1_REQUIRED,
    KEY_SERIAL_REQUIRED,
    KEY_WAVEFORM_REQUIRED,
@@ -109,53 +103,6 @@ def set_core_data(config: ConfigType) -> ConfigType:
    return config


-_TOOLCHAINS = (Toolchain.PLATFORMIO, Toolchain.ARDUINO)
-_validate_toolchain = cv.toolchain_enum(_TOOLCHAINS)
-_resolve_toolchain = cv.resolve_toolchain("ESP8266", _TOOLCHAINS, Toolchain.PLATFORMIO)
-
-
-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
-
-    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"
-        )
-    # platform_version is a PlatformIO concept; drop it (as esp32's native
-    # toolchain does), warning when a custom pin is discarded. The floor
-    # above guarantees the schema-derived default is the ARDUINO_4 spec.
-    if (
-        conf.pop(CONF_PLATFORM_VERSION, _ARDUINO_4_PLATFORM_SPEC)
-        != _ARDUINO_4_PLATFORM_SPEC
-    ):
-        _LOGGER.warning(
-            "'platform_version' is ignored by 'toolchain: arduino'; the native "
-            "toolchain downloads the framework and compiler directly"
-        )
-    if conf[CONF_SOURCE] != _format_framework_arduino_version(version):
-        raise cv.Invalid(
-            "'toolchain: arduino' does not support a custom framework source; "
-            "use 'toolchain: platformio'"
-        )
-    # BOARDS is a subset of ESP8266_BOARD_BUILD today; the second clause is
-    # a drift guard for the independently regenerated tables
-    if (
-        config[CONF_BOARD] not in BOARDS
-        or config[CONF_BOARD] not in ESP8266_BOARD_BUILD
-    ):
-        raise cv.Invalid(
-            f"Board '{config[CONF_BOARD]}' is not supported by "
-            "'toolchain: arduino'; use 'toolchain: platformio'"
-        )
-    return config
-
-
 def get_download_types(storage_json: StorageJSON) -> list[dict[str, str]]:
    """Binary-download entries for a built ESP8266 firmware.

@@ -185,7 +132,7 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
    # 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.
+    # version bump cannot drift between the two paths.
    from esphome.arduino8266.framework import framework_package_version

    try:
@@ -247,7 +194,7 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
    platform_version = value.get(CONF_PLATFORM_VERSION)
    if platform_version is None:
        if version >= cv.Version(3, 1, 0):
-            platform_version = _ARDUINO_4_PLATFORM_SPEC
+            platform_version = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
        else:
            platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
    value[CONF_PLATFORM_VERSION] = platform_version
@@ -270,10 +217,6 @@ def _parse_platform_version(value: Any) -> str:
        return value


-# The platform_version derived for every core >= 3.1.0 config
-_ARDUINO_4_PLATFORM_SPEC = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
-
-
 ARDUINO_FRAMEWORK_SCHEMA = cv.All(
    cv.Schema(
        {
@@ -290,6 +233,7 @@ ARDUINO_FRAMEWORK_SCHEMA = cv.All(
 )


+BUILD_FLASH_MODES = ["qio", "qout", "dio", "dout"]
 CONFIG_SCHEMA = cv.All(
    cv.Schema(
        {
@@ -306,30 +250,15 @@ CONFIG_SCHEMA = cv.All(
            cv.Optional(CONF_ENABLE_SERIAL1): cv.boolean,
            cv.Optional(CONF_ENABLE_FULL_PRINTF, default=False): cv.boolean,
            cv.Optional(CONF_ENABLE_SCANF_FLOAT): cv.boolean,
-            cv.Optional(
-                CONF_TOOLCHAIN, visibility=cv.Visibility.ADVANCED
-            ): _validate_toolchain,
        }
    ),
-    _resolve_toolchain,
-    _validate_native_toolchain,
+    # Until the native toolchain lands, PlatformIO is the only backend;
+    # reject a --toolchain this platform cannot serve yet.
+    cv.require_platformio_toolchain("ESP8266"),
    set_core_data,
 )


-def native_toolchain_module():
-    """The native build backend for the resolved toolchain, if any.
-
-    ``__main__`` dispatches from its own toolchain-keyed table; this helper
-    serves the component's internal callers.
-    """
-    if not CORE.using_toolchain_arduino:
-        return None
-    from esphome.arduino8266 import toolchain
-
-    return toolchain
-
-
 def check_rosetta() -> None:
    """Fail fast when the x86_64 ESP8266 toolchain cannot run on this Mac.

@@ -365,13 +294,12 @@ def _choose_ld_script(board: str) -> str:

@coroutine_with_priority(CoroPriority.PLATFORM)
 async def to_code(config: ConfigType) -> None:
-    use_platformio = CORE.using_toolchain_platformio
    cg.add(esp8266_ns.setup_preferences())

-    if use_platformio:
-        cg.add_platformio_option("lib_ldf_mode", "off")
-        cg.add_platformio_option("lib_compat_mode", "strict")
-        cg.add_platformio_option("board", config[CONF_BOARD])
+    cg.add_platformio_option("lib_ldf_mode", "off")
+    cg.add_platformio_option("lib_compat_mode", "strict")
+
+    cg.add_platformio_option("board", config[CONF_BOARD])
    cg.add_build_flag("-DUSE_ESP8266")
    cg.set_cpp_standard("gnu++20")
    cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
@@ -387,33 +315,28 @@ async def to_code(config: ConfigType) -> None:
            "enabling scanf float support (~8KB flash)"
        )

-    # The native generator reads the same decision (KEY_SCANF_FLOAT)
-    CORE.data[KEY_ESP8266][KEY_SCANF_FLOAT] = bool(enable_scanf_float)
-    if use_platformio:
-        extra_scripts = [
-            "pre:ccache.py",
-            "pre:testing_mode.py",
-            "pre:exclude_updater.py",
-            "pre:exclude_waveform.py",
-            "pre:relocate_ratetable.py",
-        ]
-        if not enable_scanf_float:
-            extra_scripts.append("pre:remove_float_scanf.py")
-        extra_scripts.extend(pch_extra_scripts())
-        extra_scripts.append("post:post_build.py")
-        cg.add_platformio_option("extra_scripts", extra_scripts)
+    extra_scripts = [
+        "pre:ccache.py",
+        "pre:testing_mode.py",
+        "pre:exclude_updater.py",
+        "pre:exclude_waveform.py",
+        "pre:relocate_ratetable.py",
+    ]
+    if not enable_scanf_float:
+        extra_scripts.append("pre:remove_float_scanf.py")
+    extra_scripts.append("post:post_build.py")
+    cg.add_platformio_option("extra_scripts", extra_scripts)

    conf = config[CONF_FRAMEWORK]
+    cg.add_platformio_option("framework", "arduino")
    cg.add_build_flag("-DUSE_ARDUINO")
    cg.add_build_flag("-DUSE_ESP8266_FRAMEWORK_ARDUINO")
    cg.add_build_flag("-Wno-nonnull-compare")
-    if use_platformio:
-        cg.add_platformio_option("framework", "arduino")
-        cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
-        cg.add_platformio_option(
-            "platform_packages",
-            [f"platformio/framework-arduinoespressif8266@{conf[CONF_SOURCE]}"],
-        )
+    cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
+    cg.add_platformio_option(
+        "platform_packages",
+        [f"platformio/framework-arduinoespressif8266@{conf[CONF_SOURCE]}"],
+    )

    # Default for platformio is LWIP2_LOW_MEMORY with:
    #  - MSS=536
@@ -451,8 +374,7 @@ async def to_code(config: ConfigType) -> None:
    # Force-include inline std::__throw_* overrides so GCC dead-strips the unused
    # libstdc++ error message strings (e.g. "basic_string::_M_create") from DRAM.
    # See throw_stubs.h for details. Must be prepended before <string>, so this
-    # uses build_src_flags with -include. Unconditional: the native build
-    # generator reads the same option, keeping one source of truth.
+    # uses build_src_flags with -include.
    cg.add_platformio_option(
        "build_src_flags", "-include esphome/components/esp8266/throw_stubs.h"
    )
@@ -482,8 +404,6 @@ async def to_code(config: ConfigType) -> None:
    # implementation in the Arduino ESP8266 core.
    cg.add_build_flag("-Wl,--wrap=millis")

-    # Unconditional: the native build generator reads the same option,
-    # keeping one source of truth
    cg.add_platformio_option("board_build.flash_mode", config[CONF_BOARD_FLASH_MODE])

    ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
@@ -492,7 +412,7 @@ async def to_code(config: ConfigType) -> None:
        cg.RawExpression(f"VERSION_CODE({ver.major}, {ver.minor}, {ver.patch})"),
    )

-    if use_platformio and config[CONF_BOARD] in BOARDS:
+    if config[CONF_BOARD] in BOARDS:
        cg.add_platformio_option(
            "board_build.ldscript", _choose_ld_script(config[CONF_BOARD])
        )
@@ -533,24 +453,8 @@ async def finalize_serial_config() -> None:
        cg.add_build_flag("-DNO_GLOBAL_SERIAL1")


-# Called by __main__.compile_program; returning False falls through to the
-# PlatformIO toolchain.
-def run_compile(args, config: ConfigType) -> bool:
-    # Positive check: the native backend only runs when explicitly resolved
-    toolchain = native_toolchain_module()
-    if toolchain is None:
-        return False
-    if toolchain.run_compile(config, CORE.verbose) != 0:
-        raise EsphomeError("ESP8266 native build failed")
-    return True
-
-
 # Called by writer.py
 def copy_files() -> None:
-    # Native builds skip the PlatformIO extra scripts; the build generator
-    # carries their logic
-    if CORE.using_toolchain_arduino:
-        return
    dir = Path(__file__).parent
    for script in (
        "post_build",
@@ -565,7 +469,6 @@ def copy_files() -> None:
            CORE.relative_build_path(f"{script}.py"),
        )
    copy_ccache_script()
-    copy_pch_script()


 # ESP logs stack trace decoder, based on https://github.com/me-no-dev/EspExceptionDecoder
@@ -608,75 +511,22 @@ ESP8266_EXCEPTION_CODES = {
 }


-_DECODE_WARNED_AT: dict[str, float] = {}
+def _decode_pc(config: ConfigType, addr: str) -> None:
+    from esphome.platformio import toolchain

-
-def _warn_decode_problem(key: str, message: str, *args) -> bool:
-    """Warn, deduplicated briefly so a burst of stack-dump addresses warns
-    once but a later dump warns again; returns whether it warned so the
-    caller can mark suppressed addresses individually."""
-    now = time.monotonic()
-    last = _DECODE_WARNED_AT.get(key)
-    if last is not None and now - last < 30:
-        return False
-    _DECODE_WARNED_AT[key] = now
-    _LOGGER.warning(message, *args)
-    return True
-
-
-def _decode_pc(config: ConfigType, addr: str, *, bulk: bool = False) -> None:
-    """Decode one crash address. ``bulk``: the caller is scanning every
-    8-hex stack word, most of which are not code addresses -- unmappable
-    ones log at debug so real frames are not buried."""
-    if (native_toolchain := native_toolchain_module()) is not None:
-        addr2line = native_toolchain.get_addr2line_path()
-        elf = native_toolchain.get_elf_path()
-        for path in (addr2line, elf):
-            if not path.is_file():
-                _warn_decode_problem(
-                    str(path), "Cannot decode crash addresses: %s missing", path
-                )
-                # The detailed warning names no address; mark named
-                # registers, but bulk stack words at debug (~150 per dump)
-                log = _LOGGER.debug if bulk else _LOGGER.warning
-                log("Not decoded %s (toolchain file missing)", addr)
-                return
-        addr2line, elf = str(addr2line), str(elf)
-    else:
-        from esphome.platformio import toolchain
-
-        idedata = toolchain.get_idedata(config)
-        if not idedata.addr2line_path or not idedata.firmware_elf_path:
-            _warn_decode_problem(
-                "no-addr2line",
-                "Cannot decode crash addresses: no addr2line or ELF in idedata",
-            )
-            log = _LOGGER.debug if bulk else _LOGGER.warning
-            log("Not decoded %s (no addr2line or ELF)", addr)
-            return
-        addr2line, elf = idedata.addr2line_path, idedata.firmware_elf_path
-    command = [addr2line, "-pfiaC", "-e", elf, addr]
+    idedata = toolchain.get_idedata(config)
+    if not idedata.addr2line_path or not idedata.firmware_elf_path:
+        _LOGGER.debug("decode_pc no addr2line")
+        return
+    command = [idedata.addr2line_path, "-pfiaC", "-e", idedata.firmware_elf_path, addr]
    try:
        translation = subprocess.check_output(command, close_fds=False).decode().strip()
-    except Exception as err:  # noqa: BLE001  # pylint: disable=broad-except
-        # Warn, not debug: a failing addr2line must be visible. The warning
-        # is rate-limited across a dump, so mark every undecoded address
-        # inline or the rest read as merely unmappable
-        if not _warn_decode_problem(
-            "addr2line-failed", "Could not decode crash address %s (%s)", addr, err
-        ):
-            # The detailed warning already named this address; mark only
-            # the rate-limited ones, and bulk stack words at debug
-            log = _LOGGER.debug if bulk else _LOGGER.warning
-            log("Not decoded %s (addr2line failed)", addr)
+    except Exception:  # noqa: BLE001  # pylint: disable=broad-except
        _LOGGER.debug("Caught exception for command %s", command, exc_info=1)
        return

    if "?? ??:0" in translation:
-        # A named register that fails to decode is confusing silence; a
-        # bulk stack word failing is the expected common case
-        log = _LOGGER.debug if bulk else _LOGGER.warning
-        log("Not decoded %s (address not in %s)", addr, elf)
+        # Nothing useful
        return
    translation = translation.replace(" at ??:?", "").replace(":?", "")
    _LOGGER.warning("Decoded %s", translation)
@@ -746,6 +596,6 @@ def process_stacktrace(config: ConfigType, line: str, backtrace_state: bool) ->

    if backtrace_state:
        for addr in re.finditer(STACKTRACE_ESP8266_BACKTRACE_PC_RE, line):
-            _decode_pc(config, addr.group(), bulk=True)
+            _decode_pc(config, addr.group())

    return backtrace_state
@@ -16,6 +16,7 @@ KEY_WAVEFORM_REQUIRED = "waveform_required"
 KEY_SERIAL_REQUIRED = "serial_required"
 KEY_SERIAL1_REQUIRED = "serial1_required"
 # Set for the native (non-PlatformIO) toolchain's build generator
+KEY_FLASH_MODE = "flash_mode"
 KEY_SCANF_FLOAT = "scanf_float"
 # Per-board flash-layout override consumed by board_ld_script()
 KEY_LDSCRIPT = "ldscript"
@@ -72,6 +73,3 @@ def enable_serial1() -> None:
            enable_serial1()
    """
    CORE.data.setdefault(KEY_ESP8266, {})[KEY_SERIAL1_REQUIRED] = True
-
-
-BUILD_FLASH_MODES = ("qio", "qout", "dio", "dout")
@@ -41,7 +41,10 @@ const noise::NoiseContext &ESPHomeOTAComponent::noise_context_() const {
 #endif
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer
+// Milliseconds for data transfer. Covers the lwIP retransmit run seen in
+// practice for a lost chunk ack (1.5 + 3 + 6 + 12 + 24 + 48 s); the CLI waits
+// longer (espota2.DATA_PHASE_TIMEOUT) so the device is free before it retries
+static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 105000;

 // Single-instance pointer — multi-port configs are rejected in final_validate.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -118,21 +118,24 @@ void I2SAudioSpeakerBase::loop() {
        break;
      }

+      // Still starting up or winding down from a previous run
+      if ((this->tx_handle_ != nullptr) || (this->speaker_task_handle_ != nullptr)) {
+        break;
+      }
+
      if (this->start_i2s_driver(this->audio_stream_info_) != ESP_OK) {
        ESP_LOGE(TAG, "Driver failed to start; retrying in 1 second");
        this->status_momentary_error("driver-failure", 1000);
        break;
      }

-      if (this->speaker_task_handle_ == nullptr) {
-        xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
-                    &this->speaker_task_handle_);
+      xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+                  &this->speaker_task_handle_);

-        if (this->speaker_task_handle_ == nullptr) {
-          ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
-          this->status_momentary_error("task-failure", 1000);
-          this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
-        }
+      if (this->speaker_task_handle_ == nullptr) {
+        ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
+        this->status_momentary_error("task-failure", 1000);
+        this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
      }
      break;
    case speaker::STATE_RUNNING:   // Intentional fallthrough
@@ -218,8 +221,8 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
 }

 bool I2SAudioSpeakerBase::has_buffered_data() const {
-  if (this->audio_ring_buffer_.use_count() > 0) {
-    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
+  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
+  if (temp_ring_buffer != nullptr) {
    return temp_ring_buffer->available() > 0;
  }
  return false;
@@ -2,7 +2,6 @@ import json
 import logging
 from pathlib import Path

-from esphome.build_helpers.pch import pch_extra_scripts
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -27,7 +26,7 @@ from esphome.const import (
 from esphome.core import CORE
 from esphome.core.config import BOARD_MAX_LENGTH
 from esphome.helpers import copy_file_if_changed
-from esphome.platformio.toolchain import copy_ccache_script, copy_pch_script
+from esphome.platformio.toolchain import copy_ccache_script
 from esphome.storage_json import StorageJSON

 from . import gpio  # noqa: F401
@@ -514,7 +513,7 @@ async def component_to_code(config):
        # it for project source files only. GCC uses the last -O flag.
        build_src_flags += " -Os"
    cg.add_platformio_option("build_src_flags", build_src_flags)
-    cg.add_platformio_option("extra_scripts", ["pre:ccache.py", *pch_extra_scripts()])
+    cg.add_platformio_option("extra_scripts", ["pre:ccache.py"])
    # IRAM_ATTR is a no-op on BK72xx (SDK masks FIQ+IRQ around flash ops).
    # On other families, patch_linker.py routes .sram.text into the right
    # RAM-executable output section and prints a post-link placement summary.
@@ -620,4 +619,3 @@ def copy_files() -> None:
        CORE.relative_build_path("patch_linker.py"),
    )
    copy_ccache_script()
-    copy_pch_script()
@@ -3,6 +3,7 @@

 #include "esphome/components/esp32/crash_handler.h"
 #include <esp_log.h>
+#include <esp_idf_version.h>

 #include <driver/uart.h>
 #include <soc/soc_caps.h>
@@ -16,8 +17,10 @@
 #include <driver/usb_serial_jtag_vfs.h>
 #endif
 #endif
-
-#include "esp_idf_version.h"
+#if defined(CONFIG_PM_ENABLE) && defined(CONFIG_FREERTOS_USE_TICKLESS_IDLE) && \
+    (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0))
+#include "esp_sleep.h"
+#endif
 #include "freertos/FreeRTOS.h"

 #include <fcntl.h>
@@ -87,6 +90,12 @@ void init_uart(uart_port_t uart_num, uint32_t baud_rate, int tx_buffer_size) {
  // ESP-IDF requires rx_buffer_size > UART_HW_FIFO_LEN (128 bytes).
  const int min_rx_buffer_size = UART_HW_FIFO_LEN(uart_num) + 1;
  uart_driver_install(uart_num, min_rx_buffer_size, tx_buffer_size, 0, nullptr, 0);
+#if defined(CONFIG_PM_ENABLE) && defined(CONFIG_FREERTOS_USE_TICKLESS_IDLE) && \
+    (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0))
+  // Always flush before going to light sleep. Could be disabled for devices
+  // without TOP_PD or if source_clk = UART_SCLK_RTC
+  esp_sleep_set_console_uart_handling_mode(ESP_SLEEP_ALWAYS_FLUSH_UART);
+#endif
 }

 void Logger::pre_setup() {
@@ -129,7 +129,7 @@ void MicroWakeWord::setup() {
      return;
    }
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (this->ring_buffer_.use_count() > 1) {
+    if (temp_ring_buffer != nullptr) {
      // Producer-only write: never touches consumer state. If the buffer is full, ask the inference task
      // to drain it - reset() is a consumer operation and must run on the inference task's thread.
      // Disable partial writes so audio chunks are either fully accepted or rejected and handled below.
@@ -446,9 +446,9 @@ void MicroWakeWord::loop() {
    xEventGroupClearBits(this->event_group_, EventGroupBits::TASK_STOPPING);
  }

-  if ((event_group_bits & EventGroupBits::TASK_STOPPED)) {
+  // Retries on a subsequent loop if the task is still running on the other core
+  if ((event_group_bits & EventGroupBits::TASK_STOPPED) && this->inference_task_.deallocate()) {
    ESP_LOGD(TAG, "Inference task is finished, freeing task resources");
-    this->inference_task_.deallocate();
    xEventGroupClearBits(this->event_group_, ALL_BITS);
    xQueueReset(this->detection_queue_);
    this->set_state_(State::STOPPED);
@@ -48,7 +48,7 @@ class MicrophoneSource final {
  template<typename F> void add_data_callback(F &&data_callback) {
    this->mic_->add_data_callback([this, data_callback](const std::vector<uint8_t> &data) {
      if (this->enabled_ || this->passive_) {
-        if (this->processed_samples_.use_count() == 0) {
+        if (this->processed_samples_ == nullptr) {
          // Create vector if its unused
          this->processed_samples_ = std::make_shared<std::vector<uint8_t>>();
        }
@@ -218,7 +218,7 @@ size_t SourceSpeaker::play(const uint8_t *data, size_t length, TickType_t ticks_
  }
  size_t bytes_written = 0;
  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-  if (temp_ring_buffer.use_count() > 0) {
+  if (temp_ring_buffer != nullptr) {
    // Only write to the ring buffer if the reference is valid
    bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
    if (bytes_written > 0) {
@@ -250,14 +250,14 @@ esp_err_t SourceSpeaker::start_() {
  // avoids unnecessary single-frame splices.
  const size_t ring_buffer_size =
      (this->audio_stream_info_.ms_to_bytes(this->buffer_duration_ms_) / bytes_per_frame) * bytes_per_frame;
-  if (this->audio_source_.use_count() == 0) {
+  if (this->audio_source_ == nullptr) {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (!temp_ring_buffer) {
+    if (temp_ring_buffer == nullptr) {
      temp_ring_buffer = ring_buffer::RingBuffer::create(ring_buffer_size);
      this->ring_buffer_ = temp_ring_buffer;
    }

-    if (!temp_ring_buffer) {
+    if (temp_ring_buffer == nullptr) {
      return ESP_ERR_NO_MEM;
    }

@@ -278,7 +278,7 @@ void SourceSpeaker::stop() { this->send_command_(SOURCE_SPEAKER_COMMAND_STOP); }
 void SourceSpeaker::finish() { this->send_command_(SOURCE_SPEAKER_COMMAND_FINISH); }

 bool SourceSpeaker::has_buffered_data() const {
-  return ((this->audio_source_.use_count() > 0) && this->audio_source_->has_buffered_data());
+  return ((this->audio_source_ != nullptr) && this->audio_source_->has_buffered_data());
 }

 void SourceSpeaker::set_mute_state(bool mute_state) {
@@ -382,8 +382,8 @@ void MixerSpeaker::loop() {
    ESP_LOGV(TAG, "Stopping");
    xEventGroupClearBits(this->event_group_, MIXER_TASK_STATE_STOPPING);
  }
-  if (event_group_bits & MIXER_TASK_STATE_STOPPED) {
-    this->task_.deallocate();
+  // Retries on a subsequent loop if the task is still running on the other core
+  if ((event_group_bits & MIXER_TASK_STATE_STOPPED) && this->task_.deallocate()) {
    ESP_LOGD(TAG, "Stopped");
    xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS);
    this->all_stopped_since_ms_ = 0;
@@ -496,7 +496,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
        if (speaker->is_running() && !speaker->get_pause_state()) {
          // Speaker is running and not paused, so it possibly can provide audio data
          std::shared_ptr<audio::RingBufferAudioSource> audio_source = speaker->get_audio_source().lock();
-          if (audio_source.use_count() == 0) {
+          if (audio_source == nullptr) {
            // No audio source allocated, so skip processing this speaker
            continue;
          }
@@ -26,44 +26,129 @@ static const uint8_t MLX90614_ID4 = 0x3F;

 static const char *const TAG = "mlx90614";

+// The EEPROM cell has a limited number of write cycles, so stop retrying after a few failures
+static constexpr uint8_t EMISSIVITY_WRITE_ATTEMPTS = 3;
+
+// SMBus packet error code: CRC-8 with polynomial 0x07, MSB first
+static uint8_t crc8_pec(const uint8_t *data, uint8_t len) { return crc8(data, len, 0x00, 0x07, true); }
+
 void MLX90614Component::setup() {
-  if (!this->write_emissivity_()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-    this->mark_failed();
+  if (std::isnan(this->emissivity_)) {
    return;
  }
+  this->emissivity_write_attempts_ = EMISSIVITY_WRITE_ATTEMPTS;
+  this->try_write_emissivity_();
+  if (this->emissivity_write_attempts_ != 0) {
+    this->status_set_warning(LOG_STR("Failed to write emissivity, will retry"));
+  }
+}
+
+void MLX90614Component::try_write_emissivity_() {
+  if (this->emissivity_write_attempts_ == 0) {
+    return;
+  }
+  if (this->write_emissivity_()) {
+    this->emissivity_write_attempts_ = 0;
+    return;
+  }
+  if (--this->emissivity_write_attempts_ == 0) {
+    ESP_LOGE(TAG, "Giving up on writing emissivity after %u attempts", EMISSIVITY_WRITE_ATTEMPTS);
+    this->emissivity_write_failed_ = true;
+  }
 }

 bool MLX90614Component::write_emissivity_() {
-  if (std::isnan(this->emissivity_))
+  // Skip the write when the EEPROM already holds the desired value to save write cycles
+  uint16_t current_emissivity;
+  if (this->read_register_(MLX90614_EMISSIVITY, current_emissivity) != i2c::ERROR_OK) {
+    return false;
+  }
+
+  const auto desired_emissivity = static_cast<uint16_t>(this->emissivity_ * 0xFFFF);
+  if (current_emissivity == desired_emissivity) {
    return true;
-  uint16_t value = (uint16_t) (this->emissivity_ * 65535);
-  if (!this->write_bytes_(MLX90614_EMISSIVITY, 0)) {
-    return false;
  }
-  delay(10);
-  if (!this->write_bytes_(MLX90614_EMISSIVITY, value)) {
-    return false;
-  }
-  delay(10);
-  return true;
+
+  return this->write_register_(MLX90614_EMISSIVITY, desired_emissivity);
 }

-bool MLX90614Component::write_bytes_(uint8_t reg, uint16_t data) {
+bool MLX90614Component::write_register_(uint8_t reg, uint16_t data) {
+  // The PEC covers the whole write transaction: SLA+W, command, data low, data high
  uint8_t buf[5];
  buf[0] = this->address_ << 1;
  buf[1] = reg;
-  buf[2] = data & 0xFF;
-  buf[3] = data >> 8;
-  buf[4] = crc8(buf, 4, 0x00, 0x07, true);
-  return this->write_bytes(reg, buf + 2, 3);
+
+  // See datasheet 8.3.3.1 EEPROM write sequence
+  // 1. Write 0x0000 into the cell of interest (erases the cell)
+  buf[2] = buf[3] = 0;
+  buf[4] = crc8_pec(buf, 4);
+  auto ec = this->write_register(reg, buf + 2, 3);
+  if (ec != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Can't erase register 0x%02X, error %d", reg, ec);
+    return false;
+  }
+
+  // 2. Wait at least 5ms
+  delay(10);
+
+  // 3. Write the new value
+  if (data != 0) {
+    buf[2] = data & 0xFF;
+    buf[3] = data >> 8;
+    buf[4] = crc8_pec(buf, 4);
+    ec = this->write_register(reg, buf + 2, 3);
+    if (ec != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Can't write register 0x%02X, error %d", reg, ec);
+      return false;
+    }
+    // 4. Wait at least 5ms
+    delay(10);
+  }
+
+  // 5. Read back to confirm the value was stored
+  uint16_t read_back;
+  ec = this->read_register_(reg, read_back);
+  if (ec != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Can't check register 0x%02X value, error %d", reg, ec);
+    return false;
+  }
+
+  if (read_back != data) {
+    ESP_LOGW(TAG, "Read back mismatch on register 0x%02X. Expected 0x%04X, got 0x%04X", reg, data, read_back);
+    return false;
+  }
+
+  return true;
+}
+
+i2c::ErrorCode MLX90614Component::read_register_(uint8_t reg, uint16_t &data) {
+  // The PEC covers the whole read transaction: SLA+W, command, SLA+R, data low, data high
+  uint8_t buf[6];
+  buf[0] = this->address_ << 1;
+  buf[1] = reg;
+  buf[2] = (this->address_ << 1) | 0x01;
+
+  const auto ec = this->read_register(reg, buf + 3, 3);
+  if (ec != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "i2c read error %d", ec);
+    return ec;
+  }
+
+  const auto expected_pec = crc8_pec(buf, 5);
+  if (buf[5] != expected_pec) {
+    ESP_LOGW(TAG, "i2c CRC error. Expected 0x%02X, got 0x%02X", expected_pec, buf[5]);
+    return i2c::ERROR_CRC;
+  }
+
+  data = encode_uint16(buf[4], buf[3]);
+  return i2c::ERROR_OK;
 }

 void MLX90614Component::dump_config() {
  ESP_LOGCONFIG(TAG, "MLX90614:");
  LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  if (this->emissivity_write_attempts_ != 0) {
+    ESP_LOGW(TAG, "  Emissivity not written yet, will retry");
  }
  LOG_UPDATE_INTERVAL(this);
  LOG_SENSOR("  ", "Ambient", this->ambient_sensor_);
@@ -71,33 +156,41 @@ void MLX90614Component::dump_config() {
 }

 void MLX90614Component::update() {
-  uint8_t emissivity[3];
-  if (this->read_register(MLX90614_EMISSIVITY, emissivity, 3) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
+  // Temperature reads run regardless of the emissivity state so a failure still shows up as NAN
+  this->try_write_emissivity_();
+
+  // Publishes NAN on a bus or CRC failure so a stuck reading is visible instead of silently stale
+  auto publish_sensor = [this](sensor::Sensor *sensor, uint8_t reg) {
+    if (sensor == nullptr) {
+      return i2c::ERROR_OK;
+    }
+
+    uint16_t raw;
+    const auto ec = this->read_register_(reg, raw);
+    if (ec != i2c::ERROR_OK) {
+      sensor->publish_state(NAN);
+      return ec;
+    }
+
+    // Bit 15 set means the device flagged the reading as invalid
+    const float temperature = (raw & 0x8000) ? NAN : raw * 0.02f - 273.15f;
+    ESP_LOGD(TAG, "'%s': Got temperature=%.1f°C", sensor->get_name().c_str(), temperature);
+    sensor->publish_state(temperature);
+    return ec;
+  };
+
+  const auto object_ec = publish_sensor(this->object_sensor_, MLX90614_TEMPERATURE_OBJECT_1);
+  const auto ambient_ec = publish_sensor(this->ambient_sensor_, MLX90614_TEMPERATURE_AMBIENT);
+
+  if (object_ec != i2c::ERROR_OK || ambient_ec != i2c::ERROR_OK) {
+    this->status_set_warning(LOG_STR("Failed to read some sensors"));
+  } else if (this->emissivity_write_failed_) {
+    this->status_set_warning(LOG_STR("Failed to write emissivity"));
+  } else if (this->emissivity_write_attempts_ != 0) {
+    this->status_set_warning(LOG_STR("Failed to write emissivity, will retry"));
+  } else {
+    this->status_clear_warning();
  }
-  uint8_t raw_object[3];
-  if (this->read_register(MLX90614_TEMPERATURE_OBJECT_1, raw_object, 3) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
-  }
-
-  uint8_t raw_ambient[3];
-  if (this->read_register(MLX90614_TEMPERATURE_AMBIENT, raw_ambient, 3) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
-  }
-
-  float ambient = raw_ambient[1] & 0x80 ? NAN : encode_uint16(raw_ambient[1], raw_ambient[0]) * 0.02f - 273.15f;
-  float object = raw_object[1] & 0x80 ? NAN : encode_uint16(raw_object[1], raw_object[0]) * 0.02f - 273.15f;
-
-  ESP_LOGD(TAG, "Got Temperature=%.1f°C Ambient=%.1f°C", object, ambient);
-
-  if (this->ambient_sensor_ != nullptr && !std::isnan(ambient))
-    this->ambient_sensor_->publish_state(ambient);
-  if (this->object_sensor_ != nullptr && !std::isnan(object))
-    this->object_sensor_->publish_state(object);
-  this->status_clear_warning();
 }

 }  // namespace esphome::mlx90614
@@ -18,13 +18,18 @@ class MLX90614Component final : public PollingComponent, public i2c::I2CDevice {
  void set_emissivity(float emissivity) { emissivity_ = emissivity; }

 protected:
+  void try_write_emissivity_();
  bool write_emissivity_();

-  bool write_bytes_(uint8_t reg, uint16_t data);
+  bool write_register_(uint8_t reg, uint16_t data);
+  i2c::ErrorCode read_register_(uint8_t reg, uint16_t &data);

  sensor::Sensor *ambient_sensor_{nullptr};
  sensor::Sensor *object_sensor_{nullptr};

  float emissivity_{NAN};
+  // Remaining attempts to program the emissivity EEPROM cell, bounded to limit cell wear
+  uint8_t emissivity_write_attempts_{0};
+  bool emissivity_write_failed_{false};
 };
 }  // namespace esphome::mlx90614
@@ -26,30 +26,34 @@ namespace esphome::network {

 /// Return whether the node is connected to the network (through wifi, eth, ...)
 ESPHOME_ALWAYS_INLINE inline bool is_connected() {
+  // With a single interface enabled the checks below collapse to `if (x) return true; return false;`, which
+  // clang-tidy wants folded into one return. Keep the per-interface form so every enabled interface is checked.
+  // NOLINTBEGIN(readability-simplify-boolean-expr)
 #ifdef USE_ETHERNET
  if (ethernet::global_eth_component != nullptr && ethernet::global_eth_component->is_connected())
    return true;
 #endif

 #ifdef USE_MODEM
-  if (modem::global_modem_component != nullptr)
-    return modem::global_modem_component->is_connected();
+  if (modem::global_modem_component != nullptr && modem::global_modem_component->is_connected())
+    return true;
 #endif

 #ifdef USE_WIFI
-  if (wifi::global_wifi_component != nullptr)
-    return wifi::global_wifi_component->is_connected();
+  if (wifi::global_wifi_component != nullptr && wifi::global_wifi_component->is_connected())
+    return true;
 #endif

 #ifdef USE_OPENTHREAD
-  if (openthread::global_openthread_component != nullptr)
-    return openthread::global_openthread_component->is_connected();
+  if (openthread::global_openthread_component != nullptr && openthread::global_openthread_component->is_connected())
+    return true;
 #endif

 #ifdef USE_HOST
  return true;  // Assume it's connected
 #endif
  return false;
+  // NOLINTEND(readability-simplify-boolean-expr)
 }

 /// Return whether the network is disabled: every configured interface with a
@@ -88,12 +88,12 @@ def encryption_schema(config: ConfigType | None) -> ConfigType:

 async def to_code(config: ConfigType) -> None:
    cg.add_define("USE_NOISE")
-    cg.add_library("esphome/noise-c", "0.1.24")
+    cg.add_library("esphome/noise-c", "0.1.26")
    # noise-c depends on libsodium, but declaring it here too lets the
    # library manager see the full set up front instead of discovering
    # libsodium only after noise-c has downloaded, so the two can download
    # in parallel. The version must match noise-c's library.json.
-    cg.add_library("esphome/libsodium", "1.10021.6")
+    cg.add_library("esphome/libsodium", "1.10021.8")
    # Enable optimized memzero/memcmp in libsodium instead of volatile byte loops
    cg.add_build_flag("-DHAVE_WEAK_SYMBOLS=1")
    cg.add_build_flag("-DHAVE_INLINE_ASM=1")
@@ -153,8 +153,8 @@ void ResamplerSpeaker::loop() {
    ESP_LOGV(TAG, "Stopping");
    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
  }
-  if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
-    this->task_.deallocate();
+  // Retries on a subsequent loop if the task is still running on the other core
+  if ((event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) && this->task_.deallocate()) {
    ESP_LOGD(TAG, "Stopped");
    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
  }
@@ -235,7 +235,7 @@ size_t ResamplerSpeaker::play(const uint8_t *data, size_t length, TickType_t tic
    bytes_written = this->output_speaker_->play(data, length, ticks_to_wait);
  } else {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer) {
+    if (temp_ring_buffer != nullptr) {
      // Only write to the ring buffer if the reference is valid
      bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
    } else {
@@ -299,7 +299,7 @@ bool ResamplerSpeaker::has_buffered_data() const {
  bool has_ring_buffer_data = false;
  if (this->requires_resampling_()) {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer) {
+    if (temp_ring_buffer != nullptr) {
      has_ring_buffer_data = (temp_ring_buffer->available() > 0);
    }
  }
@@ -342,7 +342,7 @@ void ResamplerSpeaker::resample_task(void *params) {
      std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = ring_buffer::RingBuffer::create(
          this_resampler->audio_stream_info_.ms_to_bytes(this_resampler->buffer_duration_ms_));

-      if (!temp_ring_buffer) {
+      if (temp_ring_buffer == nullptr) {
        err = ESP_ERR_NO_MEM;
      } else {
        this_resampler->ring_buffer_ = temp_ring_buffer;
@@ -6,7 +6,6 @@ from string import ascii_letters, digits
 import subprocess
 from typing import Any

-from esphome.build_helpers.pch import pch_extra_scripts
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -34,7 +33,7 @@ from esphome.core import (
 )
 from esphome.core.config import BOARD_MAX_LENGTH
 from esphome.helpers import copy_file_if_changed, read_file, write_file_if_changed
-from esphome.platformio.toolchain import copy_ccache_script, copy_pch_script
+from esphome.platformio.toolchain import copy_ccache_script
 from esphome.storage_json import StorageJSON
 from esphome.types import ConfigType

@@ -341,10 +340,7 @@ async def to_code(config: ConfigType) -> None:
    cg.add_define("ESPHOME_VARIANT", VARIANT_FRIENDLY[variant])
    cg.add_define(ThreadModel.SINGLE)

-    cg.add_platformio_option(
-        "extra_scripts",
-        ["pre:ccache.py", *pch_extra_scripts(), "post:post_build.py"],
-    )
+    cg.add_platformio_option("extra_scripts", ["pre:ccache.py", "post:post_build.py"])

    conf = config[CONF_FRAMEWORK]
    cg.add_platformio_option("framework", "arduino")
@@ -648,7 +644,6 @@ def copy_files() -> None:
        CORE.relative_build_path("inject_lwip_include.py"),
    )
    copy_ccache_script()
-    copy_pch_script()
    _generate_lwipopts_h()
    if generate_pio_files():
        path = CORE.relative_src_path("esphome.h")
@@ -30,6 +30,7 @@ CONF_SENDSPIN_ID = "sendspin_id"
 CONF_INITIAL_STATIC_DELAY = "initial_static_delay"
 CONF_FIXED_DELAY = "fixed_delay"
 CONF_DECODE_MEMORY = "decode_memory"
+CONF_CODECS = "codecs"

 # Matches ARTWORK_MAX_SLOTS in sendspin-cpp.
 MAX_ARTWORK_SLOTS = 4
@@ -44,6 +45,20 @@ CODEC_FORMAT_OPUS = SendspinCodecFormat.enum("OPUS")
 CODEC_FORMAT_PCM = SendspinCodecFormat.enum("PCM")
 CODEC_FORMAT_UNSUPPORTED = SendspinCodecFormat.enum("UNSUPPORTED")

+CODEC_FLAC = "flac"
+CODEC_OPUS = "opus"
+CODEC_PCM = "pcm"
+
+CODECS = {
+    CODEC_FLAC: CODEC_FORMAT_FLAC,
+    CODEC_OPUS: CODEC_FORMAT_OPUS,
+    CODEC_PCM: CODEC_FORMAT_PCM,
+}
+
+# Opus only supports 48 kHz audio, so it is left out of the default list at other rates.
+DEFAULT_CODECS = [CODEC_FLAC, CODEC_OPUS, CODEC_PCM]
+OPUS_SAMPLE_RATE = 48000
+
 SendspinImageFormat = sendspin_library_ns.enum("SendspinImageFormat", is_class=True)
 IMAGE_FORMAT_JPEG = SendspinImageFormat.enum("JPEG")
 IMAGE_FORMAT_PNG = SendspinImageFormat.enum("PNG")
@@ -286,16 +301,13 @@ async def to_code(config: ConfigType) -> None:
    if data.player_support:
        cg.add_define("USE_SENDSPIN_PLAYER", True)

-        # Configures the player role. We always assume support for 16 bits per sample mono and stereo FLAC, Opus, and PCM at the configured sample rate
-        # (with Opus only supported at 48 kHz since that's the only sample rate it supports). Users can configure the specific formats via the Sendspin server
+        # Configures the player role. Each configured codec is advertised for 16 bits per sample
+        # mono and stereo at the configured sample rate. The order is a preference order, both for
+        # the codecs themselves and for stereo over mono.
        player_cfg = data.player_config
        sample_rate = player_cfg[CONF_SAMPLE_RATE]

-        # OPUS only supports 48 kHz audio
-        codecs = [CODEC_FORMAT_FLAC]
-        if sample_rate == 48000:
-            codecs.append(CODEC_FORMAT_OPUS)
-        codecs.append(CODEC_FORMAT_PCM)
+        codecs = [CODECS[codec] for codec in player_cfg[CONF_CODECS]]

        def _audio_format(codec: MockObj, channels: int) -> cg.StructInitializer:
            return cg.StructInitializer(
@@ -13,11 +13,16 @@ from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 from .. import (
+    CODEC_OPUS,
+    CODECS,
+    CONF_CODECS,
    CONF_DECODE_MEMORY,
    CONF_FIXED_DELAY,
    CONF_INITIAL_STATIC_DELAY,
    CONF_SENDSPIN_ID,
+    DEFAULT_CODECS,
    MEMORY_LOCATIONS,
+    OPUS_SAMPLE_RATE,
    SendspinHub,
    register_player_config,
    request_controller_support,
@@ -49,10 +54,32 @@ DisableStaticDelayAdjustmentAction = sendspin_ns.class_(
 )


+def _resolve_codecs(config: ConfigType) -> ConfigType:
+    """Validate the codec preference list, filling in the default when it is not set."""
+    sample_rate = config[CONF_SAMPLE_RATE]
+    if (codecs := config.get(CONF_CODECS)) is None:
+        config[CONF_CODECS] = [
+            codec
+            for codec in DEFAULT_CODECS
+            if codec != CODEC_OPUS or sample_rate == OPUS_SAMPLE_RATE
+        ]
+        return config
+
+    if len(set(codecs)) != len(codecs):
+        raise cv.Invalid("Each codec may only be listed once", path=[CONF_CODECS])
+    if CODEC_OPUS in codecs and sample_rate != OPUS_SAMPLE_RATE:
+        raise cv.Invalid(
+            f"Codec '{CODEC_OPUS}' requires a {CONF_SAMPLE_RATE} of {OPUS_SAMPLE_RATE}",
+            path=[CONF_CODECS],
+        )
+    return config
+
+
 def _register(config: ConfigType) -> ConfigType:
    request_controller_support()
    register_player_config(
        {
+            CONF_CODECS: config[CONF_CODECS],
            CONF_SAMPLE_RATE: config[CONF_SAMPLE_RATE],
            CONF_BUFFER_SIZE: config[CONF_BUFFER_SIZE],
            CONF_INITIAL_STATIC_DELAY: config[CONF_INITIAL_STATIC_DELAY],
@@ -85,9 +112,13 @@ CONFIG_SCHEMA = cv.All(
                min=16000, max=96000
            ),
            cv.Optional(CONF_DECODE_MEMORY): cv.one_of(*MEMORY_LOCATIONS, lower=True),
+            cv.Optional(CONF_CODECS): cv.All(
+                cv.ensure_list(cv.enum(CODECS, lower=True)), cv.Length(min=1)
+            ),
        }
    ),
    cv.only_on_esp32,
+    _resolve_codecs,
    _register,
 )

@@ -202,8 +202,15 @@ AudioPipelineState AudioPipeline::process_state() {
    if (!this->is_playing_) {
      // The tasks have been stopped for two ``process_state`` calls in a row, so delete the tasks
      if (this->read_task_.is_created() || this->decode_task_.is_created()) {
-        this->read_task_.deallocate();
-        this->decode_task_.deallocate();
+        // Both are attempted every time; a task that is still running on the other core is freed by a
+        // subsequent call, and freeing an already freed task succeeds without doing anything
+        bool read_task_freed = this->read_task_.deallocate();
+        bool decode_task_freed = this->decode_task_.deallocate();
+        if (!read_task_freed || !decode_task_freed) {
+          // A task is still running on the other core, so keep the pipeline in its current state and try
+          // again on the next call
+          return AudioPipelineState::PLAYING;
+        }
        if (this->hard_stop_) {
          // Stop command was sent, so immediately end the playback
          this->speaker_->stop();
@@ -315,17 +322,17 @@ void AudioPipeline::read_task(void *params) {
      if (err == ESP_OK) {
        size_t file_ring_buffer_size = this_pipeline->buffer_size_;

-        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer;
+        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this_pipeline->raw_file_ring_buffer_.lock();

-        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
+        if (temp_ring_buffer == nullptr) {
          temp_ring_buffer = ring_buffer::RingBuffer::create(file_ring_buffer_size);
          this_pipeline->raw_file_ring_buffer_ = temp_ring_buffer;
        }

-        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
+        if (temp_ring_buffer == nullptr) {
          err = ESP_ERR_NO_MEM;
        } else {
-          reader->add_sink(this_pipeline->raw_file_ring_buffer_);
+          err = reader->add_sink(temp_ring_buffer);
        }
      }

@@ -396,7 +403,9 @@ void AudioPipeline::decode_task(void *params) {
          make_unique<audio::AudioDecoder>(this_pipeline->transfer_buffer_size_, this_pipeline->transfer_buffer_size_);

      esp_err_t err = decoder->start(this_pipeline->current_audio_file_type_);
-      decoder->add_source(this_pipeline->raw_file_ring_buffer_);
+      if (err == ESP_OK) {
+        err = decoder->add_source(this_pipeline->raw_file_ring_buffer_);
+      }

      if (err != ESP_OK) {
        // Send specific error message
@@ -2,7 +2,13 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_CONDITION, CONF_ID, CONF_LAMBDA, CONF_STATE
+from esphome.const import (
+    CONF_CONDITION,
+    CONF_DEVICE_CLASS,
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_STATE,
+)
 from esphome.cpp_generator import LambdaExpression

 from .. import template_ns
@@ -12,7 +18,11 @@ TemplateBinarySensor = template_ns.class_(
 )

 CONFIG_SCHEMA = (
-    binary_sensor.binary_sensor_schema(TemplateBinarySensor)
+    cv.with_visibility(
+        binary_sensor.binary_sensor_schema(TemplateBinarySensor),
+        cv.Visibility.UI,
+        CONF_DEVICE_CLASS,
+    )
    .extend(
        {
            cv.Exclusive(CONF_LAMBDA, CONF_CONDITION): cv.returning_lambda,
@@ -1,10 +1,14 @@
 from esphome.components import button
+import esphome.config_validation as cv
+from esphome.const import CONF_DEVICE_CLASS

 from .. import template_ns

 TemplateButton = template_ns.class_("TemplateButton", button.Button)

-CONFIG_SCHEMA = button.button_schema(TemplateButton)
+CONFIG_SCHEMA = cv.with_visibility(
+    button.button_schema(TemplateButton), cv.Visibility.UI, CONF_DEVICE_CLASS
+)


 async def to_code(config):
@@ -6,6 +6,7 @@ from esphome.const import (
    CONF_ASSUMED_STATE,
    CONF_CLOSE_ACTION,
    CONF_CURRENT_OPERATION,
+    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_LAMBDA,
    CONF_OPEN_ACTION,
@@ -38,7 +39,11 @@ CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"

 CONFIG_SCHEMA = (
-    cover.cover_schema(TemplateCover)
+    cv.with_visibility(
+        cover.cover_schema(TemplateCover),
+        cv.Visibility.UI,
+        CONF_DEVICE_CLASS,
+    )
    .extend(
        {
            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import event
 import esphome.config_validation as cv
-from esphome.const import CONF_EVENT_TYPES
+from esphome.const import CONF_DEVICE_CLASS, CONF_EVENT_TYPES

 from .. import template_ns

@@ -9,7 +9,9 @@ CODEOWNERS = ["@nohat"]

 TemplateEvent = template_ns.class_("TemplateEvent", event.Event, cg.Component)

-CONFIG_SCHEMA = event.event_schema(TemplateEvent).extend(
+CONFIG_SCHEMA = cv.with_visibility(
+    event.event_schema(TemplateEvent), cv.Visibility.UI, CONF_DEVICE_CLASS
+).extend(
    {
        cv.Required(CONF_EVENT_TYPES): cv.ensure_list(cv.string_strict),
    }
@@ -3,6 +3,7 @@ import esphome.codegen as cg
 from esphome.components import number
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_INITIAL_VALUE,
    CONF_LAMBDA,
@@ -12,6 +13,7 @@ from esphome.const import (
    CONF_RESTORE_VALUE,
    CONF_SET_ACTION,
    CONF_STEP,
+    CONF_UNIT_OF_MEASUREMENT,
 )

 from .. import template_ns
@@ -46,7 +48,12 @@ def validate(config):


 CONFIG_SCHEMA = cv.All(
-    number.number_schema(TemplateNumber)
+    cv.with_visibility(
+        number.number_schema(TemplateNumber),
+        cv.Visibility.UI,
+        CONF_DEVICE_CLASS,
+        CONF_UNIT_OF_MEASUREMENT,
+    )
    .extend(
        {
            cv.Required(CONF_MAX_VALUE): cv.float_,
@@ -2,7 +2,16 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_LAMBDA, CONF_STATE
+from esphome.const import (
+    CONF_ACCURACY_DECIMALS,
+    CONF_DEVICE_CLASS,
+    CONF_FORCE_UPDATE,
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_STATE,
+    CONF_STATE_CLASS,
+    CONF_UNIT_OF_MEASUREMENT,
+)

 from .. import template_ns

@@ -11,9 +20,14 @@ TemplateSensor = template_ns.class_(
 )

 CONFIG_SCHEMA = (
-    sensor.sensor_schema(
-        TemplateSensor,
-        accuracy_decimals=1,
+    cv.with_visibility(
+        sensor.sensor_schema(TemplateSensor, accuracy_decimals=1),
+        cv.Visibility.UI,
+        CONF_UNIT_OF_MEASUREMENT,
+        CONF_ACCURACY_DECIMALS,
+        CONF_DEVICE_CLASS,
+        CONF_STATE_CLASS,
+        CONF_FORCE_UPDATE,
    )
    .extend(
        {
@@ -4,6 +4,7 @@ from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ASSUMED_STATE,
+    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_LAMBDA,
    CONF_OPTIMISTIC,
@@ -31,7 +32,11 @@ def validate(config):


 CONFIG_SCHEMA = cv.All(
-    switch.switch_schema(TemplateSwitch)
+    cv.with_visibility(
+        switch.switch_schema(TemplateSwitch),
+        cv.Visibility.UI,
+        CONF_DEVICE_CLASS,
+    )
    .extend(
        {
            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
@@ -3,7 +3,7 @@ import esphome.codegen as cg
 from esphome.components import text_sensor
 from esphome.components.text_sensor import TextSensorPublishAction
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_LAMBDA, CONF_STATE
+from esphome.const import CONF_DEVICE_CLASS, CONF_ID, CONF_LAMBDA, CONF_STATE

 from .. import template_ns

@@ -12,7 +12,11 @@ TemplateTextSensor = template_ns.class_(
 )

 CONFIG_SCHEMA = (
-    text_sensor.text_sensor_schema()
+    cv.with_visibility(
+        text_sensor.text_sensor_schema(),
+        cv.Visibility.UI,
+        CONF_DEVICE_CLASS,
+    )
    .extend(
        {
            cv.GenerateID(): cv.declare_id(TemplateTextSensor),
@@ -6,6 +6,7 @@ from esphome.const import (
    CONF_ASSUMED_STATE,
    CONF_CLOSE_ACTION,
    CONF_CURRENT_OPERATION,
+    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_LAMBDA,
    CONF_OPEN_ACTION,
@@ -36,7 +37,11 @@ CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"

 CONFIG_SCHEMA = (
-    valve.valve_schema(TemplateValve)
+    cv.with_visibility(
+        valve.valve_schema(TemplateValve),
+        cv.Visibility.UI,
+        CONF_DEVICE_CLASS,
+    )
    .extend(
        {
            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
@@ -1,6 +1,7 @@
 #include "zigbee_time_zephyr.h"
 #if defined(USE_ZIGBEE) && defined(USE_NRF52) && defined(USE_TIME)
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"

 namespace esphome::zigbee {

@@ -47,6 +48,7 @@ void ZigbeeTime::set_epoch_time(uint32_t epoch) {
    this->synchronize_epoch_(epoch);
    this->has_time_ = true;
  });
+  App.wake_loop_threadsafe();
 }

 void ZigbeeTime::zcl_device_cb_(zb_bufid_t bufid) {
@@ -49,7 +49,8 @@ void ZigbeeComponent::factory_reset() {

 void ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(ezb_bdb_comm_mode_mask_t mode) {
  if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
-    global_zigbee->set_timeout("zb_init", 10, [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
+    global_zigbee->set_timeout("zb_init", 100, [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
+    App.wake_loop_threadsafe();
    return;
  }
  if (ezb_bdb_start_top_level_commissioning(mode) != EZB_ERR_NONE) {
@@ -88,6 +89,7 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
        global_zigbee->set_timeout("zb_init", 1000, []() {
          ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_INITIALIZATION);
        });
+        App.wake_loop_threadsafe();
      }
    } break;
    case EZB_BDB_SIGNAL_STEERING: {
@@ -113,6 +115,7 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
            ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
          });
        }
+        App.wake_loop_threadsafe();
      }
    } break;
    case EZB_ZDO_SIGNAL_LEAVE: {
@@ -1,10 +1,10 @@
 #include "zigbee_zephyr.h"
 #if defined(USE_ZIGBEE) && defined(USE_NRF52)
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 #include <zephyr/settings/settings.h>
 #include <zephyr/storage/flash_map.h>
 #include "esphome/core/hal.h"
-#include "esphome/core/wake.h"

 extern "C" {
 #include <zboss_api.h>
@@ -120,7 +120,7 @@ void ZigbeeComponent::zcl_device_cb(zb_bufid_t bufid) {
  /* Set default response value. */
  p_device_cb_param->status = RET_OK;

-  esphome::wake_loop_threadsafe();
+  App.wake_loop_threadsafe();

  // endpoints are enumerated from 1
  if (global_zigbee->callbacks_.size() >= endpoint) {
@@ -138,6 +138,7 @@ void ZigbeeComponent::on_join_(bool factory_new) {
    ESP_LOGD(TAG, "Joined the network");
    this->join_cb_.call(factory_new);
  });
+  App.wake_loop_threadsafe();
 }

 void ZigbeeComponent::on_start_() {
@@ -145,6 +146,7 @@ void ZigbeeComponent::on_start_() {
    ESP_LOGD(TAG, "Started zigbee stack");
    this->start_cb_.call();
  });
+  App.wake_loop_threadsafe();
 }

 #ifdef USE_ZIGBEE_WIPE_ON_BOOT
@@ -4,6 +4,7 @@ from __future__ import annotations

 from collections.abc import Callable
 from contextlib import contextmanager, suppress
+import copy
 from datetime import datetime
 from ipaddress import (
    AddressValueError,
@@ -419,6 +420,37 @@ class Required(vol.Required):
        self.visibility: Visibility | None = visibility


+def with_visibility(schema: Schema, visibility: Visibility, *keys: str) -> Schema:
+    """Return a copy of ``schema`` with the given ``keys`` re-marked at ``visibility``.
+
+    Lets a platform override the editor :class:`Visibility` of fields it
+    inherits from a shared schema builder — without that builder needing a
+    visibility parameter of its own. The canonical use is a ``template``
+    platform promoting the value metadata its user is expected to define
+    (``device_class``, ``unit_of_measurement``, …) onto the main form:
+
+        CONFIG_SCHEMA = cv.with_visibility(
+            sensor.sensor_schema(TemplateSensor),
+            cv.Visibility.UI,
+            CONF_DEVICE_CLASS, CONF_UNIT_OF_MEASUREMENT,
+        )
+
+    The original marker's key, default and validator are preserved; only the
+    visibility changes, and the input ``schema`` is left untouched. Raises if
+    a requested key is not present so typos fail at schema-build time.
+    """
+    wanted = {str(k) for k in keys}
+    overrides = {}
+    for marker, validator in schema.schema.items():
+        if str(marker) in wanted:
+            marker = copy.copy(marker)
+            marker.visibility = visibility
+            overrides[marker] = validator
+    if missing := wanted - {str(m) for m in overrides}:
+        raise ValueError(f"with_visibility: keys not in schema: {sorted(missing)}")
+    return schema.extend(overrides)
+
+
 class FinalExternalInvalid(Invalid):
    """Represents an invalid value in the final validation phase where the path should not be prepended."""

@@ -555,14 +555,7 @@ NATIVE_ARDUINO_PIO_OPTIONS = frozenset({"board_build.f_cpu", "board_build.ldscri
 # that is stored rather than translated away. Consumed by the esp8266 native
 # backend (later in this chain) for its ignored-option warning; defined here
 # so it stays adjacent to the routing.
-# build_src_flags and board_build.flash_mode: set unconditionally by
-# esp8266/__init__ and read by the native generator; not user-routable, so
-# not in the set above
-NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS = NATIVE_ARDUINO_PIO_OPTIONS | {
-    "lib_ignore",
-    "build_src_flags",
-    "board_build.flash_mode",
-}
+NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS = NATIVE_ARDUINO_PIO_OPTIONS | {"lib_ignore"}


@coroutine_with_priority(CoroPriority.FINAL)
@@ -56,6 +56,15 @@ void EntityBase::configure_entity_(const char *name, uint32_t object_id_hash, ui
  this->flags_.entity_category = (entity_fields >> ENTITY_FIELD_ENTITY_CATEGORY_SHIFT) & 0x3;
 }

+void EntityBase::set_internal(bool internal) {
+  // Remove the after-setup path in 2027.3.0 and ignore the call instead.
+  if (App.is_setup_complete()) {
+    ESP_LOGE(TAG, "'%s': set_internal() after setup is undefined behavior, stops working in 2027.3.0",
+             this->get_name().c_str());
+  }
+  this->flags_.internal = internal;
+}
+
 // Weak default lookup functions — overridden by generated code in main.cpp
 __attribute__((weak)) const char *entity_device_class_lookup(uint8_t) { return ""; }
 __attribute__((weak)) const char *entity_uom_lookup(uint8_t) { return ""; }
@@ -88,13 +88,26 @@ class EntityBase {
  // Get whether this Entity should be hidden outside ESPHome
  bool is_internal() const { return this->flags_.internal; }

-  // Deprecated: Calling set_internal() at runtime is undefined behavior. Components and clients
-  // are NOT notified of the change, the flag may have already been read during setup, and there
-  // is NO guarantee any consumer will observe the new value. Use the 'internal:' YAML key instead.
-  ESPDEPRECATED("set_internal() is undefined behavior at runtime — components and Home Assistant are NOT "
-                "notified. Use the 'internal:' YAML key instead. Will be removed in 2027.3.0.",
-                "2026.3.0")
-  void set_internal(bool internal) { this->flags_.internal = internal; }
+  // Set whether this Entity should be hidden outside ESPHome. Prefer the 'internal:' YAML key
+  // whenever possible: it is guaranteed and has none of the limitations below. Use this only when
+  // the decision can only be made at boot. Must be called before MQTT and the API read the flag:
+  // from on_boot at the default priority, or a setup() that runs above setup_priority::AFTER_WIFI.
+  // If the answer comes from a device handshake, hold setup with can_proceed() until it arrives.
+  // Calls after setup finishes are undefined behavior: the flag is still written and an error is
+  // logged, and from 2027.3.0 the call will be ignored.
+  //
+  // Known limitations. Not bugs, so no issue reports please; a PR that removes one with no RAM
+  // or performance cost would be considered.
+  // - No consumer is notified of a change, so the flag can only be decided once per boot.
+  // - The guard is coarse: a call from a priority below AFTER_WIFI (an on_boot with a low priority,
+  //   or a setup() at LATE) still passes, but the API camera listener is already registered, MQTT
+  //   (AFTER_CONNECTION) has cached the flag, and an API client that connected while setup was
+  //   stalled on a slow component has already listed the entities, so they keep the old value.
+  // - Un-hiding an entity declared 'internal: true' in YAML skips the duplicate name check that
+  //   codegen runs for exposed entities, so a name collision can surface at runtime. Entities with
+  //   only an 'id:' are forced internal and use the id as their name.
+  // - Zigbee codegen skips YAML internal entities entirely, so un-hiding cannot add them to Zigbee.
+  void set_internal(bool internal);

  // Check if this object is declared to be disabled by default.
  // That means that when the device gets added to Home Assistant (or other clients) it should
@@ -40,16 +40,31 @@ bool StaticTask::create(TaskFunction_t fn, const char *name, uint32_t stack_size
  return true;
 }

-void StaticTask::destroy() {
-  if (this->handle_ != nullptr) {
-    TaskHandle_t handle = this->handle_;
-    this->handle_ = nullptr;
-    vTaskDelete(handle);
+bool StaticTask::destroy() {
+  if (this->handle_ == nullptr) {
+    return true;
  }
+
+  // Suspending takes the task off the ready and event lists, so nothing can schedule it again. It only asks
+  // the other core to yield though, so the task may still be running on it for a moment.
+  vTaskSuspend(this->handle_);
+  if (eTaskGetState(this->handle_) != eSuspended) {
+    // The task is still running on the other core and using its stack. Deleting it now would only put it on
+    // the termination list and return, so the caller has to try again once it has been swapped out.
+    return false;
+  }
+
+  // The task cannot run again, so the delete completes right away instead of being left to the idle task.
+  TaskHandle_t handle = this->handle_;
+  this->handle_ = nullptr;
+  vTaskDelete(handle);
+  return true;
 }

-void StaticTask::deallocate() {
-  this->destroy();
+bool StaticTask::deallocate() {
+  if (!this->destroy()) {
+    return false;
+  }
  if (this->stack_buffer_ != nullptr) {
    RAMAllocator<StackType_t> allocator(this->use_psram_ ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
                                                         : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
@@ -57,6 +72,7 @@ void StaticTask::deallocate() {
    this->stack_buffer_ = nullptr;
    this->stack_size_ = 0;
  }
+  return true;
 }

 }  // namespace esphome
@@ -11,6 +11,7 @@ namespace esphome {

 /** Helper for FreeRTOS static task management.
 * Bundles TaskHandle_t, StaticTask_t, and the stack buffer into one object with create/destroy methods.
+ * Call destroy() and deallocate() from another task: a task cannot free the stack it is still running on.
 */
 class StaticTask {
 public:
@@ -23,7 +24,7 @@ class StaticTask {
  /// @brief Allocate stack and create task.
  /// @param fn         Task function
  /// @param name       Task name (for debug)
-  /// @param stack_size Stack size in StackType_t words
+  /// @param stack_size Stack size in bytes (StackType_t is a byte on ESP-IDF)
  /// @param param      Parameter passed to task function
  /// @param priority   FreeRTOS task priority
  /// @param use_psram  If true, allocate stack in PSRAM; otherwise internal RAM
@@ -31,11 +32,17 @@ class StaticTask {
  bool create(TaskFunction_t fn, const char *name, uint32_t stack_size, void *param, UBaseType_t priority,
              bool use_psram);

-  /// @brief Delete the task but keep the stack buffer allocated for reuse by a subsequent create() call.
-  void destroy();
+  /// @brief Delete the task, keeping the stack buffer allocated for reuse by a subsequent create() call.
+  /// The task must have finished its work and parked itself, either suspended or blocked indefinitely: it is
+  /// suspended here so that it cannot be scheduled again, and it is given no chance to clean up.
+  /// @return true if the task was deleted; false if it is still running on another core, in which case the
+  /// caller should try again later.
+  bool destroy();

-  /// @brief Delete the task (if running) and free the stack buffer.
-  void deallocate();
+  /// @brief Delete the task (if created) and free the stack buffer.
+  /// @return true if the stack buffer was freed; false if the task is still running on another core, in
+  /// which case the caller should try again later.
+  bool deallocate();

 protected:
  TaskHandle_t handle_{nullptr};
@@ -16,7 +16,6 @@ from esphome.build_helpers.ccache import (
    parse_enable_env,
    resolve_ccache_path,
 )
-from esphome.build_helpers.pch import ccache_pch_env
 from esphome.build_helpers.tools_cache import IDF_TOOLS_CACHE, tools_cache_path
 from esphome.core import Version
 from esphome.framework_helpers import (
@@ -1206,33 +1205,15 @@ def _ccache_env() -> dict[str, str]:

    Only values the user has not already set in the environment are returned, so
    a custom ``CCACHE_DIR`` / ``CCACHE_MAXSIZE`` / etc. is respected.
-    The pch settings add ``time_macros`` sloppiness process-wide; the visible
-    effect is a cached TU can keep an older ``esp_app_desc`` build timestamp.
-    """
-    if not _ccache_enabled():
-        # The raw knob value (e.g. "disable") is still inherited by idf.py
-        # via os.environ, where a non-false-constant string reads as
-        # truthy; export the canonical off spelling instead
-        return {"IDF_CCACHE_ENABLE": "0"}
-
-    env = ccache_defaults_env(get_idf_tools_path() / "ccache")
-    env.update(ccache_pch_env())
-    # Exactly one canonical spelling ever reaches idf.py, whatever the
-    # accepted input spelling was ("enable", "yes", ...)
-    env["IDF_CCACHE_ENABLE"] = "1"
-    return env
-
-
-def _ccache_enabled() -> bool:
-    """Whether ESP-IDF compiles run under ccache.
-
-    IDF_CCACHE_ENABLE (the backend-native knob) wins over the shared
-    ESPHOME_CCACHE_ENABLE; when unset, enabled iff a runnable binary is
-    on PATH.
    """
+    # IDF_CCACHE_ENABLE (the backend-native knob) wins over the shared
+    # ESPHOME_CCACHE_ENABLE.
    idf_knob = parse_enable_env("IDF_CCACHE_ENABLE")
    if idf_knob is False:
-        return False
+        # The raw value (e.g. "disable") is still inherited by idf.py via
+        # os.environ, where a non-false-constant string reads as truthy;
+        # export the canonical off spelling instead
+        return {"IDF_CCACHE_ENABLE": "0"}
    if idf_knob is True:
        # Forced on ignores the runnability verdict, but the outcome is
        # worth saying out loud. Probed directly (not via the resolver,
@@ -1252,8 +1233,17 @@ def _ccache_enabled() -> bool:
                "IDF_CCACHE_ENABLE=1 forces on the ccache at %s even though "
                "it failed to run; idf.py will use it anyway",
            )
-        return True
-    return resolve_ccache_path() is not None
+    elif resolve_ccache_path() is None:
+        # ESP-IDF silently skips ccache without the binary; export the
+        # canonical off spelling so an unparsable inherited value (or a
+        # probe-rejected ccache idf.py would still find) cannot enable it
+        return {"IDF_CCACHE_ENABLE": "0"}
+
+    env = ccache_defaults_env(get_idf_tools_path() / "ccache")
+    # Exactly one canonical spelling ever reaches idf.py, whatever the
+    # accepted input spelling was ("enable", "yes", ...)
+    env["IDF_CCACHE_ENABLE"] = "1"
+    return env


 def get_framework_env(
@@ -1,6 +1,5 @@
 """ESP-IDF direct build API for ESPHome."""

-from contextlib import suppress
 from dataclasses import dataclass, field
 import hashlib
 import json
@@ -529,20 +528,6 @@ def run_compile(config, verbose: bool) -> int:
            return result.returncode
        _patch_memory_segments()

-    # After every reconfigure so compile_commands and sdkconfig are settled.
-    # An optional speedup must never abort the build
-    from esphome.build_gen.espidf import discard_pch, prepare_pch
-
-    try:
-        prepare_pch()
-    except Exception:  # noqa: BLE001  # pylint: disable=broad-exception-caught
-        # Discard so a stale .gch can never be consumed
-        with suppress(OSError):
-            discard_pch()
-        _LOGGER.warning(
-            "Precompiled header setup failed; compiling without it", exc_info=True
-        )
-
    # Build
    args = []

@@ -96,6 +96,10 @@ UPLOAD_BUFFER_SIZE = UPLOAD_BLOCK_SIZE * 8
 # across the addresses on top of that.
 EXTRA_UPLOAD_ATTEMPTS = 2
 UPLOAD_RETRY_DELAY = 5.0
+# Data phase timeout; must stay longer than the device's OTA_SOCKET_TIMEOUT_DATA
+# (105 s) so a stalled session is gone before a retry, and long enough for lwIP
+# to get a lost chunk ack through after the retransmit run seen in practice
+DATA_PHASE_TIMEOUT = 160.0

 _LOGGER = logging.getLogger(__name__)

@@ -694,8 +698,7 @@ def perform_ota(

    _LOGGER.info("Handshake complete")

-    # Timeout must match device-side OTA_SOCKET_TIMEOUT_DATA to prevent premature failures
-    sock.settimeout(90.0)
+    sock.settimeout(DATA_PHASE_TIMEOUT)

    if extended_proto:
        send_check(sock, ota_type, "ota type")
@@ -854,7 +857,7 @@ def run_ota_impl_(
    # clean up a half-open connection (its handshake watchdog runs at 20s);
    # moving on to the next address family stays immediate. Known limitation:
    # a silent mid-transfer drop with no reset can wedge the device until its
-    # 90s data timeout, which outlasts this budget; the retries target the
+    # 105s data timeout, which outlasts this budget; the retries target the
    # common failures where the device resets or closes the link promptly.
    total_attempts = len(res) + EXTRA_UPLOAD_ATTEMPTS
    last_error = ""
@@ -1,364 +0,0 @@
-import hashlib
-import os
-from pathlib import Path
-import posixpath
-import re
-import shlex
-import stat
-import subprocess
-import traceback
-
-# pylint: disable=E0602
-Import("env")  # noqa: F821
-_projenv_error = None
-try:
-    Import("projenv")  # noqa: F821
-except Exception as err:  # noqa: BLE001 -- not exported under -t nobuild
-    projenv = None
-    _projenv_error = err
-
-# Precompile the src force-includes plus defines.h and force-include the
-# result into C++ src compiles only; their preprocessed output is unchanged.
-# Registration is gated host-side (pch_enabled()). Keep the closure, ccache
-# values, and stamp flow in sync with build_helpers/pch.py.
-
-# Compiler failures that clear on their own must not latch the .failed marker
-_TRANSIENT_ERRORS = ("No space left", "Cannot allocate", "Resource temporarily")
-
-_INCLUDE_RE = re.compile(rb'^\s*#\s*include\s+["<]([^">]+)[">]', re.MULTILINE)
-_CORE_HEADER = "esphome/core/defines.h"
-
-
-def _raise_walk_error(err: OSError) -> None:
-    raise err
-
-
-def _resolves_dir(path: Path) -> bool:
-    """False when missing; other stat failures propagate."""
-    try:
-        return stat.S_ISDIR(path.stat().st_mode)
-    except (FileNotFoundError, NotADirectoryError):
-        return False
-
-
-def _resolves(path: Path) -> bool:
-    """False when missing; other stat failures propagate (identity unknown)."""
-    try:
-        return stat.S_ISREG(path.stat().st_mode)
-    except (FileNotFoundError, NotADirectoryError):
-        return False
-
-
-def _include_closure(src_dir: Path, roots: list) -> dict:
-    """Quoted-include closure: src-relative name -> contents (mirror of
-    build_helpers/pch.py)."""
-    seen = {}
-    stack = [(name, "") for name in roots]
-    while stack:
-        name, from_dir = stack.pop()
-        for candidate in (f"{from_dir}/{name}" if from_dir else name, name):
-            rel = posixpath.normpath(candidate)
-            if not rel.startswith("..") and _resolves(src_dir / rel):
-                break
-        else:
-            continue
-        if rel in seen:
-            continue
-        try:
-            data = (src_dir / rel).read_bytes()
-        except OSError as err:
-            # A marker would truncate the transitive walk; fail closed
-            print(f"ESPHome: could not read {rel} for the pch checksum: {err}")
-            raise
-        seen[rel] = data
-        parent = posixpath.dirname(rel)
-        stack.extend(
-            (inc.decode(errors="surrogateescape"), parent)
-            for inc in _INCLUDE_RE.findall(data)
-        )
-    return seen
-
-
-def _shell_arg(element) -> str | None:
-    """One compiler argv from one SCons element, matching the real spawn:
-    spaced elements pass whole, the rest get one shell unquote (skipped on
-    Windows, where shlex would eat path backslashes)."""
-    arg = str(element)
-    if " " in arg or os.name == "nt":
-        return arg.replace('\\"', '"')
-    if not arg.strip():
-        return arg
-    try:
-        tokens = shlex.split(arg)
-    except ValueError as err:
-        print(f"ESPHome: could not lex flag {arg!r} for the pch: {err}")
-        return None
-    if len(tokens) != 1:
-        # A flag the model cannot reproduce would diverge the .gch's flags
-        print(f"ESPHome: cannot model flag {arg!r} for the pch")
-        return None
-    return tokens[0]
-
-
-def _compile_gch(cxx, flags, header: Path, gch: Path, proj_dir: Path):
-    """Compile the .gch, then probe that the toolchain can load it back
-    (GCC 10 on macOS arm64 rejects its own per-process). Returns an error
-    string or None; OSError propagates as transient."""
-    result = subprocess.run(  # noqa: PLW1510
-        [cxx, "-x", "c++-header", *flags, "-c", str(header), "-o", str(gch)],
-        cwd=proj_dir,
-        # C locale keeps diagnostics matchable by _TRANSIENT_ERRORS
-        env={**os.environ, "LC_ALL": "C"},
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode < 0:
-        # Signal-killed (OOM, ^C): route to the transient no-marker path
-        raise OSError(f"compiler killed by signal {-result.returncode}")
-    if result.returncode != 0:
-        return result.stderr
-    # -MF is only legal alongside a dependency flag; pass it solely to
-    # redirect a depfile that -MD/-MMD in the flags would otherwise write
-    dep_redirect = (
-        ["-MF", os.devnull]
-        if any(f in ("-MD", "-MMD", "-M", "-MM") for f in flags)
-        else []
-    )
-    probe = subprocess.run(  # noqa: PLW1510
-        [
-            cxx,
-            *flags,
-            *dep_redirect,
-            "-Winvalid-pch",
-            "-include",
-            str(header),
-            "-fsyntax-only",
-            "-x",
-            "c++",
-            "-",
-        ],
-        cwd=proj_dir,
-        env={**os.environ, "LC_ALL": "C"},
-        input="",
-        capture_output=True,
-        text=True,
-    )
-    if probe.returncode < 0:
-        raise OSError(f"probe killed by signal {-probe.returncode}")
-    if probe.returncode != 0 or ".gch" in probe.stderr:
-        return f"toolchain cannot load the pch: {probe.stderr.strip()}"
-    return None
-
-
-def _read_stamp(path: Path) -> str:
-    """A corrupt sidecar must read as stale, not kill the pch forever."""
-    try:
-        return path.read_text(encoding="utf-8").strip()
-    except (OSError, UnicodeDecodeError):
-        return ""
-
-
-def _setup_pch() -> None:
-    if projenv is None:
-        # Expected under -t nobuild; anything else must leave a trail
-        print(f"ESPHome: projenv unavailable ({_projenv_error}); skipping pch")
-        return
-    # Project root: SCons compiles run here, so the relative -include
-    # resolves; an absolute path would break cross-device ccache sharing.
-    proj_dir = Path(env.subst("$PROJECT_DIR"))  # noqa: F821
-    src_dir = Path(env.subst("$PROJECT_SRC_DIR"))  # noqa: F821
-    header = proj_dir / "esphome_pch.h"
-    gch = Path(f"{header}.gch")
-    sum_path = Path(f"{gch}.sum")
-
-    cxx = projenv.subst("$CXX")  # noqa: F821
-    # The header holds the -include entries itself, so the .gch compile must
-    # not see them; consumers keep theirs, which the .gch then satisfies.
-    flags = []
-    include_headers = []
-    raw_args = [
-        _shell_arg(element)
-        for element in projenv.subst_list("$CXXFLAGS $CCFLAGS $_CCCOMCOM")[0]  # noqa: F821
-    ]
-    if any(arg is None for arg in raw_args):
-        print("ESPHome: skipping precompiled header: unmodelable flag")
-        return
-    flag_it = iter(raw_args)
-    for tok in flag_it:
-        if tok == "-include":
-            include_headers.append(next(flag_it, ""))
-        elif tok.startswith("-include") and not tok.startswith("-include-"):
-            include_headers.append(tok[len("-include") :])
-        else:
-            flags.append(tok)
-    if any(not name for name in include_headers):
-        print("ESPHome: build_src_flags has a trailing -include; skipping pch")
-        return
-    # Fold only relative names resolving under src/: consumers keep their
-    # own -include entries, so folding an unguarded user header would
-    # include it twice; unfolded ones stay consumer-only.
-    try:
-        folded = [
-            name
-            for name in include_headers
-            if not Path(name).is_absolute() and _resolves(src_dir / name)
-        ]
-    except OSError as err:
-        print(f"ESPHome: skipping precompiled header: {err}")
-        return
-    if unfolded := [n for n in include_headers if n not in folded]:
-        print(f"ESPHome: not precompiling non-src force-includes: {unfolded}")
-    content = "".join(f'#include "{name}"\n' for name in (*folded, _CORE_HEADER))
-
-    digest = hashlib.sha256()
-    digest.update(content.encode(errors="surrogateescape"))
-    digest.update(cxx.encode(errors="surrogateescape"))
-    # Mirror CCACHE_BASEDIR: strip the per-device build path so identical
-    # configs produce identical .sum files and share cache entries
-    flags_id = " ".join(flags)
-    if basedir := os.environ.get("CCACHE_BASEDIR"):
-        flags_id = flags_id.replace(basedir, "")
-    digest.update(flags_id.encode(errors="surrogateescape"))
-    # GCC never validates a .gch against its source headers, and PlatformIO
-    # package paths carry no version, so a package bump must invalidate here
-    platform = env.PioPlatform()  # noqa: F821
-    for package in sorted(platform.packages):
-        try:
-            version = platform.get_package_version(package)
-        except KeyError:
-            # An unresolved manifest must not hash as a constant
-            if platform.get_package(package) is not None:
-                print(f"ESPHome: skipping precompiled header: no version for {package}")
-                return
-            version = None  # absent optional package
-        except Exception as err:  # noqa: BLE001
-            # No trustworthy package identity: a stale .gch could survive
-            print(f"ESPHome: skipping precompiled header: {err}")
-            return
-        digest.update(f"{package}={version}".encode())
-        digest.update(b"\0")
-    try:
-        closure = _include_closure(src_dir, [*folded, _CORE_HEADER])
-    except OSError as err:
-        print(f"ESPHome: skipping precompiled header: {err}")
-        return
-    for rel in sorted(closure):
-        digest.update(rel.encode(errors="surrogateescape"))
-        digest.update(closure[rel])
-        digest.update(b"\0")
-    # Project-local -I dirs (e.g. rp2's lwip_override) hold generated
-    # headers the src closure cannot see; hash them too
-    prev = ""
-    try:
-        for tok in flags:
-            inc = tok[2:] if tok.startswith("-I") and len(tok) > 2 else ""
-            if prev == "-I":
-                inc = tok
-            prev = tok
-            if not inc:
-                continue
-            inc_dir = Path(inc)
-            if not (
-                _resolves_dir(inc_dir)
-                and inc_dir.is_relative_to(proj_dir)
-                and not inc_dir.is_relative_to(src_dir)
-                # Library trees never enter the prefix closure; walking them
-                # would read every library file each build
-                and not inc_dir.is_relative_to(proj_dir / ".piolibdeps")
-                and not inc_dir.is_relative_to(proj_dir / ".pioenvs")
-            ):
-                continue
-            local_headers = []
-            # os.walk with onerror: rglob would swallow unlistable subtrees
-            for root, _dirs, files in os.walk(inc_dir, onerror=_raise_walk_error):
-                local_headers.extend(
-                    Path(root) / f
-                    for f in files
-                    if f.endswith((".h", ".hpp", ".hh", ".inc"))
-                )
-            for local in sorted(local_headers):
-                digest.update(str(local.relative_to(proj_dir)).encode())
-                digest.update(local.read_bytes())
-                digest.update(b"\0")
-    except OSError as err:
-        print(f"ESPHome: skipping precompiled header: {err}")
-        return
-    checksum = digest.hexdigest()
-
-    # The ccache .sum sidecar doubles as the freshness stamp
-    if (
-        not header.is_file()
-        or not gch.is_file()
-        or not sum_path.is_file()
-        or (_read_stamp(sum_path) != checksum)
-    ):
-        failed_marker = Path(f"{gch}.failed")
-        if _read_stamp(failed_marker) == checksum:
-            print(
-                "ESPHome: skipping precompiled header (previous attempt "
-                f"failed); delete {failed_marker.name} to retry"
-            )
-            return
-        header.write_text(content, encoding="utf-8")
-        try:
-            error = _compile_gch(cxx, flags, header, gch, proj_dir)
-        except OSError as err:
-            # Transient spawn/IO failure: no marker, retry next build
-            print(f"ESPHome: precompiled header compile did not run: {err}")
-            gch.unlink(missing_ok=True)
-            sum_path.unlink(missing_ok=True)
-            return
-        if error is not None:
-            print("ESPHome: precompiled header failed; compiling without it")
-            print(error)
-            gch.unlink(missing_ok=True)
-            sum_path.unlink(missing_ok=True)
-            if any(m in error for m in _TRANSIENT_ERRORS):
-                # Resource exhaustion clears on its own; retry next build
-                return
-            # Skip retries until a flag/header/platform change alters the checksum
-            failed_marker.write_text(checksum + "\n", encoding="utf-8")
-            return
-        failed_marker.unlink(missing_ok=True)
-        sum_path.write_text(checksum + "\n", encoding="utf-8")
-
-    # Computed first so the flags and env land together: a raise between
-    # them would leave a pch-consuming build without its ccache settings.
-    # projenv["ENV"] aliases os.environ, so these reach all TUs; only
-    # time_macros affects non-pch TUs. User values win.
-    ccache_updates = {
-        key: value
-        for key, value in (
-            ("CCACHE_SLOPPINESS", "pch_defines,time_macros"),
-            ("CCACHE_PCH_EXTSUM", "true"),
-        )
-        if key not in os.environ
-    }
-    sloppiness = os.environ.get("CCACHE_SLOPPINESS")
-    if sloppiness is not None:
-        tokens = {tok.strip() for tok in sloppiness.split(",")}
-        missing = [t for t in ("pch_defines", "time_macros") if t not in tokens]
-        if missing:
-            # Without these ccache declines every pch-consuming compile
-            ccache_updates["CCACHE_SLOPPINESS"] = ",".join((sloppiness, *missing))
-            print(f"ESPHome: adding {','.join(missing)} to CCACHE_SLOPPINESS for the pch")
-    extsum = os.environ.get("CCACHE_PCH_EXTSUM")
-    if extsum is not None and extsum.strip().lower() not in ("1", "true", "yes", "on"):
-        # ccache then hashes the non-reproducible .gch bytes: permanent misses
-        print(f"ESPHome: CCACHE_PCH_EXTSUM={extsum} disables pch caching")
-    # Prepended: GCC only uses a .gch while no other tokens precede it.
-    # The relative name also reaches "pio run -t idedata" output.
-    # -Wno-error: the per-process probe can pass while a later cc1plus
-    # rejects the .gch; that must stay a warning under user -Werror.
-    projenv.Prepend(  # noqa: F821
-        CXXFLAGS=["-Winvalid-pch", "-Wno-error=invalid-pch", "-include", header.name]
-    )
-    projenv["ENV"].update(ccache_updates)  # noqa: F821
-    print("ESPHome: Compiling with precompiled header")
-
-
-try:
-    _setup_pch()
-except Exception:  # noqa: BLE001 -- a speedup must never break the build
-    print("ESPHome: pch internal error; compiling without it")
-    traceback.print_exc()
@@ -289,15 +289,6 @@ def copy_ccache_script() -> None:
    )


-def copy_pch_script() -> None:
-    """Copy the shared precompiled-header SCons post-script into the build
-    dir; platform components pair it with ``post:pch.py`` in extra_scripts."""
-    copy_file_if_changed(
-        Path(__file__).parent / "pch.py.script",
-        CORE.relative_build_path("pch.py"),
-    )
-
-
 def default_libdeps_dir() -> str:
    """The PLATFORMIO_LIBDEPS_DIR value a pio run defaults to; the package
    prefetch must resolve installed libraries against the same dir."""
@@ -7,7 +7,6 @@ import re
 import time

 from esphome import loader
-from esphome.build_helpers.pch import PCH_ARTIFACT_NAMES
 from esphome.compiled_config import save_compiled_config
 from esphome.config import iter_component_configs, iter_components
 from esphome.const import (
@@ -610,20 +609,11 @@ def clean_build(clear_pio_cache: bool = True, *, full: bool = False):
            if idf_path.is_dir():
                _LOGGER.info("Deleting %s", idf_path)
                rmtree(idf_path)
-        # The PlatformIO pch artifacts live at the project root so the
-        # relative -include resolves; a partial clean must drop them too
-        for name in PCH_ARTIFACT_NAMES:
-            CORE.relative_build_path(name).unlink(missing_ok=True)

-    # The idedata caches are derived from the build but live under the data
-    # dir, not the build path, so they must be removed separately in both
-    # modes. Globbed (name.json plus name.<backend>.json) so a future
-    # backend suffix cannot silently drift out of clean-all.
-    idedata_dir = CORE.relative_internal_path("idedata")
-    for idedata_cache in (
-        *idedata_dir.glob(f"{CORE.name}.json"),
-        *idedata_dir.glob(f"{CORE.name}.*.json"),
-    ):
+    # The idedata cache is derived from the build but lives under the data dir,
+    # not the build path, so it must be removed separately in both modes.
+    idedata_cache = CORE.relative_internal_path("idedata", f"{CORE.name}.json")
+    if idedata_cache.is_file():
        _LOGGER.info("Deleting %s", idedata_cache)
        idedata_cache.unlink()

@@ -45,7 +45,7 @@ lib_deps_base =
 lib_deps =
    ${common.lib_deps_base}
    https://github.com/dudanov/MideaUART.git#eeea6c3e9b4474f067054592b435be1c4e466815 ; midea
-    esphome/noise-c@0.1.24                 ; noise (api, ota)
+    esphome/noise-c@0.1.26                 ; noise (api, ota)
    improv/Improv@1.2.7                    ; improv_serial / esp32_improv
    kikuchan98/pngle@1.1.0                 ; online_image
    ; Using the repository directly, otherwise ESP-IDF can't use the library
@@ -244,7 +244,7 @@ lib_deps =
    ${common:idf-component-libs.lib_deps}
    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
    droscy/esp_wireguard@0.4.5            ; wireguard
-    esphome/noise-c@0.1.24                ; noise (api, ota)
+    esphome/noise-c@0.1.26                ; noise (api, ota)
    ESP32Async/AsyncTCP@3.4.5             ; async_tcp
    DNSServer                             ; captive_portal
    heman/AsyncMqttClient-esphome@2.0.0   ; mqtt
@@ -641,7 +641,7 @@ build_unflags =
 extends = common
 platform = platformio/native
 lib_deps =
-    esphome/noise-c@0.1.24  ; used by noise (api, ota)
+    esphome/noise-c@0.1.26  ; used by noise (api, ota)
    lvgl/lvgl@9.5.0         ; lvgl
 build_flags =
    ${common.build_flags}
@@ -10,7 +10,7 @@ tzlocal==5.4.4    # from time
 tzdata>=2026.3  # from time
 pyserial==3.5
 platformio==6.1.19
-esptool==5.3.1
+esptool==5.4.0
 click==8.3.3
 aioesphomeapi==46.3.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
@@ -50,7 +50,6 @@ from __future__ import annotations

 import argparse
 from collections import Counter
-from collections.abc import Callable
 from enum import StrEnum
 from functools import cache
 import json
@@ -532,53 +531,37 @@ ESP32_PLATFORMIO_TRIGGER_PATH_PREFIXES = ("esphome/platformio/",)
 #   - esphome/build_gen/platformio.py -- the PlatformIO build generator
 #   - script/test_build_components.py -- the harness the job invokes
 #   - .github/workflows/ci.yml -- the job's own definition
-# Shared by every toolchain smoke-test job: the harness it invokes and the
-# workflow that defines it
-_SMOKE_HARNESS_TRIGGER_FILES = frozenset(
+ESP32_PLATFORMIO_TRIGGER_FILES = frozenset(
    {
+        "esphome/build_gen/platformio.py",
        "script/test_build_components.py",
        ".github/workflows/ci.yml",
    }
 )

-ESP32_PLATFORMIO_TRIGGER_FILES = _SMOKE_HARNESS_TRIGGER_FILES | {
-    "esphome/build_gen/platformio.py",
-}
-
-
-def _path_or_file_trigger(
-    files: list[str],
-    trigger_files: frozenset[str],
-    trigger_prefixes: tuple[str, ...],
-) -> bool:
-    """Whether any changed file matches the given infrastructure triggers."""
-    return any(
-        file in trigger_files or file.startswith(trigger_prefixes) for file in files
-    )
-
-
-@cache
-def _cached_components_closure(files: tuple[str, ...]) -> frozenset[str]:
-    """Dependency closure of the changed components, from the changed files.
-
-    The walk is expensive and every toolchain smoke-test job asks for the
-    same file list, so compute it once per run."""
-    component_files = [f for f in files if filter_component_and_test_files(f)]
-    return frozenset(get_components_with_dependencies(component_files, True))
-

 def _esp32_platformio_path_or_file_trigger(files: list[str]) -> bool:
    """Whether any changed file is a PlatformIO infrastructure / harness trigger."""
-    return _path_or_file_trigger(
-        files, ESP32_PLATFORMIO_TRIGGER_FILES, ESP32_PLATFORMIO_TRIGGER_PATH_PREFIXES
-    )
+    for file in files:
+        if file in ESP32_PLATFORMIO_TRIGGER_FILES:
+            return True
+        if any(
+            file.startswith(prefix) for prefix in ESP32_PLATFORMIO_TRIGGER_PATH_PREFIXES
+        ):
+            return True
+    return False


 def _esp_idf_infra_changed(files: list[str]) -> bool:
    """Whether any changed file is ESP-IDF build/runner infrastructure."""
-    return _path_or_file_trigger(
-        files, ESP_IDF_INFRA_TRIGGER_FILES, ESP_IDF_INFRA_TRIGGER_PATH_PREFIXES
-    )
+    for file in files:
+        if file in ESP_IDF_INFRA_TRIGGER_FILES:
+            return True
+        if any(
+            file.startswith(prefix) for prefix in ESP_IDF_INFRA_TRIGGER_PATH_PREFIXES
+        ):
+            return True
+    return False


 def esp32_platformio_components_to_test(branch: str | None = None) -> list[str]:
@@ -616,23 +599,15 @@ def esp32_platformio_components_to_test(branch: str | None = None) -> list[str]:
    Returns:
        Sorted list of component names to compile.
    """
-    return _toolchain_components_to_test(
-        branch, ESP32_PLATFORMIO_TEST_COMPONENTS, _esp32_platformio_path_or_file_trigger
-    )
-
-
-def _toolchain_components_to_test(
-    branch: str | None,
-    test_set: frozenset[str],
-    infra_trigger: Callable[[list[str]], bool],
-) -> list[str]:
-    """The shared narrowing rule for the per-toolchain smoke-test jobs."""
    files = changed_files(branch)

-    if core_changed(files) or infra_trigger(files):
-        return sorted(test_set)
+    if core_changed(files) or _esp32_platformio_path_or_file_trigger(files):
+        return sorted(ESP32_PLATFORMIO_TEST_COMPONENTS)

-    return sorted(test_set & _cached_components_closure(tuple(files)))
+    component_files = [f for f in files if filter_component_and_test_files(f)]
+    changed = get_components_with_dependencies(component_files, True)
+
+    return sorted(ESP32_PLATFORMIO_TEST_COMPONENTS & set(changed))


 def should_run_esp32_platformio(branch: str | None = None) -> bool:
@@ -653,83 +628,6 @@ def should_run_esp32_platformio(branch: str | None = None) -> bool:
    return bool(esp32_platformio_components_to_test(branch))


-# The `--toolchain arduino` smoke-test set: covers the core, the bundled and
-# converted registry libraries, and the waveform path.
-ESP8266_NATIVE_TEST_COMPONENTS = frozenset(
-    {
-        "esp8266",
-        "api",
-        "web_server",
-        "captive_portal",
-        "mqtt",
-        "esp8266_pwm",
-        "neopixelbus",
-        "bme280_i2c",
-        "uart",
-    }
-)
-
-# Infrastructure whose changes always trigger the native ESP8266 compile
-# test. esphome/build_helpers/ holds the idedata and size-summary helpers
-# the backend shares with the native ESP-IDF build.
-ESP8266_NATIVE_TRIGGER_PATH_PREFIXES = (
-    "esphome/arduino8266/",
-    "esphome/arduino/",
-    "esphome/build_helpers/",
-)
-# Shared library-conversion modules every native build imports; espidf-only
-# infra (build_gen/espidf.py) deliberately stays out of the esp8266 set.
-_NATIVE_SHARED_TRIGGER_FILES = frozenset(
-    {
-        "esphome/framework_helpers.py",
-        "esphome/platformio/library.py",
-        "esphome/platformio/extra_script.py",
-    }
-)
-# Tripwire: the shared modules must stay in the ESP-IDF trigger set too
-# (now defined in clang_tidy_hash), or its smoke test silently skips them
-assert _NATIVE_SHARED_TRIGGER_FILES <= ESP_IDF_INFRA_TRIGGER_FILES
-ESP8266_NATIVE_TRIGGER_FILES = (
-    _NATIVE_SHARED_TRIGGER_FILES
-    | _SMOKE_HARNESS_TRIGGER_FILES
-    | {
-        "esphome/build_gen/arduino8266.py",
-        "esphome/build_gen/build_tool.py",
-        "esphome/components/esp8266/build_surgery.py",
-        "esphome/components/esp8266/boards.py",
-        "esphome/platformio/registry.py",
-        # esp8266/__init__.py imports copy_ccache_script from it
-        "esphome/platformio/toolchain.py",
-        ".github/actions/cache-arduino8266/action.yml",
-    }
-)
-
-
-def _esp8266_native_path_or_file_trigger(files: list[str]) -> bool:
-    """Whether any changed file is native-ESP8266 infrastructure / harness."""
-    # base_python_changed covers the top-level esphome/*.py modules the
-    # native backend imports directly (framework_helpers, helpers, writer,
-    # __main__); without it a change there would silently skip this job.
-    # base_python_changed is deliberately broad (any top-level esphome/*.py)
-    # as belt-and-braces while the backend is new; narrow it to the modules
-    # the backend imports once the toolchain has soaked a few releases
-    return base_python_changed(files) or _path_or_file_trigger(
-        files, ESP8266_NATIVE_TRIGGER_FILES, ESP8266_NATIVE_TRIGGER_PATH_PREFIXES
-    )
-
-
-def esp8266_native_components_to_test(branch: str | None = None) -> list[str]:
-    """Subset of ``ESP8266_NATIVE_TEST_COMPONENTS`` the job needs to compile.
-
-    Same narrowing logic as ``esp32_platformio_components_to_test``: the full
-    list on core or infrastructure changes, otherwise the intersection with
-    the changed-component dependency closure (empty list skips the job).
-    """
-    return _toolchain_components_to_test(
-        branch, ESP8266_NATIVE_TEST_COMPONENTS, _esp8266_native_path_or_file_trigger
-    )
-
-
 def determine_cpp_unit_tests(
    branch: str | None = None,
 ) -> tuple[bool, list[str]]:
@@ -1328,8 +1226,6 @@ def main() -> None:
        run_device_builder = True
        esp32_platformio_components = sorted(ESP32_PLATFORMIO_TEST_COMPONENTS)
        run_esp32_platformio = True
-        esp8266_native_components = sorted(ESP8266_NATIVE_TEST_COMPONENTS)
-        run_esp8266_native = True
    else:
        integration_run_all, integration_test_files = determine_integration_tests(
            args.branch
@@ -1341,8 +1237,6 @@ def main() -> None:
        run_device_builder = should_run_device_builder(args.branch)
        esp32_platformio_components = esp32_platformio_components_to_test(args.branch)
        run_esp32_platformio = bool(esp32_platformio_components)
-        esp8266_native_components = esp8266_native_components_to_test(args.branch)
-        run_esp8266_native = bool(esp8266_native_components)
    run_integration, integration_test_buckets = _compute_integration_test_buckets(
        integration_run_all, integration_test_files
    )
@@ -1538,8 +1432,6 @@ def main() -> None:
        "device_builder": run_device_builder,
        "esp32_platformio": run_esp32_platformio,
        "esp32_platformio_components": ",".join(esp32_platformio_components),
-        "esp8266_native": run_esp8266_native,
-        "esp8266_native_components": ",".join(esp8266_native_components),
        "changed_components": changed_components,
        "changed_components_with_tests": changed_components_with_tests,
        "directly_changed_components_with_tests": list(directly_changed_with_tests),
@@ -1,27 +1,49 @@
 #!/bin/sh
 # Prepare the dev environment for a new checkout or worktree.
 #
-# Installed into the git hooks directory by script/setup. Deliberately tiny and
-# self-contained: it stays valid on branches where script/setup does not exist,
-# and simply does nothing there.
+# Installed into the git hooks directory by script/setup.py. Deliberately tiny
+# and self-contained: it stays valid on branches where the setup script does not
+# exist, and simply does nothing there.

 # $3 is 1 for a branch checkout, 0 for a file checkout.
 [ "$3" = "1" ] || exit 0

 top=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0

-# This also runs on ordinary branch switches, where there is nothing to do.
+# This also runs on ordinary branch switches, where there is nothing to do. Both
+# layouts are checked because git for Windows runs hooks under its own bundled
+# shell, where the environment lives in venv/Scripts rather than venv/bin.
 [ -x "$top/venv/bin/python" ] && exit 0
-[ -x "$top/script/setup" ] || exit 0
+[ -f "$top/venv/Scripts/python.exe" ] && exit 0
+
+# Branches from before the setup script moved to Python carry only the shell
+# entry point, so whichever one the checked out branch has is used.
+py=
+if [ -f "$top/script/setup.py" ]; then
+  # The interpreter goes by different names across platforms, and on Windows
+  # "python3" is often a stub that opens the app store instead of running
+  # anything, so each candidate is tried before it is used. Doing nothing is the
+  # right outcome when none of them work.
+  for candidate in "python3" "python" "py -3"; do
+    # Unquoted on purpose: the launcher candidate is a command plus a flag.
+    if $candidate -c "" >/dev/null 2>&1; then
+      py=$candidate
+      break
+    fi
+  done
+  [ -n "$py" ] || exit 0
+elif ! [ -x "$top/script/setup" ]; then
+  exit 0
+fi

 # Every worktree shares the hooks directory of the checkout it was created
-# from, and the script/setup run below is the one from whichever branch was just
+# from, and the setup script run below is the one from whichever branch was just
 # checked out. Older branches install their own pre-commit hook without checking
 # for a worktree: that moves the shared hook aside as pre-commit.legacy and
 # replaces it with one tied to this worktree's virtual environment, so commits
 # break in every checkout. To rule that out, the hooks directory is copied
-# before script/setup runs and put back exactly as it was afterwards, including
-# removing any file script/setup added.
+# before the setup script runs and put back exactly as it was afterwards,
+# including removing any file the setup script added.
 hooks=$(git rev-parse --path-format=absolute --git-path hooks 2>/dev/null) || exit 0
 snap=$(mktemp -d "$hooks/.post-checkout.XXXXXX") || exit 0
 cp -p "$hooks"/* "$snap"/ 2>/dev/null
@@ -29,7 +51,13 @@ cp -p "$hooks"/* "$snap"/ 2>/dev/null
 # Clear VIRTUAL_ENV so a checkout made from a shell with an environment already
 # activated still gets its own, rather than having the active one repointed at
 # this working tree.
-env -u VIRTUAL_ENV "$top/script/setup"
+unset VIRTUAL_ENV
+if [ -n "$py" ]; then
+  # Unquoted on purpose, as above.
+  $py "$top/script/setup.py"
+else
+  "$top/script/setup"
+fi
 status=$?

 for f in "$hooks"/*; do
@@ -1104,6 +1104,10 @@ def get_components_per_integration_fixture() -> dict[str, set[str]]:


 _TEST_FUNC_RE = re.compile(r"async def (test_\w+)")
+# Any usage form (decorator, pytestmark assignment or list element); only
+# test_*.py files are scanned, so the marker docs elsewhere cannot false-hit
+_SHARED_YAML_USE_RE = re.compile(r"\bmark\.shared_yaml")
+_SHARED_YAML_ARG_RE = re.compile(r"\(\s*[\"'](\w+)[\"']\s*\)")


@cache
@@ -1123,6 +1127,19 @@ def get_fixture_to_test_files() -> dict[str, frozenset[str]]:
        for func in _TEST_FUNC_RE.findall(content):
            base_name = func.replace("test_", "").partition("[")[0]
            result.setdefault(base_name, set()).add(rel_path)
+        # Shared fixtures are named by marker, not by a test function; each
+        # decorator must carry a string literal or its fixture would silently
+        # map to no tests
+        for use in _SHARED_YAML_USE_RE.finditer(content):
+            arg = _SHARED_YAML_ARG_RE.match(content, use.end())
+            if arg is None:
+                line = content.count("\n", 0, use.start()) + 1
+                raise ValueError(
+                    f"{rel_path}:{line}: shared_yaml marker must take a "
+                    "single-line string literal so CI test selection can map "
+                    "its fixture"
+                )
+            result.setdefault(arg.group(1), set()).add(rel_path)

    return {k: frozenset(v) for k, v in result.items()}

@@ -1,71 +1,7 @@
 #!/usr/bin/env bash
-# Set up ESPHome dev environment
+# Set up ESPHome dev environment.
+#
+# The work is done by setup.py, which script/setup.bat also runs, so the Unix
+# and Windows entry points share one implementation.

-set -e
-
-cd "$(dirname "$0")/.."
-if [ -n "$VIRTUAL_ENV" ]; then
-  # A virtual environment is already active (e.g. the devcontainer's pre-provisioned
-  # esphome-venv). Install into it rather than creating a ./venv in the workspace.
-  venv_state=active
-elif [ -x venv/bin/python ]; then
-  # Reuse the environment from an earlier run, so this script can be run again
-  # at any time to pick up dependency changes.
-  venv_state=reused
-  source venv/bin/activate
-else
-  venv_state=created
-  # --clear replaces a partial environment left behind by an interrupted run.
-  if [ -x "$(command -v uv)" ]; then
-    uv venv --clear --seed venv
-  else
-    python3 -m venv --clear venv
-  fi
-  source venv/bin/activate
-fi
-
-if ! [ -x "$(command -v uv)" ]; then
-  python3 -m pip install uv
-fi
-
-uv pip install setuptools wheel
-uv pip install -e ".[dev,test]" --config-settings editable_mode=compat
-
-# A worktree shares one git hooks directory with the main checkout it was
-# created from, so hooks are installed from the main checkout only. Installing
-# from a worktree would point the shared hook at that worktree's virtual
-# environment, breaking it for everyone once the worktree is removed.
-git_dir="$(git rev-parse --absolute-git-dir 2>/dev/null || true)"
-common_dir="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true)"
-if [ -n "$common_dir" ] && [ "$git_dir" = "$common_dir" ]; then
-  # --overwrite replaces any hook already in place. Without it, prek finds a
-  # previously installed pre-commit hook, moves it aside to
-  # .git/hooks/pre-commit.legacy and keeps calling it, so every commit would
-  # run both tools.
-  prek install --overwrite
-
-  # Prepares the virtual environment for new checkouts and worktrees. Installed
-  # once here, it covers every worktree created from this checkout.
-  if [ -d "$common_dir/hooks" ]; then
-    cp script/git-hooks/post-checkout "$common_dir/hooks/post-checkout"
-    chmod +x "$common_dir/hooks/post-checkout"
-  fi
-fi
-
-mkdir -p .temp
-
-echo
-echo
-case "$venv_state" in
-  created)
-    echo "Virtual environment created at ./venv. Run 'source venv/bin/activate' to use it."
-    ;;
-  reused)
-    echo "Dependencies updated in the existing ./venv. Run 'source venv/bin/activate' to use it."
-    ;;
-  active)
-    echo "Dependencies installed into the active virtual environment:"
-    echo "  $VIRTUAL_ENV"
-    echo "It is already active in this shell, so no 'source venv/bin/activate' is needed."
-    ;;
-esac
+exec python3 "$(dirname "$0")/setup.py" "$@"
@@ -1,28 +1 @@
-@echo off
-
-if defined VIRTUAL_ENV goto :install
-
-echo Starting the Virtual Environment
-python -m venv venv
-call venv/Scripts/activate
-echo Running the Virtual Environment
-
-:install
-
-echo Installing required packages...
-
-python.exe -m pip install --upgrade pip
-
-pip3 install -r requirements.txt -r requirements_test.txt -r requirements_dev.txt
-pip3 install setuptools wheel
-pip3 install -e ".[dev,test]" --config-settings editable_mode=compat
-
-rem --overwrite replaces any hook already in place. Without it, prek finds a
-rem previously installed pre-commit hook, moves it aside to
-rem .git/hooks/pre-commit.legacy and keeps calling it, so every commit would
-rem run both tools.
-prek install --overwrite
-
-echo .
-echo .
-echo Virtual environment created. Run 'venv/Scripts/activate' to use it.
+@python "%~dp0setup.py" %*
@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Set up the ESPHome development environment.
+
+Shared implementation behind script/setup and script/setup.bat, so the Unix and
+Windows entry points cannot drift apart. Uses only the standard library: it runs
+before any dependency has been installed.
+"""
+
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import sysconfig
+
+MIN_PYTHON = (3, 12)
+
+ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_VENV = ROOT / "venv"
+POST_CHECKOUT_HOOK = ROOT / "script" / "git-hooks" / "post-checkout"
+
+# State of the environment the dependencies end up in, used for the closing
+# message.
+VENV_ACTIVE = "active"
+VENV_REUSED = "reused"
+VENV_CREATED = "created"
+
+
+def bin_dir(venv: Path) -> Path:
+    """Return the directory holding a virtual environment's executables.
+
+    The "venv" scheme resolves to bin on Unix and Scripts on Windows, so the
+    layout does not have to be hardcoded here.
+    """
+    base = str(venv)
+    return Path(
+        sysconfig.get_path("scripts", "venv", vars={"base": base, "platbase": base})
+    )
+
+
+def venv_python(venv: Path) -> Path:
+    """Return the path to a virtual environment's interpreter."""
+    name = "python.exe" if os.name == "nt" else "python"
+    return bin_dir(venv) / name
+
+
+def run(command: list[str], env: dict[str, str] | None = None) -> None:
+    """Run a command, aborting the whole script if it fails."""
+    print(f"+ {' '.join(command)}", flush=True)
+    result = subprocess.run(command, cwd=ROOT, env=env, check=False)
+    if result.returncode != 0:
+        # Some tools fail without printing anything, so name the step that broke.
+        print(
+            f"Failed with exit code {result.returncode}: {command[0]}", file=sys.stderr
+        )
+        raise SystemExit(result.returncode)
+
+
+def git_output(*args: str) -> str:
+    """Return the trimmed output of a git command, or "" if it cannot be run."""
+    try:
+        result = subprocess.run(
+            ["git", *args], cwd=ROOT, capture_output=True, text=True, check=False
+        )
+    except OSError:
+        # Git is not required to install the dependencies, only to install hooks.
+        return ""
+    if result.returncode != 0:
+        return ""
+    return result.stdout.strip()
+
+
+def create_venv(venv: Path) -> None:
+    """Create a virtual environment, replacing anything already at the path."""
+    # --clear replaces a partial environment left behind by an interrupted run.
+    if (uv := shutil.which("uv")) is not None:
+        run([uv, "venv", "--clear", "--seed", str(venv)])
+    else:
+        run([sys.executable, "-m", "venv", "--clear", str(venv)])
+
+
+def venv_environment(venv: Path) -> dict[str, str]:
+    """Return the environment child processes need to target a virtual env.
+
+    Equivalent to sourcing the environment's activate script: tools such as uv
+    and prek pick the environment up from VIRTUAL_ENV and PATH.
+    """
+    env = dict(os.environ)
+    env["VIRTUAL_ENV"] = str(venv)
+    env.pop("PYTHONHOME", None)
+    path = str(bin_dir(venv))
+    # An empty entry would be appended if PATH is unset, and on Unix that means
+    # the working directory is searched for executables.
+    if existing := env.get("PATH"):
+        path = os.pathsep.join([path, existing])
+    env["PATH"] = path
+    return env
+
+
+def find_uv(venv: Path, env: dict[str, str]) -> str:
+    """Return the path to uv, installing it into the environment if needed."""
+    if (uv := shutil.which("uv", path=env["PATH"])) is not None:
+        return uv
+    run([str(venv_python(venv)), "-m", "pip", "install", "uv"], env=env)
+    if (uv := shutil.which("uv", path=env["PATH"])) is not None:
+        return uv
+    raise SystemExit("uv could not be installed, aborting.")
+
+
+def install_dependencies(venv: Path, env: dict[str, str]) -> None:
+    """Install ESPHome and its development dependencies into the environment."""
+    uv = find_uv(venv, env)
+    run([uv, "pip", "install", "setuptools", "wheel"], env=env)
+    # The dev and test extras pull in requirements_dev.txt and
+    # requirements_test.txt, and the package itself pulls in requirements.txt,
+    # so this single install covers every requirements file.
+    run(
+        [
+            uv,
+            "pip",
+            "install",
+            "-e",
+            ".[dev,test]",
+            "--config-settings",
+            "editable_mode=compat",
+        ],
+        env=env,
+    )
+
+
+def install_git_hooks(env: dict[str, str]) -> None:
+    """Install the git hooks, but only when run from the main checkout.
+
+    A worktree shares one git hooks directory with the main checkout it was
+    created from. Installing from a worktree would point the shared hook at that
+    worktree's virtual environment, breaking it for everyone once the worktree is
+    removed.
+    """
+    git_dir = git_output("rev-parse", "--absolute-git-dir")
+    common_dir = git_output("rev-parse", "--path-format=absolute", "--git-common-dir")
+    if not git_dir or not common_dir or Path(git_dir) != Path(common_dir):
+        return
+
+    prek = shutil.which("prek", path=env["PATH"])
+    if prek is None:
+        raise SystemExit("prek was not installed, aborting.")
+    # --overwrite replaces any hook already in place. Without it, prek finds a
+    # previously installed pre-commit hook, moves it aside to
+    # .git/hooks/pre-commit.legacy and keeps calling it, so every commit would
+    # run both tools.
+    run([prek, "install", "--overwrite"], env=env)
+
+    # Prepares the virtual environment for new checkouts and worktrees. Installed
+    # once here, it covers every worktree created from this checkout.
+    hooks_dir = Path(common_dir) / "hooks"
+    if hooks_dir.is_dir():
+        installed = hooks_dir / "post-checkout"
+        shutil.copyfile(POST_CHECKOUT_HOOK, installed)
+        installed.chmod(0o755)
+
+
+def activate_hint() -> str:
+    """Return the command that activates the environment this script creates."""
+    activate = bin_dir(DEFAULT_VENV).relative_to(ROOT) / "activate"
+    if os.name == "nt":
+        return str(activate)
+    return f"source {activate.as_posix()}"
+
+
+def report(state: str, venv: Path) -> None:
+    """Print the closing message for the environment that was set up."""
+    location = f"./{DEFAULT_VENV.name}"
+    print()
+    print()
+    if state == VENV_ACTIVE:
+        print("Dependencies installed into the active virtual environment:")
+        print(f"  {venv}")
+        print(
+            f"It is already active in this shell, so no '{activate_hint()}' is needed."
+        )
+    elif state == VENV_REUSED:
+        print(
+            f"Dependencies updated in the existing {location}. "
+            f"Run '{activate_hint()}' to use it."
+        )
+    else:
+        print(
+            f"Virtual environment created at {location}. "
+            f"Run '{activate_hint()}' to use it."
+        )
+
+
+def main() -> None:
+    """Set up the development environment."""
+    if sys.version_info < MIN_PYTHON:
+        raise SystemExit(
+            f"ESPHome needs Python {MIN_PYTHON[0]}.{MIN_PYTHON[1]} or newer, "
+            f"but this is Python {sys.version.split()[0]}."
+        )
+
+    # A virtual environment that is already active (for example the
+    # devcontainer's pre-provisioned esphome-venv) is installed into rather than
+    # creating a ./venv in the workspace.
+    if active := os.environ.get("VIRTUAL_ENV"):
+        state, venv = VENV_ACTIVE, Path(active)
+    elif venv_python(DEFAULT_VENV).is_file():
+        # Reuse the environment from an earlier run, so this script can be run
+        # again at any time to pick up dependency changes.
+        state, venv = VENV_REUSED, DEFAULT_VENV
+    else:
+        state, venv = VENV_CREATED, DEFAULT_VENV
+        create_venv(venv)
+
+    env = venv_environment(venv)
+    install_dependencies(venv, env)
+    install_git_hooks(env)
+    (ROOT / ".temp").mkdir(exist_ok=True)
+    report(state, venv)
+
+
+if __name__ == "__main__":
+    main()
@@ -1027,7 +1027,6 @@ def test_components(
    isolated_components: set[str] | None = None,
    base_only: bool = False,
    toolchain: str | None = None,
-    fail_on_no_tests: bool = False,
 ) -> int:
    """Test components with optional intelligent grouping.

@@ -1062,34 +1061,20 @@ def test_components(
    # toolchain build.
    include_validate = esphome_command != "compile"

-    # Find all component tests; remember which components each pattern
-    # (wildcards included) matched, for the deferred no-tests accounting
+    # Find all component tests
    all_tests = {}
-    pattern_components: dict[str, set[str]] = {}
    for pattern in component_patterns:
        # Skip empty patterns (happens when components list is empty string)
        if not pattern:
            continue
-        found = find_component_tests(
-            tests_dir, pattern, base_only, include_validate=include_validate
+        all_tests.update(
+            find_component_tests(
+                tests_dir, pattern, base_only, include_validate=include_validate
+            )
        )
-        pattern_components[pattern] = set(found)
-        all_tests.update(found)
-
-    # The flag's contract is "no test matched fails": a fully blank pattern
-    # list would otherwise slide into the reference-baseline fallback and
-    # exit green while building nothing a caller asked for
-    if fail_on_no_tests and not any(component_patterns):
-        print("No components requested (blank component list)")
-        return 1
-
-    if fail_on_no_tests and not all_tests:
-        # Nothing matched at all: fail before the synthetic baseline build,
-        # which would spend a compile reporting success on nothing. Partial
-        # matches defer to the per-pattern accounting after the summary.
-        print(f"No components found matching: {component_patterns}")
-        return 1

+    # If no components found, build a reference configuration for baseline comparison
+    # Create a synthetic "empty" component test that will build just the base config
    if not all_tests:
        print(f"No components found matching: {component_patterns}")
        print(
@@ -1193,26 +1178,6 @@ def test_components(
                        toolchain=toolchain,
                    )

-    silent: list[str] = []
-    if fail_on_no_tests:
-        # A green run that built nothing for a requested pattern (renamed
-        # fixture, missing base file, version-suffix mismatch, a wildcard
-        # matching no component) must not pass CI. Per pattern: an
-        # all-or-nothing check would let one silent pattern hide behind the
-        # others. Opt-in: some legs (the esp32-ard smoke subset)
-        # legitimately match nothing. Failing is deferred past the summary
-        # so a real failure's reproduce commands still print.
-        built = {c for r in test_results for c in r.components}
-        # A pattern is silent when it matched no fixture, or when none of
-        # its matched components produced a build (wildcards included)
-        silent = [
-            p
-            for p in component_patterns
-            if p and not (pattern_components.get(p, set()) & built)
-        ]
-        if silent:
-            print(f"No tests ran for requested pattern(s): {', '.join(silent)}")
-
    # Separate results into passed and failed
    passed_results = [r for r in test_results if r.success]
    failed_results = [r for r in test_results if not r.success]
@@ -1244,7 +1209,7 @@ def test_components(
    if os.environ.get("GITHUB_STEP_SUMMARY"):
        write_github_summary(test_results, toolchain=toolchain)

-    if failed_results or silent:
+    if failed_results:
        return 1

    return 0
@@ -1299,12 +1264,6 @@ def main() -> int:
        "--toolchain",
        help="Select toolchain for compiling.",
    )
-    parser.add_argument(
-        "--fail-on-no-tests",
-        action="store_true",
-        help="Exit non-zero when no test matched (for CI legs whose "
-        "components must all have fixtures)",
-    )

    args = parser.parse_args()

@@ -1323,7 +1282,6 @@ def main() -> int:
        continue_on_fail=args.continue_on_fail,
        enable_grouping=not args.no_grouping,
        isolated_components=isolated_components,
-        fail_on_no_tests=args.fail_on_no_tests,
        base_only=args.base_only,
        toolchain=args.toolchain,
    )
@@ -17,6 +17,8 @@ CONFIG_ESP_TASK_WDT_INIT=y
 CONFIG_ESP_TASK_WDT_PANIC=y
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
+CONFIG_FREERTOS_USE_TICKLESS_IDLE=y
+CONFIG_PM_ENABLE=y

 # esp32_ble
 CONFIG_BT_ENABLED=y
@@ -0,0 +1,90 @@
+"""Validation tests for the sendspin media_source platform.
+
+These cover the codec preference list, whose rejection branches a compile test
+cannot reach: a `test*.yaml` can only assert that a configuration is accepted.
+"""
+
+from typing import Any
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.sendspin import CONF_CODECS, _get_data
+from esphome.components.sendspin.media_source import CONFIG_SCHEMA
+from esphome.const import PlatformFramework
+from esphome.types import ConfigType
+from tests.component_tests.types import SetCoreConfigCallable
+
+
+def _media_source_config(**overrides: Any) -> ConfigType:
+    """Build a minimal valid media source config, allowing field overrides."""
+    config: ConfigType = {
+        "id": "sendspin_media_source",
+        "sendspin_id": "sendspin_hub",
+    }
+    config.update(overrides)
+    return config
+
+
+def test_default_codecs_at_48_khz(set_core_config: SetCoreConfigCallable) -> None:
+    """Every codec is advertised when the sample rate suits all of them."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    config = CONFIG_SCHEMA(_media_source_config())
+
+    assert config[CONF_CODECS] == ["flac", "opus", "pcm"]
+
+
+def test_default_codecs_drop_opus_at_other_rates(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """Opus only supports 48 kHz, so it leaves the default list at other rates."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    config = CONFIG_SCHEMA(_media_source_config(sample_rate=44100))
+
+    assert config[CONF_CODECS] == ["flac", "pcm"]
+
+
+def test_configured_order_is_preserved(set_core_config: SetCoreConfigCallable) -> None:
+    """The list is a preference order, so it reaches the player role as written."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    CONFIG_SCHEMA(_media_source_config(codecs=["pcm", "flac"]))
+
+    assert _get_data().player_config[CONF_CODECS] == ["pcm", "flac"]
+
+
+def test_empty_codec_list_rejected(set_core_config: SetCoreConfigCallable) -> None:
+    """A player with no codecs at all could never be given a stream."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="length of value must be at least 1"):
+        CONFIG_SCHEMA(_media_source_config(codecs=[]))
+
+
+def test_duplicate_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
+    """A repeated codec has no meaning in a preference order."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="may only be listed once"):
+        CONFIG_SCHEMA(_media_source_config(codecs=["flac", "flac"]))
+
+
+def test_unknown_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
+    """Only codecs the player role can decode are accepted."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="Unknown value"):
+        CONFIG_SCHEMA(_media_source_config(codecs=["mp3"]))
+
+
+def test_opus_at_wrong_sample_rate_rejected(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """Asking for Opus at a rate it cannot handle fails rather than silently
+    dropping the stated preference."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="requires a sample_rate of 48000"):
+        CONFIG_SCHEMA(_media_source_config(codecs=["opus"], sample_rate=44100))
@@ -0,0 +1,76 @@
+"""The template platforms surface value-describing metadata on the main form.
+
+Hardware platforms get sensible defaults for unit/device_class/etc., so those
+fields fall through to the editor's advanced disclosure. A ``template`` entity
+has no such defaults -- the user is expected to define them -- so the template
+platforms pass ``visibility=cv.Visibility.UI`` to promote them onto the form.
+"""
+
+from __future__ import annotations
+
+import importlib
+
+import pytest
+
+import esphome.config_validation as cv
+
+
+def _markers(schema: cv.Schema) -> dict[str, object]:
+    s = schema
+    if hasattr(s, "validators"):
+        # cv.All -> the schema is the first validator.
+        s = s.validators[0]
+    return {str(k): k for k in s.schema}
+
+
+@pytest.mark.parametrize(
+    ("platform", "fields"),
+    [
+        (
+            "sensor",
+            [
+                "unit_of_measurement",
+                "accuracy_decimals",
+                "device_class",
+                "state_class",
+                "force_update",
+            ],
+        ),
+        ("binary_sensor", ["device_class"]),
+        ("switch", ["device_class"]),
+        ("cover", ["device_class"]),
+        ("button", ["device_class"]),
+        ("valve", ["device_class"]),
+        ("event", ["device_class"]),
+        ("text_sensor", ["device_class"]),
+        ("number", ["device_class", "unit_of_measurement"]),
+    ],
+)
+def test_template_metadata_is_ui(platform: str, fields: list[str]) -> None:
+    mod = importlib.import_module(f"esphome.components.template.{platform}")
+    markers = _markers(mod.CONFIG_SCHEMA)
+    for field in fields:
+        assert markers[field].visibility is cv.Visibility.UI, f"{platform}.{field}"
+
+
+def test_template_sensor_promotion_preserves_defaults() -> None:
+    """Promoting to UI must not drop the fields' defaults."""
+    from esphome.components.template.sensor import CONFIG_SCHEMA
+
+    markers = _markers(CONFIG_SCHEMA)
+    assert markers["accuracy_decimals"].default() == 1
+    assert markers["force_update"].default() is False
+
+
+def test_hardware_platform_metadata_not_promoted() -> None:
+    """Without ``visibility=`` the builders leave metadata unset.
+
+    Unset markers fall through to the consumer's ``Optional`` default of
+    advanced, so hardware platforms are unaffected by the template promotion.
+    """
+    from esphome.components import binary_sensor, sensor
+
+    hw_sensor = _markers(sensor.sensor_schema(device_class="temperature"))
+    assert hw_sensor["device_class"].visibility is None
+    hw_bs = _markers(binary_sensor.binary_sensor_schema(device_class="motion"))
+    assert hw_bs["device_class"].visibility is None
@@ -21,6 +21,13 @@ The `yaml_config` fixture automatically loads YAML configurations based on the t
 - The fixture file must exist or the test will fail with a clear error message
 - The fixture automatically injects a dynamic port number into the API configuration

+Tests marked `@pytest.mark.shared_yaml("name")` load `fixtures/name.yaml` instead
+of the test-named file and compile it in a shared, hash-keyed build directory, so
+the whole group pays one full compile and each test only a relink. The marker
+argument must be a single-line string literal (CI test selection maps fixtures to
+test files by scanning for it), and marked tests must hand the `yaml_config`
+content to `run_compiled` unmodified.
+
 ### Key Fixtures

 - `run_compiled` - Combines write, compile, and run operations into a single context manager
@@ -4,17 +4,22 @@ from __future__ import annotations

 import asyncio
 from collections.abc import AsyncGenerator, Callable, Generator
-from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from contextlib import AbstractAsyncContextManager, asynccontextmanager, suppress
 import fcntl
+from functools import cache
+import hashlib
 import logging
 import os
 from pathlib import Path
 import platform
+import re
+import shutil
 import signal
 import socket
 import subprocess
 import sys
 import tempfile
+import time
 from typing import TextIO

 from aioesphomeapi import APIClient, APIConnectionError, LogParser, ReconnectLogic
@@ -23,7 +28,13 @@ import pytest_asyncio

 import esphome.config
 from esphome.core import CORE
-from esphome.helpers import get_usable_cpu_count
+from esphome.helpers import (
+    get_usable_cpu_count,
+    read_file,
+    rmtree,
+    write_file,
+    write_file_if_changed,
+)
 from esphome.platformio.toolchain import get_idedata

 from .const import (
@@ -56,6 +67,21 @@ import pty  # not available on Windows
 pytest.register_assert_rewrite("tests.integration.entity_utils")


+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "shared_yaml(name): load fixtures/<name>.yaml and compile it in a shared, "
+        "hash-keyed incremental build directory",
+    )
+
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+
+# CI caches parts of this path; keep in sync with ci.yml integration-tests.
+INTEGRATION_TESTS_ROOT = Path.home() / ".esphome-integration-tests"
+
+
 def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
    """Get environment variables for PlatformIO with shared cache."""
    env = os.environ.copy()
@@ -78,7 +104,7 @@ def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
        )
    # Compile with THIS tree's esphome sources, not wherever the venv's editable
    # install points (which may be a different git worktree or checkout).
-    repo_root = str(Path(__file__).resolve().parent.parent.parent)
+    repo_root = str(REPO_ROOT)
    existing = env.get("PYTHONPATH")
    env["PYTHONPATH"] = f"{repo_root}{os.pathsep}{existing}" if existing else repo_root
    return env
@@ -88,8 +114,7 @@ def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
 def shared_platformio_cache() -> Generator[Path]:
    """Initialize a shared PlatformIO cache for all integration tests."""
    # Use a dedicated directory for integration tests to avoid conflicts.
-    # CI caches parts of this path; keep in sync with ci.yml integration-tests.
-    test_cache_dir = Path.home() / ".esphome-integration-tests"
+    test_cache_dir = INTEGRATION_TESTS_ROOT
    cache_dir = test_cache_dir / "platformio"

    # Use a lock file in the home directory to ensure only one process initializes the cache
@@ -112,7 +137,9 @@ def shared_platformio_cache() -> Generator[Path]:
                init_dir = Path(tmpdir)
                fixture_path = Path(__file__).parent / "fixtures" / "cache_init.yaml"
                config_path = init_dir / "cache_init.yaml"
-                config_path.write_text(fixture_path.read_text())
+                config_path.write_text(
+                    fixture_path.read_text(encoding="utf-8"), encoding="utf-8"
+                )

                # Run compilation to populate the cache
                # We must succeed here to avoid race conditions where multiple
@@ -162,13 +189,6 @@ def integration_test_dir() -> Generator[Path]:
        yield Path(tmpdir)


-@pytest.fixture
-def isolated_preferences(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    """Host preferences persist per device name; give the test its own so a
-    provisioned key never leaks into another run."""
-    monkeypatch.setenv("ESPHOME_PREFDIR", str(tmp_path / "prefs"))
-
-
@pytest.fixture
 def reserved_tcp_port() -> Generator[tuple[int, socket.socket]]:
    """Reserve an unused TCP port by holding the socket open."""
@@ -188,21 +208,29 @@ def unused_tcp_port(reserved_tcp_port: tuple[int, socket.socket]) -> int:
    return reserved_tcp_port[0]


+@pytest.fixture(autouse=True)
+def isolated_preferences(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Path:
+    """Give every test its own host prefs dir; prefs are keyed only by device
+    name, which tests sharing a fixture also share."""
+    prefdir = tmp_path / "prefs"
+    monkeypatch.setenv("ESPHOME_PREFDIR", str(prefdir))
+    return prefdir
+
+
@pytest_asyncio.fixture
 async def yaml_config(request: pytest.FixtureRequest, unused_tcp_port: int) -> str:
    """Load YAML configuration based on test name."""
-    # Get the test function name
-    test_name: str = request.node.name
-    # Extract the base test name (remove test_ prefix and any parametrization)
-    base_name = test_name.replace("test_", "").partition("[")[0]
+    shared_name = _shared_yaml_name(request)
+    # Base test name: test_ prefix and any parametrization stripped
+    base_name = shared_name or request.node.name.replace("test_", "").partition("[")[0]

    # Load the fixture file
-    fixture_path = Path(__file__).parent / "fixtures" / f"{base_name}.yaml"
+    fixture_path = FIXTURES_DIR / f"{base_name}.yaml"
    if not fixture_path.exists():
        raise FileNotFoundError(f"Fixture file not found: {fixture_path}")

    loop = asyncio.get_running_loop()
-    content = await loop.run_in_executor(None, fixture_path.read_text)
+    content = await loop.run_in_executor(None, read_file, fixture_path)

    # Replace the port in the config if it contains api section
    if "api:" in content:
@@ -226,11 +254,13 @@ async def yaml_config(request: pytest.FixtureRequest, unused_tcp_port: int) -> s

    # Replace external component path placeholder if present
    if "EXTERNAL_COMPONENT_PATH" in content:
-        external_components_path = str(
-            Path(__file__).parent / "fixtures" / "external_components"
-        )
+        external_components_path = str(FIXTURES_DIR / "external_components")
        content = content.replace("EXTERNAL_COMPONENT_PATH", external_components_path)

+    if shared_name is not None:
+        # _compile verifies the marked test compiles this content unmodified
+        request.node._shared_yaml_content = content
+
    return content


@@ -240,24 +270,218 @@ async def write_yaml_config(
 ) -> AsyncGenerator[ConfigWriter]:
    """Write YAML configuration to a file."""
    # Get the test name for default filename
-    test_name = request.node.name
-    base_name = test_name.replace("test_", "").split("[")[0]
+    base_name = request.node.name.replace("test_", "").partition("[")[0]

    async def _write_config(content: str, filename: str | None = None) -> Path:
        if filename is None:
            filename = f"{base_name}.yaml"
        config_path = integration_test_dir / filename
        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, config_path.write_text, content)
+        await loop.run_in_executor(None, write_file, config_path, content)
        return config_path

    yield _write_config


+# Deliberately not CI-cached (ci.yml caches only platformio/ subpaths); stale
+# dirs for a fixture are pruned when its content hash changes.
+SHARED_BUILDS_ROOT = INTEGRATION_TESTS_ROOT / "builds"
+
+# In the dir name (not just the hash) so pruning stays inside this checkout
+_REPO_KEY = hashlib.sha256(str(REPO_ROOT).encode()).hexdigest()[:8]
+
+# Give a contended shared build lock time for a full cold compile ahead of us
+_SHARED_LOCK_TIMEOUT_S = 900
+_SHARED_LOCK_POLL_S = 0.1
+_SHARED_LOCK_REPORT_S = 30
+
+# Reclaims dirs orphaned by fixture renames or deleted checkouts
+_STALE_BUILD_MAX_AGE_S = 30 * 24 * 3600
+
+# ELF path per shared build dir; constant once compiled, so resolve it only once
+_shared_elf_paths: dict[Path, Path] = {}
+
+# Dirs this process already swept; pruning is session-scoped work
+_pruned_dirs: set[Path] = set()
+
+
+def _shared_yaml_name(request: pytest.FixtureRequest) -> str | None:
+    """Name passed to the shared_yaml marker, or None when unmarked."""
+    marker = request.node.get_closest_marker("shared_yaml")
+    if marker is None:
+        return None
+    # Exactly one \w+ positional arg: the name doubles as a build dir
+    # component, and CI test selection (script/helpers.py) parses the same shape
+    if (
+        len(marker.args) != 1
+        or marker.kwargs
+        or not re.fullmatch(r"\w+", str(marker.args[0]))
+    ):
+        raise ValueError(
+            "shared_yaml marker requires exactly one \\w+ fixture name literal"
+        )
+    return marker.args[0]
+
+
+def _shared_build_prefix(name: str) -> str:
+    return f"{name}-{_REPO_KEY}-"
+
+
+@cache
+def _shared_build_dir(name: str) -> Path:
+    """Dir keyed by checkout and fixture source, before per-test injections."""
+    key = hashlib.sha256((FIXTURES_DIR / f"{name}.yaml").read_bytes()).hexdigest()[:16]
+    return SHARED_BUILDS_ROOT / (_shared_build_prefix(name) + key)
+
+
+def _read_stamp(stamp: Path, shared_dir: Path) -> Path | None:
+    """ELF path recorded by the last completed compile, or None."""
+    try:
+        text = stamp.read_text(encoding="utf-8").strip()
+    except FileNotFoundError:
+        return None
+    except OSError as err:
+        print(f"Cannot read {stamp}: {err}")
+        return None
+    if not text:
+        print(f"Ignoring empty stamp {stamp}")
+        return None
+    built = Path(text)
+    # Never trust a stamp pointing outside its own build dir as an unlink target
+    if shared_dir.resolve() in built.resolve().parents:
+        return built
+    print(f"Ignoring stamp {stamp} pointing outside {shared_dir}")
+    return None
+
+
+def _unused_since(stale: Path, cutoff: float) -> bool:
+    """Whether a build dir looks untouched since cutoff; unknown counts as used."""
+    # Newest of the .built stamp (rewritten by every completed compile) and the
+    # dir itself (freshened by a worker claiming the dir before locking)
+    newest: float | None = None
+    for probe in (stale / ".built", stale):
+        try:
+            mtime = probe.stat().st_mtime
+        except FileNotFoundError:
+            continue
+        except NotADirectoryError:
+            return True  # a stray file where a dir should be; reclaimable
+        except OSError as err:
+            print(f"Cannot age-probe {stale}: {err}")
+            return False  # unknown never authorizes deletion
+        newest = mtime if newest is None else max(newest, mtime)
+    return newest is not None and newest < cutoff
+
+
+def _prune_stale_builds(name: str, keep: Path) -> None:
+    """Remove outdated build dirs (blocking, run in executor): this checkout's
+    other dirs for the fixture, plus anything untouched for 30 days. Tolerates
+    other workers pruning the same dirs concurrently."""
+    cutoff = time.time() - _STALE_BUILD_MAX_AGE_S
+    prefix = _shared_build_prefix(name)
+    for stale in SHARED_BUILDS_ROOT.iterdir():
+        if stale == keep:
+            continue
+        same_fixture = stale.name.startswith(prefix)
+        if not same_fixture and not _unused_since(stale, cutoff):
+            continue
+        # Creating .lock bumps the dir mtime, so remember whether the re-probe
+        # under the lock can trust it
+        lock_preexisting = (stale / ".lock").exists()
+        try:
+            lock_file = (stale / ".lock").open("w")
+        except FileNotFoundError:
+            continue  # pruned by another worker meanwhile
+        except NotADirectoryError:
+            print(f"Removing stray file {stale}")
+            stale.unlink(missing_ok=True)
+            continue
+        except OSError as err:
+            print(f"Cannot prune {stale}: {err}")
+            continue
+        with lock_file:
+            try:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                continue  # still in use by another run
+            # Re-probe under the lock: a worker freshens its dir before
+            # locking, so a just-claimed dir no longer looks unused. A dir
+            # whose .lock we just created cannot be held by anyone, and our
+            # own open bumped its mtime, so its pre-open probe stands
+            if (
+                lock_preexisting
+                and not same_fixture
+                and not _unused_since(stale, cutoff)
+            ):
+                continue
+            # rmtree tolerates races; a leftover partial tree only costs a
+            # rebuild, since the ELF is deleted before every compile
+            try:
+                rmtree(stale)
+            except OSError as err:
+                print(f"Failed to prune {stale}: {err}")
+
+
+async def _run_esphome_compile(
+    config_path: Path, cwd: Path, env: dict[str, str]
+) -> None:
+    """Run `esphome compile`, retrying up to 3 times on a segfault."""
+    max_retries = 3
+    for attempt in range(max_retries):
+        # Compile using subprocess, inheriting stdout/stderr to show progress
+        proc = await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-m",
+            "esphome",
+            "compile",
+            str(config_path),
+            cwd=cwd,
+            stdout=None,  # Inherit stdout
+            stderr=None,  # Inherit stderr
+            stdin=asyncio.subprocess.DEVNULL,
+            # Start in a new process group to isolate signal handling
+            start_new_session=True,
+            env=env,
+            close_fds=False,
+        )
+        await proc.wait()
+
+        if proc.returncode == 0:
+            break
+        if proc.returncode == -11 and attempt < max_retries - 1:
+            # Segfault (-11 = SIGSEGV), retry
+            print(
+                f"Compilation segfaulted (attempt {attempt + 1}/{max_retries}), retrying..."
+            )
+            await asyncio.sleep(1)  # Brief pause before retry
+            continue
+        raise RuntimeError(
+            f"Failed to compile {config_path}, return code: {proc.returncode}. "
+            f"Run with 'pytest -s' to see compilation output."
+        )
+
+
+def _resolve_compiled_binary(config_path: Path) -> Path:
+    """Load the config to learn the compiled ELF path (blocking, run in executor)."""
+    CORE.reset()  # Reset CORE state between test runs
+    CORE.config_path = config_path
+    config = esphome.config.read_config(
+        {"command": "compile", "config": str(config_path)}
+    )
+    if config is None:
+        raise RuntimeError(f"Failed to read config from {config_path}")
+    idedata = get_idedata(config)
+    binary_path = Path(idedata.firmware_elf_path)
+    if not binary_path.exists():
+        raise RuntimeError(f"Compiled binary not found at {binary_path}")
+    return binary_path
+
+
@pytest_asyncio.fixture
 async def compile_esphome(
    integration_test_dir: Path,
    shared_platformio_cache: Path,
+    request: pytest.FixtureRequest,
 ) -> AsyncGenerator[CompileFunction]:
    """Compile an ESPHome configuration and return the binary path."""

@@ -265,66 +489,96 @@ async def compile_esphome(
        # Use the shared PlatformIO cache for faster compilation
        # This avoids re-downloading dependencies for each test
        env = _get_platformio_env(shared_platformio_cache)
-
-        # Retry compilation up to 3 times if we get a segfault
-        max_retries = 3
-        for attempt in range(max_retries):
-            # Compile using subprocess, inheriting stdout/stderr to show progress
-            proc = await asyncio.create_subprocess_exec(
-                sys.executable,
-                "-m",
-                "esphome",
-                "compile",
-                str(config_path),
-                cwd=integration_test_dir,
-                stdout=None,  # Inherit stdout
-                stderr=None,  # Inherit stderr
-                stdin=asyncio.subprocess.DEVNULL,
-                # Start in a new process group to isolate signal handling
-                start_new_session=True,
-                env=env,
-                close_fds=False,
-            )
-            await proc.wait()
-
-            if proc.returncode == 0:
-                # Success!
-                break
-            if proc.returncode == -11 and attempt < max_retries - 1:
-                # Segfault (-11 = SIGSEGV), retry
-                print(
-                    f"Compilation segfaulted (attempt {attempt + 1}/{max_retries}), retrying..."
-                )
-                await asyncio.sleep(1)  # Brief pause before retry
-                continue
-            # Other error or final retry
-            raise RuntimeError(
-                f"Failed to compile {config_path}, return code: {proc.returncode}. "
-                f"Run with 'pytest -s' to see compilation output."
-            )
-
-        # Load the config to get idedata (blocking call, must use executor)
        loop = asyncio.get_running_loop()

-        def _read_config_and_get_binary():
-            CORE.reset()  # Reset CORE state between test runs
-            CORE.config_path = config_path
-            config = esphome.config.read_config(
-                {"command": "compile", "config": str(config_path)}
+        name = _shared_yaml_name(request)
+        if name is None:
+            await _run_esphome_compile(config_path, integration_test_dir, env)
+            return await loop.run_in_executor(
+                None, _resolve_compiled_binary, config_path
            )
-            if config is None:
-                raise RuntimeError(f"Failed to read config from {config_path}")

-            # Get the compiled binary path
-            idedata = get_idedata(config)
-            return Path(idedata.firmware_elf_path)
-
-        binary_path = await loop.run_in_executor(None, _read_config_and_get_binary)
-
-        if not binary_path.exists():
-            raise RuntimeError(f"Compiled binary not found at {binary_path}")
-
-        return binary_path
+        # Shared fixture: build in a hash-keyed dir so tests sharing a config
+        # pay one full compile and later only a main.cpp (port) rebuild + relink
+        shared_dir = _shared_build_dir(name)
+        shared_dir.mkdir(parents=True, exist_ok=True)
+        # Freshen the dir before locking so a concurrent age sweep, which
+        # re-probes under the lock, never reaps a dir a worker just claimed;
+        # if a peer reaped it already, the guarded lock open recreates it
+        with suppress(FileNotFoundError):
+            os.utime(shared_dir)
+        if shared_dir not in _pruned_dirs:
+            _pruned_dirs.add(shared_dir)
+            await loop.run_in_executor(None, _prune_stale_builds, name, shared_dir)
+        shared_config = shared_dir / f"{name}.yaml"
+        private_binary = integration_test_dir / f"{name}.elf"
+        content = await loop.run_in_executor(None, read_file, config_path)
+        if content != getattr(request.node, "_shared_yaml_content", None):
+            # The dir is keyed by the fixture source; a mutated config would be
+            # cached under a hash that does not describe it
+            raise RuntimeError(
+                "shared_yaml tests must compile the yaml_config content unmodified"
+            )
+        # flock serializes concurrent xdist workers; closing the fd releases it.
+        # Hand-rolled rather than filelock.FileLock: non-blocking retries keep
+        # the wait cancellable, while a blocking acquire in an executor thread
+        # would survive test cancellation holding the fd
+        try:
+            lock_file = (shared_dir / ".lock").open("w")
+        except FileNotFoundError:
+            # A peer run pruning divergent hashes reaped the dir between our
+            # mkdir and this open; recreate it and pay a full rebuild
+            shared_dir.mkdir(parents=True, exist_ok=True)
+            lock_file = (shared_dir / ".lock").open("w")
+        with lock_file:
+            start = time.monotonic()
+            last_report = start
+            while True:
+                try:
+                    fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    break
+                except BlockingIOError:
+                    now = time.monotonic()
+                    if now - start > _SHARED_LOCK_TIMEOUT_S:
+                        raise RuntimeError(
+                            f"Timed out waiting for the {shared_dir} lock"
+                        ) from None
+                    if now - last_report >= _SHARED_LOCK_REPORT_S:
+                        last_report = now
+                        print(
+                            f"Waited {now - start:.0f}s for another worker's "
+                            f"build of {shared_dir.name}"
+                        )
+                    await asyncio.sleep(_SHARED_LOCK_POLL_S)
+            # .built carries the ELF path of the last completed compile, so
+            # later workers skip the config re-read in _resolve_compiled_binary
+            stamp = shared_dir / ".built"
+            if (built := _shared_elf_paths.get(shared_dir)) is None:
+                built = await loop.run_in_executor(None, _read_stamp, stamp, shared_dir)
+            # Delete the ELF before compiling: whatever exists afterwards is
+            # this compile's output, so no staleness check is ever needed.
+            # With no usable stamp, sweep any leftover at the known layout
+            if built is not None:
+                built.unlink(missing_ok=True)
+            else:
+                # Layout-agnostic: ESPHOME_BUILD_PATH can move the build tree
+                for leftover in shared_dir.rglob("program"):
+                    if leftover.is_file():
+                        leftover.unlink()
+            await loop.run_in_executor(
+                None, write_file_if_changed, shared_config, content
+            )
+            await _run_esphome_compile(shared_config, shared_dir, env)
+            if built is None or not built.exists():
+                built = await loop.run_in_executor(
+                    None, _resolve_compiled_binary, shared_config
+                )
+            _shared_elf_paths[shared_dir] = built
+            await loop.run_in_executor(None, write_file, stamp, str(built))
+            # Copy out before unlocking: another worker may relink firmware.elf
+            # while this test is still running its private copy
+            await loop.run_in_executor(None, shutil.copy2, built, private_binary)
+        return private_binary

    yield _compile

@@ -1,58 +0,0 @@
-esphome:
-  name: test-batch-window-filters
-
-host:
-api:
-  batch_delay: 0ms  # Disable batching to receive all state updates
-logger:
-  level: DEBUG
-
-# Template sensor that we'll use to publish values
-sensor:
-  - platform: template
-    name: "Source Sensor"
-    id: source_sensor
-    accuracy_decimals: 2
-
-  # Batch window filters (window_size == send_every) - use streaming filters
-  - platform: copy
-    source_id: source_sensor
-    name: "Min Sensor"
-    id: min_sensor
-    filters:
-      - min:
-          window_size: 5
-          send_every: 5
-          send_first_at: 1
-
-  - platform: copy
-    source_id: source_sensor
-    name: "Max Sensor"
-    id: max_sensor
-    filters:
-      - max:
-          window_size: 5
-          send_every: 5
-          send_first_at: 1
-
-  - platform: copy
-    source_id: source_sensor
-    name: "Moving Avg Sensor"
-    id: moving_avg_sensor
-    filters:
-      - sliding_window_moving_average:
-          window_size: 5
-          send_every: 5
-          send_first_at: 1
-
-# Button to trigger publishing test values
-button:
-  - platform: template
-    name: "Publish Values Button"
-    id: publish_button
-    on_press:
-      - lambda: |-
-          // Publish 10 values: 1.0, 2.0, ..., 10.0
-          for (int i = 1; i <= 10; i++) {
-            id(source_sensor).publish_state(float(i));
-          }
@@ -0,0 +1,34 @@
+esphome:
+  name: set-internal-at-boot
+  on_boot:
+    then:
+      - lambda: |-
+          id(hidden_at_boot).set_internal(true);
+          id(shown_at_boot).set_internal(false);
+
+host:
+
+api:
+  actions:
+    - action: set_internal_late
+      then:
+        - lambda: id(untouched).set_internal(true);
+
+logger:
+
+sensor:
+  - platform: template
+    name: "Hidden At Boot"
+    id: hidden_at_boot
+    lambda: return 1.0;
+
+  - platform: template
+    name: "Shown At Boot"
+    id: shown_at_boot
+    internal: true
+    lambda: return 2.0;
+
+  - platform: template
+    name: "Untouched"
+    id: untouched
+    lambda: return 3.0;
@@ -1,111 +0,0 @@
-esphome:
-  name: uart-mock-modbus-cli-rw
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-# Two virtual buses looped back to each other: the client's transmissions reach the server and the
-# server's replies reach the client. auto_start so forwarding is active before the button fires.
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_client
-              data: !lambda return data;
-  - id: virtual_uart_client
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_1
-    type: uint16_t
-    initial_value: "0"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_client
-    id: virtual_modbus_client
-    role: client
-    turnaround_time: 10ms
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    registers:
-      # Writable + readable register: the read publishes what it returns, so the test can confirm the
-      # write half of the 0x17 ran before the read half (Modbus 6.17).
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: |-
-          id(srv_read_1).publish_state(id(stored_1));
-          return id(stored_1);
-        write_lambda: |-
-          id(stored_1) = x;
-          id(srv_write_1).publish_state(x);
-          return true;
-      # Read-only register, returned together with 0x01 by the 2-register read half.
-      - address: 0x02
-        value_type: U_WORD
-        read_lambda: return 0x00AA;
-
-sensor:
-  # Server-side observations.
-  - platform: template
-    name: "srv_write_1"
-    id: srv_write_1
-  - platform: template
-    name: "srv_read_1"
-    id: srv_read_1
-  # Client-side read-back: the values the client's on_response received.
-  - platform: template
-    name: "client_read_0"
-    id: client_read_0
-  - platform: template
-    name: "client_read_1"
-    id: client_read_1
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    on_press:
-      # FC 0x17: write reg 0x0001 = 0x1234, then read regs 0x0001..0x0002 back in the same transaction.
-      - modbus_client.read_write_multiple_registers:
-          address: 0x01
-          read_address: 0x0001
-          read_count: 2
-          write_address: 0x0001
-          values: [0x1234]
-          on_response:
-            then:
-              - lambda: |-
-                  // values is the read-back block: reg 0x0001 (must be the just-written 0x1234) and reg 0x0002.
-                  if (values.size() >= 2) {
-                    id(client_read_0).publish_state(values[0]);
-                    id(client_read_1).publish_state(values[1]);
-                  }
@@ -1,88 +0,0 @@
-esphome:
-  name: uart-mock-modbus-custom-pdu
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    id: modbus_controller_1
-    update_interval: 1s
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: return 259;
-
-sensor:
-  # Plain read to confirm the controller <-> server link is up.
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "plain_read"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-  # Custom PDU: read holding register 0x0001, count 1. The PDU is
-  # {function code, address hi, address lo, count hi, count lo}; the device
-  # address and CRC are added by the hub. The lambda parses the response payload
-  # (the register value, big-endian).
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "custom_read"
-    custom_pdu: [0x03, 0x00, 0x01, 0x00, 0x01]
-    lambda: |-
-      if (data.size() < 2) return {};
-      return (float) ((data[0] << 8) | data[1]);
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -1,106 +0,0 @@
-esphome:
-  name: uart-mock-modbus-dep-buffer
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: reg10
-    type: uint16_t
-    initial_value: "0"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    id: modbus_controller_1
-    update_interval: 1s
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x10
-        value_type: U_WORD
-        read_lambda: return id(reg10);
-        write_lambda: |-
-          id(reg10) = x;
-          return true;
-
-# A number whose write_lambda uses the DEPRECATED buffer parameter (fills `payload` with a legacy raw
-# frame as words: device address + function code + data) instead of the new item->write_* API. The write
-# must still land with its legacy semantics, and the one-time deprecation warning must fire only once per
-# entity no matter how many writes happen.
-number:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "buf_number"
-    id: buf_number
-    address: 0x10
-    register_type: holding
-    value_type: U_WORD
-    min_value: 0
-    max_value: 1000
-    step: 1
-    write_lambda: |-
-      // Legacy raw frame as words: [addr 0x01 | fc 0x06], register 0x0010, value.
-      payload.push_back(0x0106);
-      payload.push_back(0x0010);
-      payload.push_back((uint16_t) x);
-      return {};
-
-# Reports the server-side register so the test can observe that the deprecated buffer write landed.
-sensor:
-  - platform: template
-    name: "written_value"
-    id: written_value
-    update_interval: 0.5s
-    lambda: "return id(reg10);"
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # The test drives the writes via number_command; the mock is autostart.
@@ -1,95 +0,0 @@
-esphome:
-  name: uart-mock-modbus-lambda-invert
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: reg40
-    type: uint16_t
-    initial_value: "5"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    id: modbus_controller_1
-    update_interval: 1s
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x40
-        value_type: U_WORD
-        read_lambda: return id(reg40);
-        write_lambda: id(reg40) = x; return true;
-
-# An active-low holding switch: the write_lambda inverts the wire value, but the entity must still
-# report the REQUESTED state. assumed_state keeps the register unpolled, so the published state comes
-# only from write_state() - turning ON writes 0x0000 yet the switch shows ON.
-switch:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "invert_switch"
-    register_type: holding
-    address: 0x40
-    assumed_state: true
-    write_lambda: |-
-      return !x;
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_40"
-    address: 0x40
-    register_type: holding
-    value_type: U_WORD
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -1,97 +0,0 @@
-esphome:
-  name: uart-mock-modbus-lambda-write
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: reg30
-    type: uint16_t
-    initial_value: "0"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    id: modbus_controller_1
-    update_interval: 1s
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x30
-        value_type: U_WORD
-        read_lambda: return id(reg30);
-        write_lambda: id(reg30) = x; return true;
-
-# A COIL-type switch (assumed_state, write-only) whose write_lambda ignores its own coil type and instead
-# drives a HOLDING-REGISTER write on the mock server through the entity itself: `item` IS the command, so
-# item->write_single_register() sends a register write from a coil entity (cross-type). Returning nothing
-# (an empty optional) tells the write path the lambda already dispatched the frame - no default coil write.
-switch:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "cross_switch"
-    register_type: coil
-    address: 0x00
-    assumed_state: true
-    write_lambda: |-
-      item->write_single_register(0x30, x ? 1234 : 0);
-      return {};
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_30"
-    address: 0x30
-    register_type: holding
-    value_type: U_WORD
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -0,0 +1,233 @@
+esphome:
+  name: uart-mock-modbus-loopback
+
+host:
+api:
+logger:
+  level: VERBOSE
+
+external_components:
+  - source:
+      type: local
+      path: EXTERNAL_COMPONENT_PATH
+
+# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
+# The actual UART bus used is the uart_mock component below
+uart:
+  baud_rate: 115200
+  port: /dev/null
+
+# Shared loopback fixture (see the shared_yaml markers in the test file);
+# register spaces are disjoint so each test only observes its own entities.
+uart_mock:
+  - id: virtual_uart_server
+    baud_rate: 9600
+    auto_start: true
+    debug:
+    on_tx:
+      - then:
+          - uart_mock.inject_rx:
+              id: virtual_uart_controller
+              data: !lambda return data;
+  - id: virtual_uart_controller
+    baud_rate: 9600
+    auto_start: true
+    debug:
+    on_tx:
+      - then:
+          - uart_mock.inject_rx:
+              id: virtual_uart_server
+              data: !lambda return data;
+
+globals:
+  - id: reg10
+    type: uint16_t
+    initial_value: "100"
+  - id: reg11
+    type: uint16_t
+    initial_value: "200"
+  - id: reg12
+    type: uint16_t
+    initial_value: "300"
+  - id: reg13
+    type: uint16_t
+    initial_value: "0xABCD"
+  - id: reg30
+    type: uint16_t
+    initial_value: "0"
+  - id: reg40
+    type: uint16_t
+    initial_value: "5"
+  - id: reg50
+    type: uint16_t
+    initial_value: "0"
+
+modbus:
+  - uart_id: virtual_uart_server
+    id: virtual_modbus_server
+    role: server
+  - uart_id: virtual_uart_controller
+    id: virtual_modbus_controller
+    role: client
+    turnaround_time: 10ms
+
+modbus_controller:
+  - address: 1
+    modbus_id: virtual_modbus_controller
+    id: modbus_controller_1
+    update_interval: 1s
+
+modbus_server:
+  - address: 1
+    modbus_id: virtual_modbus_server
+    registers:
+      - address: 0x01
+        value_type: U_WORD
+        read_lambda: return 259;
+      - address: 0x10
+        value_type: U_WORD
+        read_lambda: return id(reg10);
+        write_lambda: id(reg10) = x; return true;
+      - address: 0x11
+        value_type: U_WORD
+        read_lambda: return id(reg11);
+        write_lambda: id(reg11) = x; return true;
+      - address: 0x12
+        value_type: U_WORD
+        read_lambda: return id(reg12);
+        write_lambda: id(reg12) = x; return true;
+      - address: 0x13
+        value_type: U_WORD
+        read_lambda: return id(reg13);
+      - address: 0x30
+        value_type: U_WORD
+        read_lambda: return id(reg30);
+        write_lambda: id(reg30) = x; return true;
+      - address: 0x40
+        value_type: U_WORD
+        read_lambda: return id(reg40);
+        write_lambda: id(reg40) = x; return true;
+      - address: 0x50
+        value_type: U_WORD
+        read_lambda: return id(reg50);
+        write_lambda: id(reg50) = x; return true;
+
+# Byte-based offset: 2 bytes -> register 0x11 (the old code folded it in as a
+# register count, hitting 0x12). assumed_state keeps the switch write-only.
+switch:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "offset_switch"
+    register_type: holding
+    address: 0x10
+    offset: 2
+    assumed_state: true
+  # Reading switch, byte offset 6 -> register 0x13; the pre-fix resolution (0x16)
+  # would draw ILLEGAL_DATA_ADDRESS and never publish.
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "read_offset_switch"
+    register_type: holding
+    address: 0x10
+    offset: 6
+    bitmask: 0x1
+  # Coil switch whose write_lambda dispatches a holding-register write via `item`;
+  # returning an empty optional suppresses the default coil write.
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "cross_switch"
+    register_type: coil
+    address: 0x00
+    assumed_state: true
+    write_lambda: |-
+      item->write_single_register(0x30, x ? 1234 : 0);
+      return {};
+  # Active-low: the write_lambda inverts the wire value but the entity must still
+  # report the requested state (assumed_state keeps the register unpolled).
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "invert_switch"
+    register_type: holding
+    address: 0x40
+    assumed_state: true
+    write_lambda: |-
+      return !x;
+
+# Uses the deprecated buffer parameter (legacy raw frame as words); the write
+# must land and the deprecation warning must fire only once per entity.
+number:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "buf_number"
+    id: buf_number
+    address: 0x50
+    register_type: holding
+    value_type: U_WORD
+    min_value: 0
+    max_value: 1000
+    step: 1
+    write_lambda: |-
+      // Legacy raw frame as words: [addr 0x01 | fc 0x06], register 0x0050, value.
+      payload.push_back(0x0106);
+      payload.push_back(0x0050);
+      payload.push_back((uint16_t) x);
+      return {};
+
+sensor:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "plain_read"
+    address: 0x01
+    register_type: holding
+    value_type: U_WORD
+  # Custom PDU: read holding register 0x0001; device address and CRC are added
+  # by the hub. The lambda parses the big-endian register value.
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "custom_read"
+    custom_pdu: [0x03, 0x00, 0x01, 0x00, 0x01]
+    lambda: |-
+      if (data.size() < 2) return {};
+      return (float) ((data[0] << 8) | data[1]);
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "reg_10"
+    address: 0x10
+    register_type: holding
+    value_type: U_WORD
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "reg_11"
+    address: 0x11
+    register_type: holding
+    value_type: U_WORD
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "reg_12"
+    address: 0x12
+    register_type: holding
+    value_type: U_WORD
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "reg_30"
+    address: 0x30
+    register_type: holding
+    value_type: U_WORD
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "reg_40"
+    address: 0x40
+    register_type: holding
+    value_type: U_WORD
+  # Reports the server-side register so the test can observe that the deprecated buffer write landed.
+  - platform: template
+    name: "written_value"
+    id: written_value
+    update_interval: 0.5s
+    lambda: "return id(reg50);"
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    id: start_scenario_btn
+    # Nothing to start (mock is autostart); tests drive entities directly
@@ -1,5 +1,5 @@
 esphome:
-  name: uart-mock-modbus-server-contro
+  name: uart-mock-modbus-mesh

 host:
 api:
@@ -17,13 +17,14 @@ uart:
  baud_rate: 115200
  port: /dev/null

+# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed read-only
+# registers, addr 5 = the read/write 0x17 target, addr 2/3 on the second
+# server hub. auto_start everywhere: the controller polls at boot, so the
+# forwarding must already be live or early requests generate warnings.
+# Every test presses Start Scenario, so all merged actions fire in every test.
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
    auto_start: true
    debug:
    on_tx:
@@ -31,35 +32,68 @@ uart_mock:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
-  - id: virtual_uart_controller
+          - uart_mock.inject_rx:
+              id: virtual_uart_server_2
+              data: !lambda return data;
+  - id: virtual_uart_server_2
    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
+    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
+          - uart_mock.inject_rx:
+              id: virtual_uart_controller
+              data: !lambda return data;
+  - id: virtual_uart_controller
+    baud_rate: 9600
+    auto_start: true
+    debug:
+    on_tx:
+      - then:
+          - uart_mock.inject_rx:
+              id: virtual_uart_server
+              data: !lambda return data;
+          - uart_mock.inject_rx:
+              id: virtual_uart_server_2
+              data: !lambda return data;
+
+globals:
+  - id: stored_1
+    type: uint16_t
+    initial_value: "0"

 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
+  - uart_id: virtual_uart_server_2
+    id: virtual_modbus_server_2
+    role: server
  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
+    id: virtual_modbus_client
    role: client
    turnaround_time: 10ms

 modbus_controller:
  - address: 1
-    modbus_id: virtual_modbus_controller
+    modbus_id: virtual_modbus_client
    id: modbus_controller_1
    update_interval: 1s
+  - address: 2
+    modbus_id: virtual_modbus_client
+    id: modbus_controller_2
+    update_interval: 1s
+  - address: 3
+    modbus_id: virtual_modbus_client
+    id: modbus_controller_3
+    update_interval: 1s

 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
-    id: modbus_server_1
    registers:
      - address: 0x01
        value_type: U_WORD
@@ -103,6 +137,34 @@ modbus_server:
      - address: 0x28
        value_type: FP32_R
        read_lambda: return 3.14;
+  - address: 5
+    modbus_id: virtual_modbus_server
+    registers:
+      # Writable + readable register: srv_write_1 plus the client's read-back
+      # confirm the write half of the 0x17 ran before the read half (Modbus 6.17).
+      - address: 0x01
+        value_type: U_WORD
+        read_lambda: return id(stored_1);
+        write_lambda: |-
+          id(stored_1) = x;
+          id(srv_write_1).publish_state(x);
+          return true;
+      # Read-only register, returned together with 0x01 by the 2-register read half.
+      - address: 0x02
+        value_type: U_WORD
+        read_lambda: return 0x00AA;
+  - address: 2
+    modbus_id: virtual_modbus_server_2
+    registers:
+      - address: 0x01
+        value_type: U_WORD
+        read_lambda: return 919;
+  - address: 3
+    modbus_id: virtual_modbus_server_2
+    registers:
+      - address: 0x01
+        value_type: U_WORD
+        read_lambda: return 929;

 sensor:
  - platform: modbus_controller
@@ -195,9 +257,46 @@ sensor:
    address: 0x28
    register_type: holding
    value_type: FP32_R
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_2
+    name: "multi_reg_a"
+    address: 0x01
+    register_type: holding
+    value_type: U_WORD
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_3
+    name: "multi_reg_b"
+    address: 0x01
+    register_type: holding
+    value_type: U_WORD
+  # client_read_write observations, server- and client-side.
+  - platform: template
+    name: "srv_write_1"
+    id: srv_write_1
+  - platform: template
+    name: "client_read_0"
+    id: client_read_0
+  - platform: template
+    name: "client_read_1"
+    id: client_read_1

 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
+    on_press:
+      # FC 0x17: write reg 0x0001 = 0x1234, then read regs 0x0001..0x0002 back in the same transaction.
+      - modbus_client.read_write_multiple_registers:
+          address: 5
+          read_address: 0x0001
+          read_count: 2
+          write_address: 0x0001
+          values: [0x1234]
+          on_response:
+            then:
+              - lambda: |-
+                  // values is the read-back block: reg 0x0001 (must be the just-written 0x1234) and reg 0x0002.
+                  if (values.size() >= 2) {
+                    id(client_read_0).publish_state(values[0]);
+                    id(client_read_1).publish_state(values[1]);
+                  }
@@ -1,138 +0,0 @@
-esphome:
-  name: uart-mock-modbus-reg-offset
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: reg10
-    type: uint16_t
-    initial_value: "100"
-  - id: reg11
-    type: uint16_t
-    initial_value: "200"
-  - id: reg12
-    type: uint16_t
-    initial_value: "300"
-  - id: reg13
-    type: uint16_t
-    initial_value: "0xABCD"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    id: modbus_controller_1
-    update_interval: 1s
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x10
-        value_type: U_WORD
-        read_lambda: return id(reg10);
-        write_lambda: id(reg10) = x; return true;
-      - address: 0x11
-        value_type: U_WORD
-        read_lambda: return id(reg11);
-        write_lambda: id(reg11) = x; return true;
-      - address: 0x12
-        value_type: U_WORD
-        read_lambda: return id(reg12);
-        write_lambda: id(reg12) = x; return true;
-      - address: 0x13
-        value_type: U_WORD
-        read_lambda: return id(reg13);
-        write_lambda: id(reg13) = x; return true;
-
-# A holding-register switch at 0x10 with a 2-BYTE offset. offset is byte-based, so the write must target
-# register 0x10 + 2/2 = 0x11. The old (pre-fix) behavior folded offset into the address as a register
-# count, hitting 0x12 instead. assumed_state keeps the switch write-only so it does not read any register.
-switch:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "offset_switch"
-    register_type: holding
-    address: 0x10
-    offset: 2
-    assumed_state: true
-  # A holding-register switch that READS its state. Byte offset 6 -> register 0x10 + 6/2 = 0x13. Post-fix
-  # the switch itself resolves to 0x13 (the even byte offset folds into the address as whole registers) and
-  # joins the 0x10..0x13 range, so no separate 0x13 sensor is needed. Pre-fix the whole byte offset folds
-  # into the address (0x16), where the server answers ILLEGAL_DATA_ADDRESS and the switch never publishes.
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "read_offset_switch"
-    register_type: holding
-    address: 0x10
-    offset: 6
-    bitmask: 0x1
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_10"
-    address: 0x10
-    register_type: holding
-    value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_11"
-    address: 0x11
-    register_type: holding
-    value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_12"
-    address: 0x12
-    register_type: holding
-    value_type: U_WORD
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -1,124 +0,0 @@
-esphome:
-  name: uart-mock-modbus-server-test
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_dev
-    baud_rate: 9600
-    rx_full_threshold: 120
-    rx_timeout: 2
-    auto_start: false
-    debug:
-    injections:
-      - delay: 100ms
-        inject_rx: [0x01, 0x03, 0x00, 0x03, 0x00, 0x01, 0x74, 0x0A] #  Read holding register 3 on device 1 (basic_read)
-      - delay: 100ms
-        #  Read holding register 7 on device 2
-        #  Reply from device 2
-        #  Read holding register 5 on device 1 (read_after_peer_response)
-        inject_rx:
-          [
-            0x02,
-            0x03,
-            0x00,
-            0x07,
-            0x00,
-            0x01,
-            0x35,
-            0xF8,
-            0x02,
-            0x03,
-            0x02,
-            0x00,
-            0xF0,
-            0xFC,
-            0x00,
-            0x01,
-            0x03,
-            0x00,
-            0x05,
-            0x00,
-            0x01,
-            0x94,
-            0x0B,
-          ]
-      - delay: 100ms
-        inject_rx: [0x02, 0x03, 0x00, 0x07, 0x00, 0x01, 0x35, 0xF8] #  Read holding register 7 on device 2, with no response
-      - delay: 100ms
-        #  Read holding register 7 on device 2, with no response
-        #  Read holding register A on device 1 (read_after_peer_timeout)
-        inject_rx:
-          [
-            0x02,
-            0x03,
-            0x00,
-            0x07,
-            0x00,
-            0x01,
-            0x35,
-            0xF8,
-            0x01,
-            0x03,
-            0x00,
-            0x0A,
-            0x00,
-            0x01,
-            0xA4,
-            0x08,
-          ]
-
-modbus:
-  uart_id: virtual_uart_dev
-  role: server
-
-modbus_server:
-  - address: 1
-    registers:
-      - address: 0x03
-        value_type: U_WORD
-        read_lambda: |-
-          id(basic_read).publish_state(1);
-          return 1;
-      - address: 0x05
-        value_type: U_WORD
-        read_lambda: |-
-          id(read_after_peer_response).publish_state(1);
-          return 1;
-      - address: 0x0A
-        value_type: U_WORD
-        read_lambda: |-
-          id(read_after_peer_timeout).publish_state(1);
-          return 1;
-
-sensor:
-  - platform: template
-    name: "basic_read"
-    id: basic_read
-  - platform: template
-    name: "read_after_peer_response"
-    id: read_after_peer_response
-  - platform: template
-    name: "read_after_peer_timeout"
-    id: read_after_peer_timeout
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    on_press:
-      - lambda: "id(virtual_uart_dev).start_scenario();"
@@ -1,116 +0,0 @@
-esphome:
-  name: uart-mock-modbus-server-mult
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-          - uart_mock.inject_rx:
-              id: virtual_uart_server_2
-              data: !lambda return data;
-  - id: virtual_uart_server_2
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-          - uart_mock.inject_rx:
-              id: virtual_uart_server_2
-              data: !lambda return data;
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_server_2
-    id: virtual_modbus_server_2
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_client
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_client
-    update_interval: 1s
-    id: modbus_controller_1
-  - address: 2
-    modbus_id: virtual_modbus_client
-    update_interval: 1s
-    id: modbus_controller_2
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    registers:
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: return 919;
-  - address: 2
-    modbus_id: virtual_modbus_server_2
-    registers:
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: return 929;
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_2
-    name: "reg_u_word_2"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -1,5 +1,5 @@
 esphome:
-  name: uart-mock-modbus-srv-rw
+  name: uart-mock-modbus-srv-injected

 host:
 api:
@@ -17,6 +17,8 @@ uart:
  baud_rate: 115200
  port: /dev/null

+# Shared server-role fixture (see the shared_yaml markers in the test file);
+# the injections concatenate and each test waits only on its own sensors.
 uart_mock:
  - id: virtual_uart_dev
    baud_rate: 9600
@@ -25,18 +27,31 @@ uart_mock:
    auto_start: false
    debug:
    injections:
-      # FC 0x17 Read/Write Multiple Registers on device 1:
-      #   write reg 0x0001 = 0x1234 (qty 1), then read regs 0x0001..0x0002 (qty 2).
-      # Per Modbus 6.17 the write is performed before the read, so reg 0x0001 must
-      # read back the just-written 0x1234 in the same request.
+      - delay: 100ms
+        inject_rx: [0x01, 0x03, 0x00, 0x03, 0x00, 0x01, 0x74, 0x0A] #  Read holding register 3 on device 1 (basic_read)
+      - delay: 100ms
+        #  Read holding register 7 on device 2, its reply, then read holding
+        #  register 5 on device 1 (read_after_peer_response)
+        inject_rx: [0x02, 0x03, 0x00, 0x07, 0x00, 0x01, 0x35, 0xF8,
+                    0x02, 0x03, 0x02, 0x00, 0xF0, 0xFC,
+                    0x00, 0x01, 0x03, 0x00, 0x05, 0x00, 0x01, 0x94, 0x0B]
+      - delay: 100ms
+        inject_rx: [0x02, 0x03, 0x00, 0x07, 0x00, 0x01, 0x35, 0xF8] #  Read holding register 7 on device 2, with no response
+      - delay: 100ms
+        #  Read holding register 7 on device 2 with no response, then read
+        #  holding register A on device 1 (read_after_peer_timeout)
+        inject_rx: [0x02, 0x03, 0x00, 0x07, 0x00, 0x01, 0x35, 0xF8,
+                    0x01, 0x03, 0x00, 0x0A, 0x00, 0x01, 0xA4, 0x08]
+      # FC 0x17 on device 1: write reg 0x0001 = 0x1234 then read 0x0001..0x0002;
+      # per Modbus 6.17 the write runs first, so 0x0001 must read back 0x1234.
      - delay: 100ms
        inject_rx:
          [0x01, 0x17, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x02, 0x12, 0x34, 0x49, 0xD8]
-      # FC 0x17: write reg 0x0003 = 0x5678 (qty 1), then read reg 0x0003 (qty 1) -
+      # FC 0x17: write reg 0x0006 = 0x5678 (qty 1), then read reg 0x0006 (qty 1) -
      # a write and read targeting a different register block.
      - delay: 100ms
        inject_rx:
-          [0x01, 0x17, 0x00, 0x03, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x02, 0x56, 0x78, 0x9B, 0x10]
+          [0x01, 0x17, 0x00, 0x06, 0x00, 0x01, 0x00, 0x06, 0x00, 0x01, 0x02, 0x56, 0x78, 0x8B, 0x55]

 globals:
  - id: stored_1
@@ -70,8 +85,18 @@ modbus_server:
        read_lambda: |-
          id(rw_read_2).publish_state(0x00AA);
          return 0x00AA;
-      # Second writable + readable register, targeted by the second request.
      - address: 0x03
+        value_type: U_WORD
+        read_lambda: |-
+          id(basic_read).publish_state(1);
+          return 1;
+      - address: 0x05
+        value_type: U_WORD
+        read_lambda: |-
+          id(read_after_peer_response).publish_state(1);
+          return 1;
+      # Second writable + readable register, targeted by the second FC 0x17 request.
+      - address: 0x06
        value_type: U_WORD
        read_lambda: |-
          id(rw_read_3).publish_state(id(stored_3));
@@ -80,8 +105,22 @@ modbus_server:
          id(stored_3) = x;
          id(rw_write_3).publish_state(x);
          return true;
+      - address: 0x0A
+        value_type: U_WORD
+        read_lambda: |-
+          id(read_after_peer_timeout).publish_state(1);
+          return 1;

 sensor:
+  - platform: template
+    name: "basic_read"
+    id: basic_read
+  - platform: template
+    name: "read_after_peer_response"
+    id: read_after_peer_response
+  - platform: template
+    name: "read_after_peer_timeout"
+    id: read_after_peer_timeout
  - platform: template
    name: "rw_write_1"
    id: rw_write_1
@@ -1,7 +1,7 @@
 """Helpers for manipulating the host platform's preferences file.

 ESPHome's host platform stores preferences in
-``~/.esphome/prefs/<app_name>.prefs`` using a simple binary layout that
+``$ESPHOME_PREFDIR/<app_name>.prefs`` using a simple binary layout that
 mirrors ``HostPreferences::sync()``:
 ``[uint32_t key][uint8_t len][uint8_t data[len]]`` per entry.

@@ -11,13 +11,21 @@ boot (e.g. forcing safe mode) or to clear stale state between runs.

 from __future__ import annotations

+import os
 from pathlib import Path
 import struct


 def host_prefs_path(device_name: str) -> Path:
-    """Return the on-disk prefs file path for a host-platform device."""
-    return Path.home() / ".esphome" / "prefs" / f"{device_name}.prefs"
+    """Return the on-disk prefs file path for a host-platform device.
+
+    Requires ESPHOME_PREFDIR, which the autouse isolated_preferences fixture
+    sets; refusing the ~/.esphome/prefs fallback keeps tests off real user
+    data if the fixture is ever bypassed."""
+    prefdir = os.environ.get("ESPHOME_PREFDIR")
+    if not prefdir:
+        raise RuntimeError("ESPHOME_PREFDIR is not set; refusing the real prefs dir")
+    return Path(prefdir) / f"{device_name}.prefs"


 def clear_host_prefs(device_name: str) -> None:
@@ -1,143 +1,154 @@
 {
-  "tests/integration/test_action_concurrent_reentry.py": 57.91,
-  "tests/integration/test_addressable_light_transition.py": 21.25,
-  "tests/integration/test_alarm_control_panel_state_transitions.py": 70.71,
-  "tests/integration/test_api_action_metadata.py": 66.6,
-  "tests/integration/test_api_action_responses.py": 36.1,
-  "tests/integration/test_api_action_timeout.py": 68.86,
-  "tests/integration/test_api_conditional_memory.py": 15.48,
-  "tests/integration/test_api_custom_services.py": 18.77,
-  "tests/integration/test_api_get_time_response_timezone.py": 21.08,
-  "tests/integration/test_api_homeassistant.py": 65.59,
-  "tests/integration/test_api_homeassistant_action_no_subscriber.py": 18.44,
-  "tests/integration/test_api_homeassistant_binary_sensor_initial_state.py": 15.05,
-  "tests/integration/test_api_list_entities_backpressure.py": 13.88,
-  "tests/integration/test_api_message_size_batching.py": 29.98,
-  "tests/integration/test_api_reboot_timeout.py": 16.05,
-  "tests/integration/test_api_string_lambda.py": 15.31,
-  "tests/integration/test_api_vv_logging.py": 19.28,
-  "tests/integration/test_api_zero_psk_provisioning.py": 31.5,
-  "tests/integration/test_areas_and_devices.py": 24.95,
-  "tests/integration/test_automation_wait_actions.py": 20.92,
-  "tests/integration/test_automations.py": 35.19,
-  "tests/integration/test_batch_delay_zero_rapid_transitions.py": 17.99,
-  "tests/integration/test_binary_sensor_autorepeat_filter.py": 20.39,
-  "tests/integration/test_binary_sensor_invalidate_state.py": 18.41,
-  "tests/integration/test_blocking_warning_log_time_not_charged_to_next_operation.py": 24.69,
-  "tests/integration/test_build_info.py": 18.7,
-  "tests/integration/test_camera_mock.py": 16.23,
-  "tests/integration/test_climate_control_action.py": 21.14,
-  "tests/integration/test_climate_custom_modes.py": 20.74,
-  "tests/integration/test_continuation_actions.py": 16.81,
-  "tests/integration/test_cover_control_action.py": 20.34,
-  "tests/integration/test_crc8_helper.py": 9.36,
-  "tests/integration/test_device_id_in_state.py": 44.67,
-  "tests/integration/test_duplicate_entities.py": 23.58,
-  "tests/integration/test_entity_icon.py": 34.35,
-  "tests/integration/test_fan_turn_on_action.py": 24.23,
-  "tests/integration/test_fnv1_hash_object_id.py": 16.21,
-  "tests/integration/test_fnv1a_hash.py": 13.38,
-  "tests/integration/test_gpio_expander_cache.py": 13.06,
-  "tests/integration/test_host_logger_thread_safety.py": 23.66,
-  "tests/integration/test_host_mode_basic.py": 8.01,
-  "tests/integration/test_host_mode_batch_delay.py": 21.0,
-  "tests/integration/test_host_mode_climate_basic_state.py": 22.14,
-  "tests/integration/test_host_mode_climate_control.py": 19.39,
-  "tests/integration/test_host_mode_empty_string_options.py": 21.76,
-  "tests/integration/test_host_mode_entity_fields.py": 29.61,
-  "tests/integration/test_host_mode_fan_preset.py": 20.01,
-  "tests/integration/test_host_mode_many_entities.py": 39.08,
-  "tests/integration/test_host_mode_many_entities_multiple_connections.py": 23.92,
-  "tests/integration/test_host_mode_noise_encryption.py": 42.42,
-  "tests/integration/test_host_mode_reconnect.py": 3.41,
-  "tests/integration/test_host_mode_sensor.py": 22.96,
-  "tests/integration/test_host_ota.py": 29.5,
-  "tests/integration/test_host_preferences.py": 16.06,
-  "tests/integration/test_host_preferences_suspend_resume.py": 18.71,
-  "tests/integration/test_improv_serial_uart.py": 20.22,
-  "tests/integration/test_large_message_batching.py": 26.56,
-  "tests/integration/test_legacy_area.py": 22.72,
-  "tests/integration/test_legacy_climate_compat.py": 14.13,
-  "tests/integration/test_legacy_fan_compat.py": 14.33,
-  "tests/integration/test_light_automations.py": 18.81,
-  "tests/integration/test_light_binary_effect_off_phase.py": 8.38,
-  "tests/integration/test_light_calls.py": 21.88,
-  "tests/integration/test_light_constant_brightness.py": 59.45,
-  "tests/integration/test_light_control_action.py": 31.91,
-  "tests/integration/test_light_dim_relative_action.py": 14.43,
-  "tests/integration/test_light_effect_zero_brightness.py": 25.05,
-  "tests/integration/test_light_initial_state.py": 18.97,
-  "tests/integration/test_light_toggle_action.py": 17.44,
-  "tests/integration/test_lock_automations.py": 18.9,
-  "tests/integration/test_logger_buffered_recursion_guard.py": 18.2,
-  "tests/integration/test_loop_disable_enable.py": 63.35,
-  "tests/integration/test_loop_interval_decoupling.py": 17.7,
-  "tests/integration/test_loop_interval_default_not_pulled_forward.py": 21.56,
-  "tests/integration/test_micros_to_millis.py": 15.89,
-  "tests/integration/test_multi_click_trigger.py": 17.23,
-  "tests/integration/test_multi_device_preferences.py": 19.4,
-  "tests/integration/test_noise_encryption_key_protection.py": 72.59,
-  "tests/integration/test_object_id_api_verification.py": 19.22,
-  "tests/integration/test_object_id_friendly_name_no_mac_suffix.py": 16.77,
-  "tests/integration/test_object_id_no_friendly_name.py": 45.8,
-  "tests/integration/test_online_image_auto_detects_image_bmp_mime.py": 86.73,
-  "tests/integration/test_online_image_auto_detects_redirected_image_bmp_mime.py": 40.4,
-  "tests/integration/test_online_image_bmp.py": 37.24,
-  "tests/integration/test_oversized_payloads.py": 55.75,
-  "tests/integration/test_preference_key_stability.py": 25.49,
-  "tests/integration/test_runtime_stats.py": 29.81,
-  "tests/integration/test_safe_mode_loop_runs.py": 6.26,
-  "tests/integration/test_scheduler_blocking_warning.py": 37.98,
-  "tests/integration/test_scheduler_bulk_cleanup.py": 18.67,
-  "tests/integration/test_scheduler_defer_cancel.py": 18.46,
-  "tests/integration/test_scheduler_defer_cancel_regular.py": 16.34,
-  "tests/integration/test_scheduler_defer_fifo_simple.py": 18.26,
-  "tests/integration/test_scheduler_defer_stress.py": 17.74,
-  "tests/integration/test_scheduler_heap_stress.py": 3.89,
-  "tests/integration/test_scheduler_internal_id_no_collision.py": 20.01,
-  "tests/integration/test_scheduler_interval_reschedule.py": 16.29,
-  "tests/integration/test_scheduler_interval_zero_coerced.py": 16.09,
-  "tests/integration/test_scheduler_null_name.py": 14.69,
-  "tests/integration/test_scheduler_numeric_id_test.py": 17.08,
-  "tests/integration/test_scheduler_pool.py": 19.88,
-  "tests/integration/test_scheduler_rapid_cancellation.py": 4.42,
-  "tests/integration/test_scheduler_recursive_timeout.py": 4.3,
-  "tests/integration/test_scheduler_removed_item_race.py": 15.49,
-  "tests/integration/test_scheduler_self_keyed.py": 25.77,
-  "tests/integration/test_scheduler_simultaneous_callbacks.py": 14.84,
-  "tests/integration/test_scheduler_string_test.py": 15.42,
-  "tests/integration/test_script_array_params.py": 12.73,
-  "tests/integration/test_script_delay_params.py": 12.69,
-  "tests/integration/test_script_queued.py": 20.38,
-  "tests/integration/test_script_queued_idle_loop.py": 25.06,
-  "tests/integration/test_script_wait_on_boot.py": 15.67,
-  "tests/integration/test_select_stringref_trigger.py": 19.48,
-  "tests/integration/test_sensor_filters_delta.py": 27.62,
-  "tests/integration/test_sensor_filters_ring_buffer.py": 20.27,
-  "tests/integration/test_sensor_filters_sliding_window.py": 56.28,
-  "tests/integration/test_sensor_filters_value_list.py": 20.6,
-  "tests/integration/test_sensor_timeout_filter.py": 22.21,
-  "tests/integration/test_socket_wake_gate_tcp.py": 16.37,
-  "tests/integration/test_status_flags.py": 29.68,
-  "tests/integration/test_strftime_to.py": 17.42,
-  "tests/integration/test_syslog.py": 18.39,
-  "tests/integration/test_template_alarm_control_panel_many_sensors.py": 25.61,
-  "tests/integration/test_template_text_save.py": 19.16,
-  "tests/integration/test_text_command.py": 16.43,
-  "tests/integration/test_text_sensor_raw_state.py": 17.19,
-  "tests/integration/test_uart_mock_ld2410.py": 37.0,
-  "tests/integration/test_uart_mock_ld2412.py": 40.82,
-  "tests/integration/test_uart_mock_ld2420.py": 32.7,
-  "tests/integration/test_uart_mock_ld2450.py": 32.84,
-  "tests/integration/test_uart_mock_modbus.py": 548.87,
-  "tests/integration/test_udp.py": 16.67,
-  "tests/integration/test_use_address_runtime.py": 27.26,
-  "tests/integration/test_valve_control_action.py": 24.58,
-  "tests/integration/test_varint_five_byte_device_id.py": 22.5,
-  "tests/integration/test_wait_until_mid_loop_timing.py": 22.05,
-  "tests/integration/test_wait_until_on_boot.py": 10.37,
-  "tests/integration/test_wait_until_ordering.py": 18.23,
-  "tests/integration/test_wait_until_reentrant_restart.py": 19.35,
-  "tests/integration/test_wake_loop_forces_phase_b.py": 17.83,
-  "tests/integration/test_water_heater_template.py": 25.7
+  "tests/integration/test_action_concurrent_reentry.py": 30.48,
+  "tests/integration/test_addressable_light_transition.py": 42.1,
+  "tests/integration/test_alarm_control_panel_state_transitions.py": 35.76,
+  "tests/integration/test_api_action_metadata.py": 22.35,
+  "tests/integration/test_api_action_responses.py": 30.31,
+  "tests/integration/test_api_action_timeout.py": 34.73,
+  "tests/integration/test_api_conditional_memory.py": 18.35,
+  "tests/integration/test_api_custom_services.py": 15.99,
+  "tests/integration/test_api_get_time_response_timezone.py": 24.21,
+  "tests/integration/test_api_homeassistant.py": 33.77,
+  "tests/integration/test_api_homeassistant_action_no_subscriber.py": 20.8,
+  "tests/integration/test_api_homeassistant_binary_sensor_initial_state.py": 23.55,
+  "tests/integration/test_api_list_entities_backpressure.py": 23.04,
+  "tests/integration/test_api_message_size_batching.py": 27.31,
+  "tests/integration/test_api_reboot_timeout.py": 29.32,
+  "tests/integration/test_api_string_lambda.py": 14.9,
+  "tests/integration/test_api_vv_logging.py": 26.25,
+  "tests/integration/test_api_zero_psk_provisioning.py": 38.19,
+  "tests/integration/test_areas_and_devices.py": 27.52,
+  "tests/integration/test_automation_wait_actions.py": 24.25,
+  "tests/integration/test_automations.py": 36.02,
+  "tests/integration/test_batch_delay_zero_rapid_transitions.py": 18.46,
+  "tests/integration/test_binary_sensor_autorepeat_filter.py": 17.47,
+  "tests/integration/test_binary_sensor_invalidate_state.py": 14.79,
+  "tests/integration/test_blocking_warning_log_time_not_charged_to_next_operation.py": 21.52,
+  "tests/integration/test_build_info.py": 21.42,
+  "tests/integration/test_camera_mock.py": 17.02,
+  "tests/integration/test_climate_control_action.py": 26.56,
+  "tests/integration/test_climate_custom_modes.py": 18.82,
+  "tests/integration/test_continuation_actions.py": 20.39,
+  "tests/integration/test_cover_control_action.py": 19.91,
+  "tests/integration/test_crc8_helper.py": 16.73,
+  "tests/integration/test_device_id_in_state.py": 58.41,
+  "tests/integration/test_duplicate_entities.py": 30.76,
+  "tests/integration/test_entity_icon.py": 25.34,
+  "tests/integration/test_fan_turn_on_action.py": 23.64,
+  "tests/integration/test_fnv1_hash_object_id.py": 25.44,
+  "tests/integration/test_fnv1a_hash.py": 20.85,
+  "tests/integration/test_gpio_expander_cache.py": 14.42,
+  "tests/integration/test_host_logger_thread_safety.py": 21.31,
+  "tests/integration/test_host_mode_basic.py": 2.65,
+  "tests/integration/test_host_mode_batch_delay.py": 22.21,
+  "tests/integration/test_host_mode_climate_basic_state.py": 27.12,
+  "tests/integration/test_host_mode_climate_control.py": 21.57,
+  "tests/integration/test_host_mode_empty_string_options.py": 27.17,
+  "tests/integration/test_host_mode_entity_fields.py": 30.1,
+  "tests/integration/test_host_mode_fan_preset.py": 17.55,
+  "tests/integration/test_host_mode_many_entities.py": 38.98,
+  "tests/integration/test_host_mode_many_entities_multiple_connections.py": 23.82,
+  "tests/integration/test_host_mode_noise_encryption.py": 39.84,
+  "tests/integration/test_host_mode_reconnect.py": 13.1,
+  "tests/integration/test_host_mode_sensor.py": 22.17,
+  "tests/integration/test_host_ota.py": 92.05,
+  "tests/integration/test_host_preferences.py": 20.29,
+  "tests/integration/test_host_preferences_suspend_resume.py": 15.02,
+  "tests/integration/test_improv_serial_uart.py": 30.15,
+  "tests/integration/test_large_message_batching.py": 25.84,
+  "tests/integration/test_legacy_area.py": 21.24,
+  "tests/integration/test_legacy_climate_compat.py": 17.34,
+  "tests/integration/test_legacy_fan_compat.py": 22.6,
+  "tests/integration/test_light_automations.py": 29.13,
+  "tests/integration/test_light_binary_effect_off_phase.py": 33.99,
+  "tests/integration/test_light_calls.py": 26.81,
+  "tests/integration/test_light_constant_brightness.py": 25.0,
+  "tests/integration/test_light_control_action.py": 25.57,
+  "tests/integration/test_light_dim_relative_action.py": 21.4,
+  "tests/integration/test_light_effect_zero_brightness.py": 19.65,
+  "tests/integration/test_light_initial_state.py": 17.58,
+  "tests/integration/test_light_toggle_action.py": 28.28,
+  "tests/integration/test_lock_automations.py": 23.3,
+  "tests/integration/test_logger_buffered_recursion_guard.py": 22.96,
+  "tests/integration/test_loop_disable_enable.py": 16.18,
+  "tests/integration/test_loop_interval_decoupling.py": 25.19,
+  "tests/integration/test_loop_interval_default_not_pulled_forward.py": 20.59,
+  "tests/integration/test_lvgl_headless_render.py": 87.78,
+  "tests/integration/test_micros_to_millis.py": 18.73,
+  "tests/integration/test_multi_click_trigger.py": 24.2,
+  "tests/integration/test_multi_device_preferences.py": 20.52,
+  "tests/integration/test_noise_encryption_key_protection.py": 19.1,
+  "tests/integration/test_object_id_api_verification.py": 26.24,
+  "tests/integration/test_object_id_friendly_name_no_mac_suffix.py": 14.88,
+  "tests/integration/test_object_id_no_friendly_name.py": 61.27,
+  "tests/integration/test_online_image_auto_detects_image_bmp_mime.py": 82.32,
+  "tests/integration/test_online_image_auto_detects_redirected_image_bmp_mime.py": 46.03,
+  "tests/integration/test_online_image_bmp.py": 34.21,
+  "tests/integration/test_oversized_payloads.py": 62.75,
+  "tests/integration/test_preference_key_stability.py": 26.8,
+  "tests/integration/test_runtime_stats.py": 28.26,
+  "tests/integration/test_safe_mode_loop_runs.py": 18.14,
+  "tests/integration/test_scheduler_blocking_warning.py": 28.7,
+  "tests/integration/test_scheduler_bulk_cleanup.py": 20.73,
+  "tests/integration/test_scheduler_defer_cancel.py": 22.99,
+  "tests/integration/test_scheduler_defer_cancel_regular.py": 21.97,
+  "tests/integration/test_scheduler_defer_fifo_simple.py": 24.15,
+  "tests/integration/test_scheduler_defer_stress.py": 23.11,
+  "tests/integration/test_scheduler_heap_stress.py": 20.2,
+  "tests/integration/test_scheduler_internal_id_no_collision.py": 23.75,
+  "tests/integration/test_scheduler_interval_reschedule.py": 15.32,
+  "tests/integration/test_scheduler_interval_zero_coerced.py": 20.1,
+  "tests/integration/test_scheduler_null_name.py": 17.43,
+  "tests/integration/test_scheduler_numeric_id_test.py": 25.51,
+  "tests/integration/test_scheduler_pool.py": 24.22,
+  "tests/integration/test_scheduler_rapid_cancellation.py": 24.01,
+  "tests/integration/test_scheduler_recursive_timeout.py": 22.94,
+  "tests/integration/test_scheduler_removed_item_race.py": 23.07,
+  "tests/integration/test_scheduler_self_keyed.py": 18.43,
+  "tests/integration/test_scheduler_simultaneous_callbacks.py": 21.99,
+  "tests/integration/test_scheduler_string_test.py": 17.27,
+  "tests/integration/test_script_array_params.py": 4.59,
+  "tests/integration/test_script_delay_params.py": 22.46,
+  "tests/integration/test_script_queued.py": 25.24,
+  "tests/integration/test_script_queued_idle_loop.py": 5.04,
+  "tests/integration/test_script_wait_on_boot.py": 21.77,
+  "tests/integration/test_sdl_headless_screenshot.py": 19.23,
+  "tests/integration/test_select_stringref_trigger.py": 19.31,
+  "tests/integration/test_sensor_filters_delta.py": 25.92,
+  "tests/integration/test_sensor_filters_ring_buffer.py": 22.39,
+  "tests/integration/test_sensor_filters_sliding_window.py": 57.93,
+  "tests/integration/test_sensor_filters_value_list.py": 20.32,
+  "tests/integration/test_sensor_timeout_filter.py": 25.35,
+  "tests/integration/test_snapshot_display.py": 19.7,
+  "tests/integration/test_socket_wake_gate_tcp.py": 14.5,
+  "tests/integration/test_status_flags.py": 33.83,
+  "tests/integration/test_strftime_to.py": 17.64,
+  "tests/integration/test_syslog.py": 24.49,
+  "tests/integration/test_template_alarm_control_panel_many_sensors.py": 24.81,
+  "tests/integration/test_template_climate_basic.py": 15.28,
+  "tests/integration/test_template_climate_custom_modes.py": 25.07,
+  "tests/integration/test_template_climate_nonoptimistic.py": 24.25,
+  "tests/integration/test_template_climate_on_control_ordering.py": 24.09,
+  "tests/integration/test_template_climate_publish_all_fields.py": 17.78,
+  "tests/integration/test_template_climate_sensor_push.py": 17.42,
+  "tests/integration/test_template_climate_set_actions.py": 23.63,
+  "tests/integration/test_template_climate_two_point_temperature.py": 25.19,
+  "tests/integration/test_template_text_save.py": 17.88,
+  "tests/integration/test_text_command.py": 22.71,
+  "tests/integration/test_text_sensor_raw_state.py": 25.17,
+  "tests/integration/test_uart_mock_ld2410.py": 58.15,
+  "tests/integration/test_uart_mock_ld2412.py": 61.14,
+  "tests/integration/test_uart_mock_ld2420.py": 33.87,
+  "tests/integration/test_uart_mock_ld2450.py": 26.06,
+  "tests/integration/test_uart_mock_modbus.py": 391.79,
+  "tests/integration/test_udp.py": 7.38,
+  "tests/integration/test_use_address_runtime.py": 24.09,
+  "tests/integration/test_valve_control_action.py": 23.22,
+  "tests/integration/test_varint_five_byte_device_id.py": 17.93,
+  "tests/integration/test_wait_until_mid_loop_timing.py": 22.26,
+  "tests/integration/test_wait_until_on_boot.py": 17.46,
+  "tests/integration/test_wait_until_ordering.py": 11.89,
+  "tests/integration/test_wait_until_reentrant_restart.py": 22.88,
+  "tests/integration/test_wake_loop_forces_phase_b.py": 16.6,
+  "tests/integration/test_water_heater_template.py": 19.66
 }
@@ -24,7 +24,6 @@ from .types import (
    RunCompiledFunction,
 )

-pytestmark = pytest.mark.usefixtures("isolated_preferences")
 NEW_KEY = PROVISIONING_PSK


@@ -41,15 +41,6 @@ async def _poll_until_exists(path: Path) -> None:
        await asyncio.sleep(0.05)


-@pytest.fixture(autouse=True)
-def isolated_preferences(monkeypatch: pytest.MonkeyPatch, tmp_path) -> Path:
-    """Keep host preferences per-test so this test never touches the real
-    ~/.esphome/prefs and never races other tests over ESPHOME_PREFDIR."""
-    prefdir = tmp_path / "prefs"
-    monkeypatch.setenv("ESPHOME_PREFDIR", str(prefdir))
-    return prefdir / f"{DEVICE_NAME}.prefs"
-
-
@pytest.mark.asyncio
 async def test_host_preferences_suspend_resume(
    yaml_config: str,
@@ -58,7 +49,7 @@ async def test_host_preferences_suspend_resume(
    isolated_preferences: Path,
 ) -> None:
    """Test that a running syncer flushes, a suspended one doesn't, and resume restores flushing."""
-    pref_file = isolated_preferences
+    pref_file = isolated_preferences / f"{DEVICE_NAME}.prefs"

    loop = asyncio.get_running_loop()
    saved_in_memory = loop.create_future()
@@ -11,14 +11,6 @@ from .state_utils import InitialStateHelper, require_entity
 from .types import APIClientConnectedFactory, RunCompiledFunction


-@pytest.fixture(autouse=True)
-def isolated_preferences(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
-    """Keep host preferences per-test so RESTORE_AND_ON never loads a stale value left
-    behind by a previous run (host preferences otherwise persist to ~/.esphome/prefs,
-    keyed only by device name)."""
-    monkeypatch.setenv("ESPHOME_PREFDIR", str(tmp_path / "prefs"))
-
-
@pytest.mark.asyncio
 async def test_light_initial_state(
    yaml_config: str,
@@ -0,0 +1,41 @@
+"""Integration test for set_internal() called during and after setup."""
+
+from __future__ import annotations
+
+import pytest
+
+from .log_utils import LineWaiter
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_set_internal_at_boot(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """set_internal() in on_boot changes API exposure, later calls log an error."""
+    waiter = LineWaiter()
+
+    async with (
+        run_compiled(yaml_config, line_callback=waiter.callback),
+        api_client_connected() as client,
+    ):
+        entities, services = await client.list_entities_services()
+        names = {entity.name for entity in entities}
+
+        assert "Hidden At Boot" not in names
+        assert "Shown At Boot" in names
+        assert "Untouched" in names
+
+        late = next(s for s in services if s.name == "set_internal_late")
+        await client.execute_service(late, {})
+        await waiter.wait_for(
+            "'Untouched'",
+            "set_internal() after setup is undefined behavior",
+            timeout=5.0,
+        )
+
+        # Still written during the deprecation window, ignored from 2027.3.0
+        entities, _ = await client.list_entities_services()
+        assert "Untouched" not in {entity.name for entity in entities}
@@ -173,6 +173,7 @@ async def test_uart_mock_modbus_no_threshold(
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_server_injected")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_server(
    yaml_config: str,
@@ -203,6 +204,7 @@ async def test_uart_mock_modbus_server(
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_server_injected")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_server_read_write(
    yaml_config: str,
@@ -231,8 +233,8 @@ async def test_uart_mock_modbus_server_read_write(
            "rw_write_1": 4660,  # 0x1234 written to reg 0x0001
            "rw_read_1": 4660,  # reg 0x0001 reads back the just-written value
            "rw_read_2": 170,  # 0x00AA read from reg 0x0002 in the same request
-            "rw_write_3": 22136,  # 0x5678 written to reg 0x0003
-            "rw_read_3": 22136,  # reg 0x0003 reads back the just-written value
+            "rw_write_3": 22136,  # 0x5678 written to reg 0x0006
+            "rw_read_3": 22136,  # reg 0x0006 reads back the just-written value
        }
    )

@@ -241,7 +243,8 @@ async def test_uart_mock_modbus_server_read_write(
        api_client_connected() as client,
    ):
        await tracker.setup_and_start_scenario(client)
-        await tracker.await_all(futures)
+        # The FC 0x17 injections fire last, behind four earlier 100ms delays
+        await tracker.await_all(futures, timeout=4.0)
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


@@ -296,6 +299,7 @@ async def test_uart_mock_modbus_server_read_write_invalid(
    )


+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller(
    yaml_config: str,
@@ -485,6 +489,7 @@ async def test_uart_mock_modbus_server_controller_bits(
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_multiple(
    yaml_config: str,
@@ -495,7 +500,7 @@ async def test_uart_mock_modbus_server_controller_multiple(

    line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()

-    expected_values = {"reg_u_word": 919, "reg_u_word_2": 929}
+    expected_values = {"multi_reg_a": 919, "multi_reg_b": 929}
    tracker = SensorTracker(list(expected_values.keys()))
    futures = tracker.expect_all(expected_values)

@@ -706,6 +711,7 @@ async def test_uart_mock_modbus_shared_address(
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_loopback")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_custom_pdu(
    yaml_config: str,
@@ -932,6 +938,7 @@ async def test_uart_mock_modbus_broadcast_write(
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_client_read_write(
    yaml_config: str,
@@ -947,9 +954,7 @@ async def test_uart_mock_modbus_client_read_write(
    """
    line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()

-    tracker = SensorTracker(
-        ["srv_write_1", "srv_read_1", "client_read_0", "client_read_1"]
-    )
+    tracker = SensorTracker(["srv_write_1", "client_read_0", "client_read_1"])
    futures = tracker.expect_all(
        {
            "srv_write_1": 4660,  # server wrote 0x1234 to reg 0x0001
@@ -967,6 +972,7 @@ async def test_uart_mock_modbus_client_read_write(
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_loopback")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_register_offset(
    yaml_config: str,
@@ -1022,6 +1028,7 @@ async def test_uart_mock_modbus_register_offset(
        )


+@pytest.mark.shared_yaml("uart_mock_modbus_loopback")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_lambda_write(
    yaml_config: str,
@@ -1058,6 +1065,7 @@ async def test_uart_mock_modbus_lambda_write(
        await tracker.await_change(wrote_30, "reg_30", timeout=4.0)


+@pytest.mark.shared_yaml("uart_mock_modbus_loopback")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_lambda_invert(
    yaml_config: str,
@@ -1113,6 +1121,7 @@ async def test_uart_mock_modbus_lambda_invert(
        )


+@pytest.mark.shared_yaml("uart_mock_modbus_loopback")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_deprecated_write_buffer(
    yaml_config: str,
@@ -78,17 +78,6 @@ def mock_esp32_platformio_components_to_test() -> Generator[Mock, None, None]:
        yield mock


-@pytest.fixture
-def mock_esp8266_native_components_to_test() -> Generator[Mock, None, None]:
-    """Mock esp8266_native_components_to_test from determine_jobs.
-
-    main() drives both the ``esp8266_native`` boolean output and the
-    ``esp8266_native_components`` CSV from this one function.
-    """
-    with patch.object(determine_jobs, "esp8266_native_components_to_test") as mock:
-        yield mock
-
-
@pytest.fixture
 def mock_determine_cpp_unit_tests() -> Generator[Mock, None, None]:
    """Mock determine_cpp_unit_tests from helpers."""
@@ -117,7 +106,6 @@ def clear_determine_jobs_caches() -> None:
    """Clear all cached functions before each test."""
    determine_jobs._is_clang_tidy_full_scan.cache_clear()
    determine_jobs._component_has_tests.cache_clear()
-    determine_jobs._cached_components_closure.cache_clear()


 def test_main_all_tests_should_run(
@@ -128,7 +116,6 @@ def test_main_all_tests_should_run(
    mock_should_run_import_time: Mock,
    mock_should_run_device_builder: Mock,
    mock_esp32_platformio_components_to_test: Mock,
-    mock_esp8266_native_components_to_test: Mock,
    mock_changed_files: Mock,
    mock_determine_cpp_unit_tests: Mock,
    capsys: pytest.CaptureFixture[str],
@@ -145,7 +132,6 @@ def test_main_all_tests_should_run(
    mock_should_run_import_time.return_value = True
    mock_should_run_device_builder.return_value = True
    mock_esp32_platformio_components_to_test.return_value = ["api", "esp32"]
-    mock_esp8266_native_components_to_test.return_value = ["api", "logger"]
    mock_determine_cpp_unit_tests.return_value = (False, ["wifi", "api", "sensor"])

    # Mock changed_files to return non-component files (to avoid memory impact)
@@ -222,8 +208,6 @@ def test_main_all_tests_should_run(
    assert output["device_builder"] is True
    assert output["esp32_platformio"] is True
    assert output["esp32_platformio_components"] == "api,esp32"
-    assert output["esp8266_native"] is True
-    assert output["esp8266_native_components"] == "api,logger"
    assert output["changed_components"] == ["wifi", "api", "sensor"]
    # changed_components_with_tests will only include components that actually have test files
    assert "changed_components_with_tests" in output
@@ -260,7 +244,6 @@ def test_main_no_tests_should_run(
    mock_should_run_import_time: Mock,
    mock_should_run_device_builder: Mock,
    mock_esp32_platformio_components_to_test: Mock,
-    mock_esp8266_native_components_to_test: Mock,
    mock_changed_files: Mock,
    mock_determine_cpp_unit_tests: Mock,
    capsys: pytest.CaptureFixture[str],
@@ -277,7 +260,6 @@ def test_main_no_tests_should_run(
    mock_should_run_import_time.return_value = False
    mock_should_run_device_builder.return_value = False
    mock_esp32_platformio_components_to_test.return_value = []
-    mock_esp8266_native_components_to_test.return_value = []
    mock_determine_cpp_unit_tests.return_value = (False, [])

    # Mock changed_files to return no component files
@@ -320,8 +302,6 @@ def test_main_no_tests_should_run(
    assert output["device_builder"] is False
    assert output["esp32_platformio"] is False
    assert output["esp32_platformio_components"] == ""
-    assert output["esp8266_native"] is False
-    assert output["esp8266_native_components"] == ""
    assert output["changed_components"] == []
    assert output["changed_components_with_tests"] == []
    assert output["component_test_count"] == 0
@@ -3171,78 +3151,6 @@ def test_memory_impact_elf_layouts_are_found(tmp_path: Path) -> None:
        assert find_elf_path(build_path) == elf, f"{platform} ELF not found"


-@pytest.mark.parametrize(
-    "changed",
-    [
-        "esphome/arduino8266/framework.py",
-        "esphome/build_gen/arduino8266.py",
-        "esphome/components/esp8266/build_surgery.py",
-        # Shared modules the native build depends on
-        "esphome/build_helpers/idedata.py",
-        "esphome/platformio/library.py",
-        # Top-level esphome/*.py modules the backend imports directly
-        "esphome/framework_helpers.py",
-        "esphome/writer.py",
-        # esp8266/__init__.py imports copy_ccache_script from it
-        "esphome/platformio/toolchain.py",
-        # The composite cache action must not ship unexercised
-        ".github/actions/cache-arduino8266/action.yml",
-    ],
-)
-def test_esp8266_native_components_full_list_on_infra_change(changed: str) -> None:
-    """Native-ESP8266 infrastructure changes run the full test list."""
-    with (
-        patch.object(determine_jobs, "changed_files", return_value=[changed]),
-        patch.object(
-            determine_jobs,
-            "get_components_with_dependencies",
-            return_value=["wifi"],
-        ),
-    ):
-        result = determine_jobs.esp8266_native_components_to_test()
-        assert result == sorted(determine_jobs.ESP8266_NATIVE_TEST_COMPONENTS)
-
-
-@pytest.mark.parametrize(
-    ("changed_files", "dependency_closure", "expected"),
-    [
-        # Tested component changed -- narrow to the intersection.
-        (
-            ["esphome/components/mqtt/mqtt_client.cpp"],
-            ["mqtt", "json"],
-            ["mqtt"],
-        ),
-        # Components outside the test set return an empty list (job skipped).
-        (
-            ["esphome/components/wifi/wifi_component.cpp"],
-            ["wifi", "network"],
-            [],
-        ),
-        # espidf infrastructure is not an esp8266-native trigger; the
-        # native backend depends on esphome/build_helpers/ instead.
-        (["esphome/build_gen/espidf.py"], [], []),
-        (["esphome/espidf/toolchain.py"], [], []),
-        (["README.md"], [], []),
-    ],
-)
-def test_esp8266_native_components_to_test_narrowing(
-    changed_files: list[str],
-    dependency_closure: list[str],
-    expected: list[str],
-) -> None:
-    """Component changes narrow the native-ESP8266 test list."""
-    with (
-        patch.object(determine_jobs, "changed_files", return_value=changed_files),
-        patch.object(
-            determine_jobs,
-            "get_components_with_dependencies",
-            return_value=dependency_closure,
-        ),
-    ):
-        result = determine_jobs.esp8266_native_components_to_test()
-        assert result == expected
-
-
 def test_compute_integration_test_buckets_no_durations_full_fanout() -> None:
    """Without recorded durations the fan-out stays at the maximum."""
    files = [f"tests/integration/test_{i:03d}.py" for i in range(15)]
@@ -2122,6 +2122,34 @@ def test_get_cpp_changed_components_independent_of_cwd(
    ) == ["time"]


+def test_fixture_map_includes_shared_yaml_markers() -> None:
+    """Fixtures named only by shared_yaml markers must map to their test file."""
+    helpers.get_fixture_to_test_files.cache_clear()
+    mapping = helpers.get_fixture_to_test_files()
+    for fixture in (
+        "uart_mock_modbus_loopback",
+        "uart_mock_modbus_mesh",
+        "uart_mock_modbus_server_injected",
+    ):
+        assert mapping[fixture] == frozenset(
+            {"tests/integration/test_uart_mock_modbus.py"}
+        )
+
+
+def test_no_orphan_integration_fixtures() -> None:
+    """Every fixture must reach CI test selection; an orphan selects nothing."""
+    helpers.get_fixture_to_test_files.cache_clear()
+    mapping = helpers.get_fixture_to_test_files()
+    fixtures_dir = (Path(__file__).parent.parent / "integration" / "fixtures").resolve()
+    fixtures = list(fixtures_dir.glob("*.yaml"))
+    assert fixtures, f"no fixtures found under {fixtures_dir}"
+    # cache_init is covered via INTEGRATION_TESTS_TRIGGER_FILES instead
+    orphans = [
+        f.stem for f in fixtures if f.stem != "cache_init" and f.stem not in mapping
+    ]
+    assert not orphans, f"fixtures invisible to CI test selection: {orphans}"
+
+
 def test_lpt_partition_balances_skewed_weights() -> None:
    """Heavy items spread across groups instead of clustering."""
    items = [f"i{n}" for n in range(6)]
@@ -35,8 +35,8 @@ def _load_script():
 def test_spec_key_collapses_destinations() -> None:
    """Two specs delivering one package share a directory and one key."""
    mod = _load_script()
-    assert mod.spec_key("esphome/noise-c @ 0.1.24") == "noise-c"
-    assert mod.spec_key("esphome/noise-c@0.1.24") == "noise-c"
+    assert mod.spec_key("esphome/noise-c @ 0.1.26") == "noise-c"
+    assert mod.spec_key("esphome/noise-c@0.1.26") == "noise-c"
    assert mod.spec_key("ESP32Async/AsyncTCP @ ^3.4.10") == mod.spec_key(
        "esp32async/asynctcp @ 3.5.0"
    )
@@ -54,23 +54,23 @@ def test_parse_specs_and_cli_args(tmp_path: Path) -> None:
        "[env:a]\n"
        "platform = fake/platform@1\n"
        "lib_deps =\n"
-        "    esphome/noise-c @ 0.1.24\n"
+        "    esphome/noise-c @ 0.1.26\n"
        "    ${common.lib_deps}\n"
        "    internal_lib\n"
        "[env:b]\n"
        "lib_deps =\n"
-        "    esphome/noise-c @ 0.1.24\n"
+        "    esphome/noise-c @ 0.1.26\n"
    )
    mod = _load_script()
    args = Namespace(libraries=True, platforms=True, tools=False)
    libs, platforms, tools = mod.parse_specs(str(ini), args)
    # exact-string duplicates collapse; distinct version pins survive
-    assert libs == ["esphome/noise-c @ 0.1.24"]
+    assert libs == ["esphome/noise-c @ 0.1.26"]
    assert platforms == ["fake/platform@1"]
    assert tools == []
    assert mod.build_cli_args(libs, platforms, tools) == [
        "-l",
-        "esphome/noise-c @ 0.1.24",
+        "esphome/noise-c @ 0.1.26",
        "-p",
        "fake/platform@1",
    ]
@@ -162,13 +162,13 @@ def test_parallel_install_behavior(tmp_path: Path) -> None:
    mod.parallel_install(
        cls,
        [
-            "esphome/noise-c @ 0.1.24",
-            "esphome/noise-c @ 0.1.24",
+            "esphome/noise-c @ 0.1.26",
+            "esphome/noise-c @ 0.1.26",
            "esphome/already @ 1.0",
            "https://x/framework.tar.xz",
        ],
    )
-    assert cls.calls == ["esphome/noise-c @ 0.1.24"]
+    assert cls.calls == ["esphome/noise-c @ 0.1.26"]
    assert cls.lock_events == ["lock", "unlock"]


@@ -205,7 +205,7 @@ def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None:
    mod = _load_script()
    cls = _reset_fake(str(tmp_path))
    cls.deps = {
-        "esphome/noise-c @ 0.1.24": [
+        "esphome/noise-c @ 0.1.26": [
            {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
            {"name": "SPI"},
        ],
@@ -213,12 +213,12 @@ def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None:
            {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
        ],
    }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24", "esphome/wg @ 1.0"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26", "esphome/wg @ 1.0"])
    assert len(cls.calls) == 3  # the shared dep installs exactly once
    assert {mod.spec_key(c) for c in cls.calls} == {"noise-c", "wg", "libsodium"}
    # Wave-1 strings carry no compatibility; the dependency wave does
    compats = dict(cls.compat_calls)
-    assert compats["esphome/noise-c @ 0.1.24"] is None
+    assert compats["esphome/noise-c @ 0.1.26"] is None
    dep_compat = next(v for k, v in cls.compat_calls if "libsodium" in k)
    assert dep_compat is not None  # mirrors pio's install_dependency

@@ -229,11 +229,11 @@ def test_dependency_wave_excludes_url_specs(tmp_path: Path) -> None:
    mod = _load_script()
    cls = _reset_fake(str(tmp_path))
    cls.deps = {
-        "esphome/noise-c @ 0.1.24": [
+        "esphome/noise-c @ 0.1.26": [
            {"name": "vendored", "version": "https://github.com/x/y.git"},
        ],
    }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26"])
    assert {mod.spec_key(c) for c in cls.calls} == {"noise-c"}


@@ -348,13 +348,13 @@ def test_warm_store_still_walks_dependencies(tmp_path: Path) -> None:
    """Already-installed top-level packages still feed the dependency
    wave; a warm store can be missing a transitive dep."""
    mod = _load_script()
-    cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.24"})
+    cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.26"})
    cls.deps = {
-        "esphome/noise-c @ 0.1.24": [
+        "esphome/noise-c @ 0.1.26": [
            {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
        ],
    }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26"])
    assert [mod.spec_key(c) for c in cls.calls] == ["libsodium"]


@@ -0,0 +1,562 @@
+"""Tests for script/setup.py."""
+
+import importlib.util
+import os
+from pathlib import Path, PurePosixPath, PureWindowsPath
+import runpy
+import sys
+from types import ModuleType
+from unittest.mock import Mock, call, patch
+
+import pytest
+
+_SCRIPT = Path(__file__).parents[2] / "script" / "setup.py"
+
+
+def _load_module() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("script_setup", _SCRIPT)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+@pytest.fixture
+def script_setup() -> ModuleType:
+    """Fresh import of script/setup.py, isolated from other tests."""
+    return _load_module()
+
+
+# --- bin_dir / venv_python / activate_hint -----------------------------------
+
+
+def test_bin_dir_matches_host_layout(script_setup: ModuleType, tmp_path: Path) -> None:
+    """The venv scheme resolves to Scripts on Windows and bin everywhere else."""
+    expected = "Scripts" if os.name == "nt" else "bin"
+    assert script_setup.bin_dir(tmp_path) == tmp_path / expected
+
+
+# Both flavours are exercised on every host. Pure paths are used because a real
+# Path refuses to change flavour: PosixPath cannot be built on Windows, and
+# WindowsPath cannot be built on Unix.
+
+
+def test_venv_python_posix(script_setup: ModuleType, tmp_path: Path) -> None:
+    with (
+        patch.object(
+            script_setup, "bin_dir", return_value=PurePosixPath("/x/venv/bin")
+        ),
+        patch.object(script_setup.os, "name", "posix"),
+    ):
+        result = script_setup.venv_python(tmp_path)
+    assert result == PurePosixPath("/x/venv/bin/python")
+
+
+def test_venv_python_nt(script_setup: ModuleType, tmp_path: Path) -> None:
+    with (
+        patch.object(
+            script_setup, "bin_dir", return_value=PureWindowsPath(r"C:\x\venv\Scripts")
+        ),
+        patch.object(script_setup.os, "name", "nt"),
+    ):
+        result = script_setup.venv_python(tmp_path)
+    assert result == PureWindowsPath(r"C:\x\venv\Scripts\python.exe")
+
+
+def test_activate_hint_posix(script_setup: ModuleType) -> None:
+    with (
+        patch.object(script_setup, "ROOT", PurePosixPath("/x")),
+        patch.object(
+            script_setup, "bin_dir", return_value=PurePosixPath("/x/venv/bin")
+        ),
+        patch.object(script_setup.os, "name", "posix"),
+    ):
+        hint = script_setup.activate_hint()
+    assert hint == "source venv/bin/activate"
+
+
+def test_activate_hint_nt(script_setup: ModuleType) -> None:
+    with (
+        patch.object(script_setup, "ROOT", PureWindowsPath(r"C:\x")),
+        patch.object(
+            script_setup, "bin_dir", return_value=PureWindowsPath(r"C:\x\venv\Scripts")
+        ),
+        patch.object(script_setup.os, "name", "nt"),
+    ):
+        hint = script_setup.activate_hint()
+    # The nt branch returns str(activate) as-is, skipping the "source " prefix.
+    assert hint == r"venv\Scripts\activate"
+
+
+# --- run -----------------------------------------------------------------
+
+
+def test_run_success(script_setup: ModuleType) -> None:
+    with patch.object(
+        script_setup.subprocess, "run", return_value=Mock(returncode=0)
+    ) as mock_run:
+        script_setup.run(["echo", "hi"])
+    mock_run.assert_called_once_with(
+        ["echo", "hi"], cwd=script_setup.ROOT, env=None, check=False
+    )
+
+
+def test_run_failure_raises_system_exit_with_code(
+    script_setup: ModuleType, capsys: pytest.CaptureFixture[str]
+) -> None:
+    with (
+        patch.object(script_setup.subprocess, "run", return_value=Mock(returncode=7)),
+        pytest.raises(SystemExit) as excinfo,
+    ):
+        script_setup.run(["false"])
+    assert excinfo.value.code == 7
+    assert "Failed with exit code 7: false" in capsys.readouterr().err
+
+
+# --- git_output ------------------------------------------------------------
+
+
+def test_git_output_success_strips_stdout(script_setup: ModuleType) -> None:
+    with patch.object(
+        script_setup.subprocess,
+        "run",
+        return_value=Mock(returncode=0, stdout="  /repo/.git \n"),
+    ) as mock_run:
+        result = script_setup.git_output("rev-parse", "--absolute-git-dir")
+    assert result == "/repo/.git"
+    mock_run.assert_called_once_with(
+        ["git", "rev-parse", "--absolute-git-dir"],
+        cwd=script_setup.ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def test_git_output_nonzero_returncode_is_empty(script_setup: ModuleType) -> None:
+    with patch.object(
+        script_setup.subprocess,
+        "run",
+        return_value=Mock(returncode=1, stdout="whatever"),
+    ):
+        assert script_setup.git_output("status") == ""
+
+
+def test_git_output_oserror_is_empty(script_setup: ModuleType) -> None:
+    with patch.object(script_setup.subprocess, "run", side_effect=OSError("no git")):
+        assert script_setup.git_output("status") == ""
+
+
+# --- create_venv -----------------------------------------------------------
+
+
+def test_create_venv_uses_uv_when_present(
+    script_setup: ModuleType, tmp_path: Path
+) -> None:
+    venv = tmp_path / "venv"
+    with (
+        patch.object(script_setup.shutil, "which", return_value="/usr/bin/uv"),
+        patch.object(
+            script_setup.subprocess, "run", return_value=Mock(returncode=0)
+        ) as mock_run,
+    ):
+        script_setup.create_venv(venv)
+    mock_run.assert_called_once_with(
+        ["/usr/bin/uv", "venv", "--clear", "--seed", str(venv)],
+        cwd=script_setup.ROOT,
+        env=None,
+        check=False,
+    )
+
+
+def test_create_venv_falls_back_to_venv_module(
+    script_setup: ModuleType, tmp_path: Path
+) -> None:
+    venv = tmp_path / "venv"
+    with (
+        patch.object(script_setup.shutil, "which", return_value=None),
+        patch.object(
+            script_setup.subprocess, "run", return_value=Mock(returncode=0)
+        ) as mock_run,
+    ):
+        script_setup.create_venv(venv)
+    mock_run.assert_called_once_with(
+        [sys.executable, "-m", "venv", "--clear", str(venv)],
+        cwd=script_setup.ROOT,
+        env=None,
+        check=False,
+    )
+
+
+# --- venv_environment --------------------------------------------------------
+
+
+def test_venv_environment_sets_virtual_env_and_prepends_path(
+    script_setup: ModuleType, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    venv = tmp_path / "venv"
+    monkeypatch.setenv("PYTHONHOME", "/somewhere")
+    monkeypatch.setenv("PATH", "/usr/bin:/bin")
+    env = script_setup.venv_environment(venv)
+    assert env["VIRTUAL_ENV"] == str(venv)
+    assert "PYTHONHOME" not in env
+    expected_prefix = str(script_setup.bin_dir(venv)) + os.pathsep
+    assert env["PATH"] == expected_prefix + "/usr/bin:/bin"
+
+
+def test_venv_environment_path_fallback_when_unset(
+    script_setup: ModuleType, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    venv = tmp_path / "venv"
+    monkeypatch.delenv("PATH", raising=False)
+    env = script_setup.venv_environment(venv)
+    # No trailing separator: an empty PATH entry means "search the cwd".
+    assert env["PATH"] == str(script_setup.bin_dir(venv))
+
+
+# --- find_uv -----------------------------------------------------------------
+
+
+def test_find_uv_found_immediately(script_setup: ModuleType, tmp_path: Path) -> None:
+    venv = tmp_path / "venv"
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(script_setup.shutil, "which", return_value="/usr/bin/uv"),
+        patch.object(script_setup.subprocess, "run") as mock_run,
+    ):
+        result = script_setup.find_uv(venv, env)
+    assert result == "/usr/bin/uv"
+    mock_run.assert_not_called()
+
+
+def test_find_uv_installed_then_found(script_setup: ModuleType, tmp_path: Path) -> None:
+    venv = tmp_path / "venv"
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(script_setup.shutil, "which", side_effect=[None, "/usr/bin/uv"]),
+        patch.object(
+            script_setup.subprocess, "run", return_value=Mock(returncode=0)
+        ) as mock_run,
+    ):
+        result = script_setup.find_uv(venv, env)
+    assert result == "/usr/bin/uv"
+    mock_run.assert_called_once_with(
+        [str(script_setup.venv_python(venv)), "-m", "pip", "install", "uv"],
+        cwd=script_setup.ROOT,
+        env=env,
+        check=False,
+    )
+
+
+def test_find_uv_still_missing_raises_system_exit(
+    script_setup: ModuleType, tmp_path: Path
+) -> None:
+    venv = tmp_path / "venv"
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(script_setup.shutil, "which", side_effect=[None, None]),
+        patch.object(script_setup.subprocess, "run", return_value=Mock(returncode=0)),
+        pytest.raises(SystemExit, match="uv could not be installed"),
+    ):
+        script_setup.find_uv(venv, env)
+
+
+# --- install_dependencies -----------------------------------------------------
+
+
+def test_install_dependencies_installs_setuptools_then_project(
+    script_setup: ModuleType, tmp_path: Path
+) -> None:
+    venv = tmp_path / "venv"
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(script_setup.shutil, "which", return_value="/usr/bin/uv"),
+        patch.object(
+            script_setup.subprocess, "run", return_value=Mock(returncode=0)
+        ) as mock_run,
+    ):
+        script_setup.install_dependencies(venv, env)
+    assert mock_run.call_args_list == [
+        call(
+            ["/usr/bin/uv", "pip", "install", "setuptools", "wheel"],
+            cwd=script_setup.ROOT,
+            env=env,
+            check=False,
+        ),
+        call(
+            [
+                "/usr/bin/uv",
+                "pip",
+                "install",
+                "-e",
+                ".[dev,test]",
+                "--config-settings",
+                "editable_mode=compat",
+            ],
+            cwd=script_setup.ROOT,
+            env=env,
+            check=False,
+        ),
+    ]
+
+
+# --- install_git_hooks ---------------------------------------------------------
+
+
+def _fake_git_output(git_dir: str, common_dir: str):
+    def _run(*args: str) -> str:
+        if "--absolute-git-dir" in args:
+            return git_dir
+        return common_dir
+
+    return _run
+
+
+def test_install_git_hooks_returns_early_when_git_dir_empty(
+    script_setup: ModuleType,
+) -> None:
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(
+            script_setup, "git_output", side_effect=_fake_git_output("", "/repo/.git")
+        ),
+        patch.object(script_setup.subprocess, "run") as mock_run,
+    ):
+        script_setup.install_git_hooks(env)
+    mock_run.assert_not_called()
+
+
+def test_install_git_hooks_returns_early_when_common_dir_empty(
+    script_setup: ModuleType,
+) -> None:
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(
+            script_setup, "git_output", side_effect=_fake_git_output("/repo/.git", "")
+        ),
+        patch.object(script_setup.subprocess, "run") as mock_run,
+    ):
+        script_setup.install_git_hooks(env)
+    mock_run.assert_not_called()
+
+
+def test_install_git_hooks_returns_early_for_worktree(
+    script_setup: ModuleType,
+) -> None:
+    """A worktree's git-dir differs from the shared common-dir."""
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(
+            script_setup,
+            "git_output",
+            side_effect=_fake_git_output("/repo/.git/worktrees/wt", "/repo/.git"),
+        ),
+        patch.object(script_setup.subprocess, "run") as mock_run,
+    ):
+        script_setup.install_git_hooks(env)
+    mock_run.assert_not_called()
+
+
+def test_install_git_hooks_missing_prek_raises_system_exit(
+    script_setup: ModuleType,
+) -> None:
+    env = {"PATH": "/usr/bin"}
+    with (
+        patch.object(
+            script_setup,
+            "git_output",
+            side_effect=_fake_git_output("/repo/.git", "/repo/.git"),
+        ),
+        patch.object(script_setup.shutil, "which", return_value=None),
+        patch.object(script_setup.subprocess, "run") as mock_run,
+        pytest.raises(SystemExit, match="prek was not installed"),
+    ):
+        script_setup.install_git_hooks(env)
+    mock_run.assert_not_called()
+
+
+def test_install_git_hooks_happy_path_installs_hook(
+    script_setup: ModuleType, tmp_path: Path
+) -> None:
+    env = {"PATH": "/usr/bin"}
+    common_dir = tmp_path / "repo" / ".git"
+    hooks_dir = common_dir / "hooks"
+    hooks_dir.mkdir(parents=True)
+    source_hook = tmp_path / "post-checkout"
+    source_hook.write_text("#!/bin/sh\necho post-checkout\n")
+
+    with (
+        patch.object(script_setup, "POST_CHECKOUT_HOOK", source_hook),
+        patch.object(
+            script_setup,
+            "git_output",
+            side_effect=_fake_git_output(str(common_dir), str(common_dir)),
+        ),
+        patch.object(script_setup.shutil, "which", return_value="/usr/bin/prek"),
+        patch.object(
+            script_setup.subprocess, "run", return_value=Mock(returncode=0)
+        ) as mock_run,
+    ):
+        script_setup.install_git_hooks(env)
+
+    mock_run.assert_called_once_with(
+        ["/usr/bin/prek", "install", "--overwrite"],
+        cwd=script_setup.ROOT,
+        env=env,
+        check=False,
+    )
+    installed = hooks_dir / "post-checkout"
+    assert installed.read_text() == source_hook.read_text()
+    if os.name != "nt":
+        # Windows has no POSIX permission bits for chmod to set.
+        assert (installed.stat().st_mode & 0o777) == 0o755
+
+
+def test_install_git_hooks_skips_copy_when_hooks_dir_missing(
+    script_setup: ModuleType, tmp_path: Path
+) -> None:
+    """The prek install still runs when the hooks directory does not exist."""
+    env = {"PATH": "/usr/bin"}
+    common_dir = tmp_path / "repo" / ".git"
+    common_dir.mkdir(parents=True)  # no "hooks" subdirectory created
+
+    with (
+        patch.object(
+            script_setup,
+            "git_output",
+            side_effect=_fake_git_output(str(common_dir), str(common_dir)),
+        ),
+        patch.object(script_setup.shutil, "which", return_value="/usr/bin/prek"),
+        patch.object(
+            script_setup.subprocess, "run", return_value=Mock(returncode=0)
+        ) as mock_run,
+    ):
+        script_setup.install_git_hooks(env)
+
+    mock_run.assert_called_once()
+    assert not (common_dir / "hooks").exists()
+
+
+# --- report ------------------------------------------------------------------
+
+
+def test_report_active_state(
+    script_setup: ModuleType, capsys: pytest.CaptureFixture
+) -> None:
+    venv = Path("/opt/esphome-venv")
+    script_setup.report(script_setup.VENV_ACTIVE, venv)
+    out = capsys.readouterr().out
+    assert "Dependencies installed into the active virtual environment:" in out
+    assert str(venv) in out
+    assert "is already active in this shell" in out
+
+
+def test_report_reused_state(
+    script_setup: ModuleType, capsys: pytest.CaptureFixture
+) -> None:
+    script_setup.report(script_setup.VENV_REUSED, script_setup.DEFAULT_VENV)
+    out = capsys.readouterr().out
+    assert "Dependencies updated in the existing ./venv" in out
+
+
+def test_report_created_state(
+    script_setup: ModuleType, capsys: pytest.CaptureFixture
+) -> None:
+    script_setup.report(script_setup.VENV_CREATED, script_setup.DEFAULT_VENV)
+    out = capsys.readouterr().out
+    assert "Virtual environment created at ./venv" in out
+
+
+# --- main --------------------------------------------------------------------
+
+
+def test_main_raises_system_exit_when_python_too_old(
+    script_setup: ModuleType,
+) -> None:
+    with (
+        patch.object(script_setup.sys, "version_info", (3, 11, 5)),
+        pytest.raises(SystemExit, match="ESPHome needs Python 3.12"),
+    ):
+        script_setup.main()
+
+
+def test_main_uses_active_virtual_env(
+    script_setup: ModuleType, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    active_venv = tmp_path / "active-venv"
+    monkeypatch.setenv("VIRTUAL_ENV", str(active_venv))
+    with (
+        patch.object(script_setup, "ROOT", tmp_path),
+        patch.object(script_setup, "create_venv") as mock_create_venv,
+        patch.object(script_setup, "install_dependencies") as mock_install_deps,
+        patch.object(script_setup, "install_git_hooks") as mock_install_hooks,
+        patch.object(script_setup, "report") as mock_report,
+    ):
+        script_setup.main()
+    mock_create_venv.assert_not_called()
+    mock_install_deps.assert_called_once()
+    mock_install_hooks.assert_called_once()
+    mock_report.assert_called_once_with(script_setup.VENV_ACTIVE, active_venv)
+    assert (tmp_path / ".temp").is_dir()
+
+
+def test_main_reuses_existing_venv(
+    script_setup: ModuleType, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.delenv("VIRTUAL_ENV", raising=False)
+    default_venv = tmp_path / "venv"
+    python_path = script_setup.venv_python(default_venv)
+    python_path.parent.mkdir(parents=True)
+    python_path.touch()
+
+    with (
+        patch.object(script_setup, "ROOT", tmp_path),
+        patch.object(script_setup, "DEFAULT_VENV", default_venv),
+        patch.object(script_setup, "create_venv") as mock_create_venv,
+        patch.object(script_setup, "install_dependencies") as mock_install_deps,
+        patch.object(script_setup, "install_git_hooks") as mock_install_hooks,
+        patch.object(script_setup, "report") as mock_report,
+    ):
+        script_setup.main()
+    mock_create_venv.assert_not_called()
+    mock_install_deps.assert_called_once()
+    mock_install_hooks.assert_called_once()
+    mock_report.assert_called_once_with(script_setup.VENV_REUSED, default_venv)
+    assert (tmp_path / ".temp").is_dir()
+
+
+def test_main_creates_new_venv(
+    script_setup: ModuleType, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.delenv("VIRTUAL_ENV", raising=False)
+    default_venv = tmp_path / "venv"  # does not exist yet
+
+    with (
+        patch.object(script_setup, "ROOT", tmp_path),
+        patch.object(script_setup, "DEFAULT_VENV", default_venv),
+        patch.object(script_setup, "create_venv") as mock_create_venv,
+        patch.object(script_setup, "install_dependencies") as mock_install_deps,
+        patch.object(script_setup, "install_git_hooks") as mock_install_hooks,
+        patch.object(script_setup, "report") as mock_report,
+    ):
+        script_setup.main()
+    mock_create_venv.assert_called_once_with(default_venv)
+    mock_install_deps.assert_called_once()
+    mock_install_hooks.assert_called_once()
+    mock_report.assert_called_once_with(script_setup.VENV_CREATED, default_venv)
+    assert (tmp_path / ".temp").is_dir()
+
+
+def test_run_as_script_calls_main(tmp_path: Path) -> None:
+    """The __main__ guard runs the whole flow, with every side effect stubbed."""
+    completed = Mock(returncode=0, stdout="")
+    with (
+        patch("subprocess.run", return_value=completed) as mock_run,
+        patch("shutil.which", return_value="/usr/bin/uv"),
+        patch("pathlib.Path.mkdir") as mock_mkdir,
+        patch.dict(os.environ, {"VIRTUAL_ENV": str(tmp_path / "env")}),
+    ):
+        runpy.run_path(str(_SCRIPT), run_name="__main__")
+
+    # The dependency install ran, and git reported no hooks directory to touch.
+    assert mock_run.called
+    mock_mkdir.assert_called_once_with(exist_ok=True)
@@ -236,98 +236,3 @@ def test_run_grouped_test_closes_group_when_subprocess_raises(
        )

    assert "::endgroup::" in capsys.readouterr().out
-
-
-def test_components_empty_match_fails_with_flag(
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """Under --fail-on-no-tests, a real component filtered to a platform
-    with no matching test file must not pass CI as a green zero-component
-    compile."""
-    rc = tbc.test_components(
-        ["logger"],
-        "zz-none",
-        "compile",
-        False,
-        enable_grouping=False,
-        fail_on_no_tests=True,
-    )
-    assert rc == 1
-    assert "No tests ran for requested pattern(s): logger" in (capsys.readouterr().out)
-
-
-def test_components_component_with_no_base_file_fails_with_flag(
-    capsys: pytest.CaptureFixture[str],
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A component whose fixture matches the platform but whose platform has
-    no base file builds nothing; under the flag that silent zero fails by
-    component name instead of hiding behind other components."""
-    monkeypatch.setattr(tbc, "get_platform_base_files", lambda base_dir: {})
-    rc = tbc.test_components(
-        ["logger"],
-        "esp8266-ard",
-        "compile",
-        False,
-        enable_grouping=False,
-        fail_on_no_tests=True,
-    )
-    assert rc == 1
-    assert "No tests ran for requested pattern(s): logger" in (capsys.readouterr().out)
-
-
-def test_components_blank_list_fails_with_flag(
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """A fully blank component list must not slide into the baseline
-    fallback and exit green under the flag."""
-    rc = tbc.test_components(
-        [""], "esp8266-ard", "compile", False, fail_on_no_tests=True
-    )
-    assert rc == 1
-    assert "blank component list" in capsys.readouterr().out
-
-
-def test_components_wildcard_no_match_fails_with_flag(
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """A wildcard matching nothing must not degrade to the synthetic
-    baseline build and exit green under the flag."""
-    rc = tbc.test_components(
-        ["zz_no_such*"],
-        "esp8266-ard",
-        "compile",
-        False,
-        enable_grouping=False,
-        fail_on_no_tests=True,
-    )
-    assert rc == 1
-    assert "No components found matching" in capsys.readouterr().out
-
-
-def test_components_empty_match_tolerated_without_flag() -> None:
-    """The esp32-ard smoke leg deliberately builds only the subset with a
-    matching fixture; without the flag an empty match stays green."""
-    assert (
-        tbc.test_components(
-            ["logger"], "zz-none", "compile", False, enable_grouping=False
-        )
-        == 0
-    )
-
-
-def test_components_unknown_component_fails_with_flag(
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """A renamed smoke-test component must shrink coverage loudly, not fall
-    into the reference-baseline build."""
-    rc = tbc.test_components(
-        ["no_such_component_xyz"],
-        "esp8266-ard",
-        "compile",
-        False,
-        enable_grouping=False,
-        fail_on_no_tests=True,
-    )
-    assert rc == 1
-    assert "No components found matching" in capsys.readouterr().out
@@ -4,9 +4,7 @@ from __future__ import annotations

 import json
 import logging
-import os
 from pathlib import Path
-import subprocess
 from unittest.mock import patch

 import pytest
@@ -490,616 +488,3 @@ def test_get_component_cmakelists_no_compile_features() -> None:
        content = get_component_cmakelists()

    assert "target_compile_features" not in content
-
-
-@pytest.fixture(autouse=True)
-def _pch_default_on(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Pin the knob so a developer's ESPHOME_PCH_ENABLE=0 cannot fail these."""
-    monkeypatch.setenv("ESPHOME_PCH_ENABLE", "1")
-
-
-def _make_pch_device(tmp_path: Path, name: str) -> Path:
-    """A device dir with the pch source headers and a stub compile_commands."""
-    from esphome.build_helpers.pch import PCH_DEFAULT_HEADERS
-
-    dev = tmp_path / name
-    for header in PCH_DEFAULT_HEADERS:
-        path = dev / "src" / header
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text("")
-    # A real quoted include chain and a per-device-named sdkconfig with
-    # identical content: the closure and sdkconfig inputs must be exercised
-    (dev / "src" / "esphome" / "core" / "defines.h").write_text(
-        '#include "esphome/core/macros.h"\n'
-    )
-    (dev / "src" / "esphome" / "core" / "macros.h").write_text("#define M 1\n")
-    # Both spellings: tests patch CORE.name to "test" or to the device name
-    (dev / f"sdkconfig.{name}").write_text("CONFIG_X=y\n")
-    (dev / "sdkconfig.test").write_text("CONFIG_X=y\n")
-    build = dev / "build"
-    build.mkdir(exist_ok=True)
-    from esphome.build_helpers.pch import pch_header_text
-
-    (build / "esphome_pch.h").write_text(pch_header_text(PCH_DEFAULT_HEADERS))
-    # Native separators: mixed f-string paths break the src-prefix match
-    # on Windows
-    src_file = str(dev / "src" / "a.cpp")
-    (build / "compile_commands.json").write_text(
-        json.dumps(
-            [
-                {
-                    "directory": str(build),
-                    "command": (
-                        "g++ -DX=1 -include esphome_pch.h "
-                        "-o esp-idf/src/CMakeFiles/__idf_src.dir/a.cpp.obj "
-                        f'-c "{src_file}"'
-                    ),
-                    "file": src_file,
-                }
-            ]
-        )
-    )
-    return dev
-
-
-def test_prepare_pch_writes_header_and_sum(tmp_path: Path) -> None:
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_a")
-    CORE.build_path = dev
-    gch = dev / "build" / "esphome_pch.h.gch"
-
-    def fake_compile(cmd, **kwargs):
-        # The compile must target the header, not the stub TU
-        assert cmd[-5:-3] == ["c++-header", "-c"]
-        gch.write_bytes(b"gch")
-        return subprocess.CompletedProcess(cmd, 0, "", "")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=fake_compile),
-    ):
-        prepare_pch()
-    checksum = (dev / "build" / "esphome_pch.h.gch.sum").read_text().strip()
-    assert len(checksum) == 64
-    # Unchanged inputs: the second call must not recompile
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=AssertionError),
-    ):
-        prepare_pch()
-
-
-def test_pch_no_device_path_poison(tmp_path: Path) -> None:
-    """Regression: neither the injected -include nor the .sum may carry the
-    per-device build path, or cross-device ccache sharing breaks."""
-    from esphome.build_gen.espidf import get_component_cmakelists, prepare_pch
-
-    sums = []
-    for name in ("dev_a", "dev_b"):
-        dev = _make_pch_device(tmp_path, name)
-        CORE.build_path = dev
-        gch = dev / "build" / "esphome_pch.h.gch"
-
-        def fake_compile(cmd, _gch=gch, **kwargs):
-            _gch.write_bytes(b"gch")
-            return subprocess.CompletedProcess(cmd, 0, "", "")
-
-        with (
-            patch.object(CORE, "name", name),
-            patch("esphome.build_helpers.pch.subprocess.run", side_effect=fake_compile),
-        ):
-            prepare_pch()
-            content = get_component_cmakelists()
-        assert str(dev) not in content
-        sums.append((dev / "build" / "esphome_pch.h.gch.sum").read_text())
-    assert sums[0] == sums[1]
-
-
-def test_component_cmakelists_pch_block(monkeypatch: pytest.MonkeyPatch) -> None:
-    from esphome.build_gen.espidf import get_component_cmakelists
-
-    content = get_component_cmakelists()
-    assert '"$<$<COMPILE_LANGUAGE:CXX>:-include>"' in content
-    assert '"$<$<COMPILE_LANGUAGE:CXX>:esphome_pch.h>"' in content
-    monkeypatch.setenv("ESPHOME_PCH_ENABLE", "0")
-    assert "-include" not in get_component_cmakelists()
-
-
-def test_pch_compile_command_variants(tmp_path: Path) -> None:
-    """Missing DB, no matching entry, and launcher-prefixed commands."""
-    from esphome.build_helpers.pch import pch_compile_command
-
-    build = tmp_path / "build"
-    build.mkdir()
-    header = build / "esphome_pch.h"
-    gch = build / "esphome_pch.h.gch"
-    assert pch_compile_command(build, header, gch) is None
-
-    (build / "compile_commands.json").write_text(
-        json.dumps(
-            [
-                {"command": "gcc -c other.c", "file": "other.c"},
-            ]
-        )
-    )
-    assert pch_compile_command(build, header, gch) is None
-
-    src_file = str(tmp_path / "src" / "esphome" / "a.cpp")
-    (build / "compile_commands.json").write_text(
-        json.dumps(
-            [
-                {
-                    "command": (
-                        "/usr/bin/ccache g++ -DX=1 -include esphome_pch.h -MMD "
-                        "-MT a.cpp.obj -MF a.cpp.obj.d "
-                        "-o esp-idf/src/CMakeFiles/__idf_src.dir/a.cpp.obj "
-                        f"-c {src_file}"
-                    ),
-                    "file": src_file,
-                },
-            ]
-        )
-    )
-    # Launcher stripped; -include/-o/-c and depfile flags removed
-    cmd, cmd_dir = pch_compile_command(build, header, gch)
-    assert cmd == [
-        "g++",
-        "-DX=1",
-        "-x",
-        "c++-header",
-        "-c",
-        str(header),
-        "-o",
-        str(gch),
-    ]
-    # The compile must run where the flags were resolved
-    assert cmd_dir == build
-
-
-@pytest.mark.skipif(os.name == "nt", reason="symlinks need privileges on Windows")
-def test_pch_compile_command_matches_src_through_symlink(tmp_path: Path) -> None:
-    """Find the src TU when CMake spells paths through a different symlink (macOS /tmp)."""
-    from esphome.build_helpers.pch import pch_compile_command
-
-    real = tmp_path / "real"
-    (real / "src" / "esphome").mkdir(parents=True)
-    link = tmp_path / "link"
-    link.symlink_to(real, target_is_directory=True)
-    CORE.build_path = str(real)
-    build = real / "build"
-    build.mkdir()
-    header = build / "esphome_pch.h"
-    gch = build / "esphome_pch.h.gch"
-    src_file = str(link / "src" / "esphome" / "a.cpp")
-    (build / "compile_commands.json").write_text(
-        json.dumps([{"command": f"g++ -DX=1 -o a.obj -c {src_file}", "file": src_file}])
-    )
-
-    cmd, cmd_dir = pch_compile_command(build, header, gch)
-
-    assert cmd[:2] == ["g++", "-DX=1"]
-    assert cmd_dir == build
-
-
-def test_pch_compile_command_rejects_unusable_entries(tmp_path: Path) -> None:
-    """Malformed DB shapes and command-less entries skip cleanly instead of
-    producing a compiler-less argv retried every build."""
-    from esphome.build_helpers.pch import pch_compile_command
-
-    build = tmp_path / "build"
-    build.mkdir()
-    header = build / "esphome_pch.h"
-    gch = build / "esphome_pch.h.gch"
-    db = build / "compile_commands.json"
-    src_file = str(tmp_path / "src" / "esphome" / "a.cpp")
-
-    db.write_text(json.dumps({"not": "a list"}))
-    assert pch_compile_command(build, header, gch) is None
-
-    db.write_text(json.dumps(["just a string"]))
-    assert pch_compile_command(build, header, gch) is None
-
-    # An empty-string directory must fall back to the build dir, not cwd
-    db.write_text(
-        json.dumps(
-            [
-                {
-                    "directory": "",
-                    "command": f"g++ -DX=1 -o a.obj -c {src_file}",
-                    "file": src_file,
-                }
-            ]
-        )
-    )
-    _, cmd_dir = pch_compile_command(build, header, gch)
-    assert cmd_dir == build
-
-    # Corrupted entries with null fields must skip, not raise
-    db.write_text(
-        json.dumps(
-            [
-                {"file": None, "command": "g++ -c x.cpp", "directory": None},
-                {"file": src_file, "command": None, "directory": None},
-            ]
-        )
-    )
-    assert pch_compile_command(build, header, gch) is None
-
-    # arguments-style entry (allowed by the spec, unused by CMake)
-    db.write_text(
-        json.dumps([{"arguments": ["g++", "-c", src_file], "file": src_file}])
-    )
-    assert pch_compile_command(build, header, gch) is None
-
-
-def test_pch_header_list_order_is_in_checksum(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """Reordering PCH_DEFAULT_HEADERS keeps the include closure identical, but the
-    generated header text differs, so the .gch must rebuild."""
-    import esphome.build_gen.espidf as espidf_mod
-
-    dev = _make_pch_device(tmp_path, "dev_r")
-    CORE.build_path = dev
-    gch = dev / "build" / "esphome_pch.h.gch"
-
-    def fake_compile(cmd, **kwargs):
-        gch.write_bytes(b"gch")
-        return subprocess.CompletedProcess(cmd, 0, "", "")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=fake_compile),
-    ):
-        espidf_mod.prepare_pch()
-        first = (dev / "build" / "esphome_pch.h.gch.sum").read_text()
-        monkeypatch.setattr(
-            espidf_mod,
-            "PCH_DEFAULT_HEADERS",
-            tuple(reversed(espidf_mod.PCH_DEFAULT_HEADERS)),
-        )
-        espidf_mod.prepare_pch()
-    assert (dev / "build" / "esphome_pch.h.gch.sum").read_text() != first
-
-
-def test_prepare_pch_failure_writes_marker_and_skips_retry(tmp_path: Path) -> None:
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_f")
-    CORE.build_path = dev
-    calls = []
-
-    def failing_compile(cmd, **kwargs):
-        calls.append(cmd)
-        return subprocess.CompletedProcess(cmd, 1, "", "boom")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=failing_compile),
-    ):
-        prepare_pch()
-        prepare_pch()
-    assert len(calls) == 1
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-    assert (dev / "build" / "esphome_pch.h.gch.failed").exists()
-
-
-def test_prepare_pch_spawn_oserror_is_transient(tmp_path: Path) -> None:
-    """Spawn/IO failures retry on the next build instead of latching."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_o")
-    CORE.build_path = dev
-    calls = []
-
-    def raising(cmd, **kwargs):
-        calls.append(cmd)
-        raise OSError("no such compiler")
-
-    header = dev / "build" / "esphome_pch.h"
-    before = header.stat().st_mtime_ns
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=raising),
-    ):
-        prepare_pch()
-        prepare_pch()
-    assert not (dev / "build" / "esphome_pch.h.gch.failed").exists()
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-    assert len(calls) == 2
-    # No .gch was ever in play, so the header must not be re-touched into
-    # forcing a full rebuild on every failing build
-    assert header.stat().st_mtime_ns == before
-
-
-def test_prepare_pch_transient_with_stale_gch_bumps_header(tmp_path: Path) -> None:
-    """A stale .gch removed on a transient failure must dirty its consumers."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_s")
-    CORE.build_path = dev
-    gch = dev / "build" / "esphome_pch.h.gch"
-    gch.write_bytes(b"stale")
-    header = dev / "build" / "esphome_pch.h"
-    os.utime(header, (1, 1))
-    with (
-        patch.object(CORE, "name", "test"),
-        patch(
-            "esphome.build_helpers.pch.subprocess.run",
-            side_effect=OSError("no such compiler"),
-        ),
-    ):
-        prepare_pch()
-    assert not gch.exists()
-    assert header.stat().st_mtime_ns > 1_000_000_000
-
-
-def test_prepare_pch_disabled_discards_and_skips_compile(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """The escape hatch is self-cleaning: a leftover .gch is removed."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    monkeypatch.setenv("ESPHOME_PCH_ENABLE", "0")
-    dev = _make_pch_device(tmp_path, "dev_d")
-    CORE.build_path = dev
-    stale = dev / "build" / "esphome_pch.h.gch"
-    stale.write_bytes(b"stale")
-    with patch("esphome.build_helpers.pch.subprocess.run", side_effect=AssertionError):
-        prepare_pch()
-    assert not stale.exists()
-
-
-def test_prepare_pch_missing_sdkconfig_fails_closed(tmp_path: Path) -> None:
-    """No sdkconfig means no config identity for the .sum: no pch at all."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_m")
-    (dev / "sdkconfig.test").unlink()
-    CORE.build_path = dev
-    stale = dev / "build" / "esphome_pch.h.gch"
-    stale.write_bytes(b"stale")
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=AssertionError),
-    ):
-        prepare_pch()
-    assert not stale.exists()
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-
-
-def test_prepare_pch_signal_kill_is_transient(tmp_path: Path) -> None:
-    """A signal-killed compile (OOM) must not latch the .failed marker."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_k")
-    CORE.build_path = dev
-    calls = []
-
-    def killed(cmd, **kwargs):
-        calls.append(cmd)
-        return subprocess.CompletedProcess(cmd, -9, "", "")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=killed),
-    ):
-        prepare_pch()
-        prepare_pch()
-    assert not (dev / "build" / "esphome_pch.h.gch.failed").exists()
-    assert len(calls) == 2
-
-
-def test_prepare_pch_without_compile_commands(tmp_path: Path) -> None:
-    """Stale checksum but no configured TU yet: no compile, no sidecars."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_n")
-    (dev / "build" / "compile_commands.json").unlink()
-    CORE.build_path = dev
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=AssertionError),
-    ):
-        prepare_pch()
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-    assert not (dev / "build" / "esphome_pch.h.gch.failed").exists()
-
-
-def test_write_project_pch_disabled_writes_no_header(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    from esphome.build_gen.espidf import write_project
-
-    monkeypatch.setenv("ESPHOME_PCH_ENABLE", "0")
-    _write_project_description(tmp_path, {})
-    CORE.build_path = tmp_path
-    with (
-        patch("esphome.build_gen.espidf.get_esp32_variant", return_value="ESP32"),
-        patch.object(CORE, "name", "test"),
-    ):
-        write_project()
-    assert not (tmp_path / "build" / "esphome_pch.h").exists()
-
-
-def test_write_project_writes_pch_header(tmp_path: Path) -> None:
-    """The header write_project emits is what _pch_cmake() force-includes;
-    this pairing is the one non-fail-safe path in the design."""
-    from esphome.build_gen.espidf import write_project
-    from esphome.build_helpers.pch import PCH_DEFAULT_HEADERS, pch_header_text
-
-    _write_project_description(tmp_path, {})
-    CORE.build_path = tmp_path
-    with (
-        patch("esphome.build_gen.espidf.get_esp32_variant", return_value="ESP32"),
-        patch.object(CORE, "name", "test"),
-    ):
-        write_project()
-    assert (tmp_path / "build" / "esphome_pch.h").read_text() == pch_header_text(
-        PCH_DEFAULT_HEADERS
-    )
-
-
-def test_prepare_pch_stale_bailout_removes_gch(tmp_path: Path) -> None:
-    """A stale .gch must not survive when no compile command is available."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_s")
-    CORE.build_path = dev
-    gch = dev / "build" / "esphome_pch.h.gch"
-    gch.write_bytes(b"stale")
-    (dev / "build" / "esphome_pch.h.gch.sum").write_text("stale-sum\n")
-    (dev / "build" / "compile_commands.json").unlink()
-    with patch.object(CORE, "name", "test"):
-        prepare_pch()
-    assert not gch.exists()
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-
-
-def test_prepare_pch_zero_exit_without_gch_is_failure(tmp_path: Path) -> None:
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_z")
-    CORE.build_path = dev
-
-    def no_output(cmd, **kwargs):
-        return subprocess.CompletedProcess(cmd, 0, "", "")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=no_output),
-    ):
-        prepare_pch()
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-    assert (dev / "build" / "esphome_pch.h.gch.failed").exists()
-
-
-def test_prepare_pch_bumps_header_for_object_depends(tmp_path: Path) -> None:
-    """The OBJECT_DEPENDS edge watches the header; a rebuilt .gch must bump
-    it so pch-consuming TUs recompile."""
-    import os as _os
-
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_t")
-    CORE.build_path = dev
-    header = dev / "build" / "esphome_pch.h"
-    gch = dev / "build" / "esphome_pch.h.gch"
-    _os.utime(header, (0, 0))
-    before = header.stat().st_mtime
-
-    def fake_compile(cmd, **kwargs):
-        gch.write_bytes(b"gch")
-        return subprocess.CompletedProcess(cmd, 0, "", "")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=fake_compile),
-    ):
-        prepare_pch()
-    assert header.stat().st_mtime > before
-
-
-def test_component_cmakelists_pch_object_depends() -> None:
-    from esphome.build_gen.espidf import get_component_cmakelists
-
-    content = get_component_cmakelists()
-    assert 'OBJECT_DEPENDS "${CMAKE_BINARY_DIR}/esphome_pch.h"' in content
-
-
-def test_prepare_pch_command_change_invalidates_sum(tmp_path: Path) -> None:
-    """A flag-only change in the compile DB must rebuild the .gch."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_c")
-    CORE.build_path = dev
-    gch = dev / "build" / "esphome_pch.h.gch"
-
-    def fake_compile(cmd, **kwargs):
-        gch.write_bytes(b"gch")
-        return subprocess.CompletedProcess(cmd, 0, "", "")
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=fake_compile),
-    ):
-        prepare_pch()
-        first = (dev / "build" / "esphome_pch.h.gch.sum").read_text()
-        db = dev / "build" / "compile_commands.json"
-        db.write_text(db.read_text().replace("-DX=1", "-DX=2"))
-        prepare_pch()
-    assert (dev / "build" / "esphome_pch.h.gch.sum").read_text() != first
-
-
-def test_prepare_pch_keeps_user_force_includes(tmp_path: Path) -> None:
-    from esphome.build_helpers.pch import pch_compile_command
-
-    dev = _make_pch_device(tmp_path, "dev_u")
-    CORE.build_path = dev
-    build = dev / "build"
-    src_file = str(dev / "src" / "esphome" / "a.cpp")
-    build.joinpath("compile_commands.json").write_text(
-        json.dumps(
-            [
-                {
-                    "directory": str(build),
-                    "command": (
-                        "g++ -include user.h -include esphome_pch.h "
-                        f"-o a.obj -c {src_file}"
-                    ),
-                    "file": src_file,
-                }
-            ]
-        )
-    )
-    cmd, _ = pch_compile_command(build, build / "esphome_pch.h", build / "x.gch")
-    assert "user.h" in cmd
-    assert "esphome_pch.h" not in " ".join(cmd[:-3])
-
-
-def test_prepare_pch_identity_unknown_discards(tmp_path: Path) -> None:
-    """An OSError from the checksum discards artifacts and skips the pch."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_i")
-    CORE.build_path = dev
-    stale = dev / "build" / "esphome_pch.h.gch"
-    stale.write_bytes(b"stale")
-    with (
-        patch.object(CORE, "name", "test"),
-        patch(
-            "esphome.build_helpers.pch.pch_checksum",
-            side_effect=OSError("stat failed"),
-        ),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=AssertionError),
-    ):
-        prepare_pch()
-    assert not stale.exists()
-    assert not (dev / "build" / "esphome_pch.h.gch.sum").exists()
-
-
-def test_prepare_pch_transient_compiler_failure_does_not_latch(
-    tmp_path: Path,
-) -> None:
-    """ENOSPC-style failures clear on their own; no .failed marker."""
-    from esphome.build_gen.espidf import prepare_pch
-
-    dev = _make_pch_device(tmp_path, "dev_e")
-    CORE.build_path = dev
-    calls = []
-
-    def enospc(cmd, **kwargs):
-        calls.append(cmd)
-        return subprocess.CompletedProcess(
-            cmd, 1, "", "fatal error: No space left on device"
-        )
-
-    with (
-        patch.object(CORE, "name", "test"),
-        patch("esphome.build_helpers.pch.subprocess.run", side_effect=enospc),
-    ):
-        prepare_pch()
-        prepare_pch()
-    assert not (dev / "build" / "esphome_pch.h.gch.failed").exists()
-    assert len(calls) == 2
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	c307706ae0	Point at can_proceed() for handshake-dependent flags	2026-09-10 09:01:09 -05:00
J. Nick Koston	cbd2645307	Keep writing the flag after setup, log that it stops working in 2027.3.0	2026-09-10 09:00:37 -05:00
J. Nick Koston	7b747bbd6b	Soften the set_internal() limitations wording	2026-09-10 08:56:35 -05:00
J. Nick Koston	b0bd118991	Recommend the YAML internal key over set_internal()	2026-09-10 08:54:55 -05:00
J. Nick Koston	77d6570605	Mark set_internal() as legacy support in the header comment	2026-09-10 08:51:42 -05:00
J. Nick Koston	db1dfff925	Correct set_internal() priority bound to AFTER_WIFI	2026-09-10 08:37:43 -05:00
J. Nick Koston	a368ad860a	Document set_internal() limitations inline	2026-09-10 08:26:16 -05:00
J. Nick Koston	fc59f6ca50	[core] Support set_internal() during setup, reject calls after setup	2026-09-10 08:19:16 -05:00
luar123	66f829c760	[zigbee] wake loop on defer/set_timeout (#19050 )	2026-09-10 08:08:07 -05:00
luar123	a88ec7d90b	[logger] Flush uart before sleep in idf 6 (#18975 )	2026-09-10 13:07:09 +00:00
luar123	54706e869c	[deep_sleep] disable loop (#18962 )	2026-09-10 07:18:15 -05:00
Anton Sergunov Jonathan Swoboda Jesse Hills	05f7d5e4f1	[mlx90614] pec validation (#6689 ) Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com> Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-10 16:14:43 +12:00
Robin ThoniandJesse Hills	ddbd89dd2a	[network] Improve `network::is_connected()` to better handle multiple interfaces (#18999 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-10 04:06:44 +00:00
Jesse Hills	5ed59af920	[template] Surface value metadata on template entity forms (#17545 )	2026-09-10 14:11:13 +12:00
Jesse Hills	4868b498cf	[ci] Ask stale PR authors to merge dev instead of rebasing (#19064 )	2026-09-10 14:09:58 +12:00
Jesse Hills	c66fa81208	[core] Consolidate setup scripts into a cross-platform setup.py (#18856 )	2026-09-10 14:09:49 +12:00
esphome[bot]	58ca345684	[ci] Refresh integration test durations (#19049 )	2026-09-09 13:42:09 -04:00
Remco van Essen	fd598057ef	[sendspin] Fix codec enum codegen when codecs is not set (#19055 )	2026-09-09 08:22:23 -04:00
Jesse Hills	ef7279341f	Merge branch 'beta' into dev	2026-09-09 12:18:55 +12:00
Jesse Hills	69f2a7d556	Merge pull request #19051 from esphome/bump-2026.9.0b3 2026.9.0b3	2026-09-09 12:18:36 +12:00
Jesse Hills	008677298a	Bump version to 2026.9.0b3	2026-09-09 09:54:44 +12:00
Kevin AhrendtandJesse Hills	d2bc056f0a	[sendspin] Add codec preference list to the media source (#19047 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-09 09:54:42 +12:00
J. Nick Koston	42fffd16fe	[esphome][core] Give a lost OTA chunk ack time to be retransmitted (#19041 )	2026-09-09 09:54:42 +12:00
J. Nick Koston	9c16aba6f7	[noise] Bump noise-c to 0.1.26 and libsodium to 1.10021.8 (#19030 )	2026-09-09 09:54:42 +12:00
Kevin Ahrendt	ac79173f4a	[i2s_audio] Fix spurious driver failure (#19045 )	2026-09-09 09:54:42 +12:00
Kevin Ahrendt	0a1e2acbcb	[audio][i2s_audio][micro_wake_word][microphone][mixer][resampler][speaker] Replace use_count() checks with lock and null test (#19046 )	2026-09-09 09:54:42 +12:00
Kevin AhrendtandCopilot Autofix powered by AI	9b6facb20d	[core] Fix use-after-free when deleting a running StaticTask (#19048 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-09-09 09:54:42 +12:00
esphome[bot]	f89b9e704c	Bump bundled esphome-device-builder to 1.14.5 (#19040 )	2026-09-09 09:54:42 +12:00
Johnandpre-commit-ci-lite[bot]	f8b2e53609	[atm90e32] Verify offset calibration writes (#18701 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-09 09:54:42 +12:00
raykholo	7660dd7fa7	[anova] Re-assert temperature unit on every poll cycle (#17141 )	2026-09-09 09:54:42 +12:00
Bryan Li Bryan Li Claude Fable 5	c3ce07755f	[rf_bridge] Fix bucket sniffing with Portisch firmware (#17683 ) Co-authored-by: Bryan Li <bryanli@Bryans-MacBook-Pro.local> Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-09-09 09:54:42 +12:00
Gytis	f8a4cfa945	[lvgl] Add missing label dependency to qrcode, keyboard and tabview (#18387 )	2026-09-09 09:54:42 +12:00
J. Nick Koston	866ddb6e57	[core] Skip PlatformIO's private-package authorization probe (#18823 )	2026-09-09 09:54:42 +12:00
Jonathan Swoboda	ca864c22b4	[tuya] Build without a network component (#18948 )	2026-09-09 09:54:42 +12:00
Jesse Hills	c9729244af	[udp] Use cv.invalid for relocated packet_transport options (#19032 )	2026-09-09 09:54:42 +12:00
Davide D M	442e4a1ec2	[debug] Check reboot source pref on ESP_RST_WDT and guard against empty source (#17537 )	2026-09-09 09:54:41 +12:00
Pieter ViljoenandJesse Hills	199acdf522	[ble_client] Report Established from nodes that never read services (#17920 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-09 09:54:41 +12:00
Samuel SiebandSamuel Sieb	9340863652	[dallas_temp] filter 85 temp from sensor reset (#17877 ) Co-authored-by: Samuel Sieb <samuel@sieb.net>	2026-09-09 09:54:41 +12:00
AndreKR	d5cff6e9df	[logger] Fix garbled stack traces (#17939 )	2026-09-09 09:54:41 +12:00
Ryan Ronnander	e7f45a0d31	[mqtt] Restore brightness flag in light discovery (#18950 )	2026-09-09 09:54:41 +12:00
mipa87andClaude	628ebe23ec	[audio] Do not treat MP3_STREAM_INFO_CHANGED as a fatal decoder error (#19028 ) Co-authored-by: Claude <noreply@anthropic.com>	2026-09-09 09:54:41 +12:00
mipa87 Claude pre-commit-ci-lite[bot]	823d79c948	[i2s_audio] Keep a start request that arrives while the speaker task stops (#19027 ) Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-09 09:54:41 +12:00
Kevin AhrendtandJesse Hills	b947094f45	[sendspin] Add codec preference list to the media source (#19047 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-09 09:31:18 +12:00
J. Nick Koston	6c5ab89d5f	[esphome][core] Give a lost OTA chunk ack time to be retransmitted (#19041 )	2026-09-09 09:08:16 +12:00
J. Nick Koston	8f511a365a	[noise] Bump noise-c to 0.1.26 and libsodium to 1.10021.8 (#19030 )	2026-09-09 09:07:06 +12:00
Kevin Ahrendt	006f31af93	[i2s_audio] Fix spurious driver failure (#19045 )	2026-09-09 09:05:02 +12:00
Kevin Ahrendt	5bb112f407	[audio][i2s_audio][micro_wake_word][microphone][mixer][resampler][speaker] Replace use_count() checks with lock and null test (#19046 )	2026-09-09 09:04:34 +12:00
dependabot[bot]	4ab9298ab3	Bump esptool from 5.3.1 to 5.4.0 (#19023 )	2026-09-08 22:11:36 +02:00
Kevin AhrendtandCopilot Autofix powered by AI	3926612281	[core] Fix use-after-free when deleting a running StaticTask (#19048 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-09-09 07:46:17 +12:00
J. Nick Koston	1ce0bed3f6	[core] Share compiled binaries across modbus integration tests (#18945 )	2026-09-08 18:10:45 +02:00