Use the computed name for download candidates too

.github/actions/cache-arduino8266/action.yml

@@ -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 }}

.github/workflows/ci.yml

@@ -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

esphome/__main__.py

@@ -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
 

esphome/arduino8266/toolchain.py

@@ -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,
-    )

esphome/build_helpers/idedata.py

@@ -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,30 +31,7 @@ IDEDATA_BEST_EFFORT_ERRORS = (
     ValueError,
 )
 
-
-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)
-
+_LOGGER = logging.getLogger(__name__)
 
 # C++ translation-unit suffixes used to identify ESPHome source files.
 _CXX_SUFFIXES = (".cpp", ".cc")

esphome/components/esp8266/__init__.py

@@ -3,7 +3,6 @@ from pathlib import Path
 import platform
 import re
 import subprocess
-import time
 from typing import Any
 
 import esphome.codegen as cg
@@ -15,7 +14,6 @@ from esphome.const import (
     CONF_FRAMEWORK,
     CONF_PLATFORM_VERSION,
     CONF_SOURCE,
-    CONF_TOOLCHAIN,
     CONF_VERSION,
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
@@ -23,7 +21,6 @@ from esphome.const import (
     KEY_TARGET_PLATFORM,
     PLATFORM_ESP8266,
     ThreadModel,
-    Toolchain,
 )
 from esphome.core import (
     CORE,
@@ -38,9 +35,8 @@ 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,
@@ -48,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,
@@ -108,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.
 
@@ -184,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:
@@ -246,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
@@ -269,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(
         {
@@ -289,6 +233,7 @@ ARDUINO_FRAMEWORK_SCHEMA = cv.All(
 )
 
 
+BUILD_FLASH_MODES = ["qio", "qout", "dio", "dout"]
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -305,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.
 
@@ -364,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])
@@ -386,32 +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.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
@@ -449,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"
     )
@@ -480,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]
@@ -490,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])
         )
@@ -531,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",
@@ -605,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)
@@ -743,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

esphome/components/esp8266/const.py

@@ -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")

esphome/core/config.py

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

esphome/platformio/prefetch.py

@@ -371,14 +371,27 @@ def _registry_jobs(
     return jobs, failed, installable
 
 
+def _is_vcs_spec_uri(url: str) -> bool:
+    """Whether pio's ``install_from_uri`` would clone this URI rather than
+    copy or download it (PackageSpec normalizes git URLs to ``git+``)."""
+    return not url.startswith(("file://", "symlink://", "http://", "https://"))
+
+
+def _spec_name(spec: Any, url: str) -> str:
+    """The spec's name; the URL basename fallback is defensive only
+    (PackageSpec derives a name from the URI itself)."""
+    return spec.name or url.split("#", 1)[0].rsplit("/", 1)[-1]
+
+
 def _uri_jobs(
     manager: Any, specs: list[Any], seen: set[str]
 ) -> tuple[list[tuple[str, int, Any]], int, list[tuple[str, Any]]]:
     """Jobs for direct-URL specs; a HEAD sizes each for the combined bar.
 
     Also returns how many HEAD probes errored (an absent length is not an
-    error) and the ``(name, spec)`` pairs whose archives will be
-    installable.
+    error) and the ``(name, spec)`` pairs to pre-install: downloaded
+    archives, plus VCS specs, which have no archive -- the pre-install
+    itself clones them, in parallel instead of one at a time in pio run.
     """
     from esphome.net_retry import fetch_with_retry, http_request
 
@@ -386,13 +399,17 @@ def _uri_jobs(
     installable: list[tuple[str, Any]] = []
     for spec in specs:
         url = spec.uri
-        if not url or not url.startswith(("http://", "https://")):
-            continue  # git+/file specs are cloned/copied, not downloaded
-        if url.split("#", 1)[0].endswith(".git"):
-            continue  # bare-URL VCS spec; PlatformIO clones it
+        if not url:
+            continue
+        is_vcs = _is_vcs_spec_uri(url)
+        if not is_vcs and not url.startswith(("http://", "https://")):
+            continue  # file/symlink specs are copied in place by pio run
         if manager.get_package(spec):
             continue
-        name = spec.name or url.rsplit("/", 1)[-1]
+        name = _spec_name(spec, url)
+        if is_vcs:
+            installable.append((name, spec))
+            continue
         # PlatformIO downloads URL specs with no checksum
         dl_path = Path(manager.compute_download_path(url, ""))
         if dl_path.is_file():
@@ -406,7 +423,7 @@ def _uri_jobs(
         if str(dl_path) in seen:
             continue  # another spec already claimed this .part
         seen.add(str(dl_path))
-        candidates.append((spec.name, url, dl_path, spec))
+        candidates.append((name, url, dl_path, spec))
 
     errors: list[str] = []
 
@@ -915,8 +932,14 @@ def _prefetch(build_dir: Path, env: str) -> None:
             if name not in failed_names
         }
         if to_install:
+            # Clones first: they wait on the network, so they must not
+            # queue behind CPU-bound archive extractions
+            ordered = sorted(
+                to_install.values(),
+                key=lambda entry: not ((url := entry[1].uri) and _is_vcs_spec_uri(url)),
+            )
             try:
-                _preinstall(mgr, list(to_install.values()))
+                _preinstall(mgr, ordered)
                 if is_platform:
                     platform_packages_installed = True
             except Exception as err:  # noqa: BLE001  # pylint: disable=broad-exception-caught

esphome/writer.py

@@ -610,15 +610,10 @@ def clean_build(clear_pio_cache: bool = True, *, full: bool = False):
                 _LOGGER.info("Deleting %s", idf_path)
                 rmtree(idf_path)
 
-    # 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()
 

script/determine-jobs.py

@@ -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),

script/test_build_components.py

@@ -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,
     )

tests/script/test_determine_jobs.py

@@ -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)]

tests/script/test_test_build_components.py

@@ -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

tests/unit_tests/components/esp8266/test_toolchain_validation.py

@@ -1,193 +0,0 @@
-"""Tests for the native (non-PlatformIO) toolchain config validation."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import patch
-
-import pytest
-
-from esphome.components import esp8266
-from esphome.components.esp8266 import (
-    ARDUINO_FRAMEWORK_SCHEMA,
-    _resolve_toolchain,
-    _validate_native_toolchain,
-)
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BOARD,
-    CONF_FRAMEWORK,
-    CONF_PLATFORM_VERSION,
-    CONF_SOURCE,
-    CONF_TOOLCHAIN,
-    CONF_VERSION,
-    Toolchain,
-)
-from esphome.core import CORE, EsphomeError
-from esphome.types import ConfigType
-
-
-@pytest.fixture(autouse=True)
-def _arduino_toolchain() -> Generator[None]:
-    # The suite-wide reset_core fixture clears CORE.toolchain after each test
-    CORE.toolchain = Toolchain.ARDUINO
-    esp8266._DECODE_WARNED_AT.clear()
-    yield
-    esp8266._DECODE_WARNED_AT.clear()
-
-
-def _config(
-    board: str = "nodemcuv2",
-    version: str = "3.1.2",
-    source: str | None = None,
-    platform_version: str | None = None,
-) -> ConfigType:
-    framework: dict[str, str] = {CONF_VERSION: version}
-    if source is not None:
-        framework[CONF_SOURCE] = source
-    if platform_version is not None:
-        framework[CONF_PLATFORM_VERSION] = platform_version
-    # The real schema fills the source/platform_version defaults, so these
-    # tests validate against what config validation actually emits
-    return {
-        CONF_FRAMEWORK: ARDUINO_FRAMEWORK_SCHEMA(framework),
-        CONF_BOARD: board,
-    }
-
-
-def test_valid_config_passes() -> None:
-    config = _config()
-    assert _validate_native_toolchain(config) is config
-
-
-def test_platformio_toolchain_skips_checks() -> None:
-    # 3.0.2 is pio-legal (>= the global 3.0.0 floor) but below the native
-    # toolchain's own 3.1.1 floor; the bogus board only the native path checks
-    CORE.toolchain = Toolchain.PLATFORMIO
-    config = _config(board="not_a_board", version="3.0.2")
-    assert _validate_native_toolchain(config) is config
-
-
-def test_version_below_floor_rejected() -> None:
-    # 3.1.0 has no registry package, so the native floor is 3.1.1
-    with pytest.raises(cv.Invalid, match="3.1.1 or newer"):
-        _validate_native_toolchain(_config(version="3.1.0"))
-
-
-def test_version_at_floor_accepted() -> None:
-    _validate_native_toolchain(_config(version="3.1.1"))
-
-
-def test_custom_platform_version_warns_and_is_dropped(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    config = _config(platform_version="platformio/espressif8266@4.0.1")
-    _validate_native_toolchain(config)
-    assert "'platform_version' is ignored" in caplog.text
-    assert CONF_PLATFORM_VERSION not in config[CONF_FRAMEWORK]
-
-
-def test_default_platform_version_does_not_warn(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    config = _config()
-    _validate_native_toolchain(config)
-    assert "'platform_version' is ignored" not in caplog.text
-    assert CONF_PLATFORM_VERSION not in config[CONF_FRAMEWORK]
-
-
-def test_custom_source_rejected() -> None:
-    with pytest.raises(cv.Invalid, match="custom framework source"):
-        _validate_native_toolchain(
-            _config(source="https://github.com/esp8266/Arduino.git")
-        )
-
-
-def test_unsupported_board_rejected() -> None:
-    with pytest.raises(cv.Invalid, match="not supported by"):
-        _validate_native_toolchain(_config(board="not_a_board"))
-
-
-def test_yaml_toolchain_key_resolves() -> None:
-    """The documented `toolchain: arduino` YAML key selects the native path."""
-    CORE.toolchain = None
-    _resolve_toolchain({CONF_TOOLCHAIN: Toolchain.ARDUINO})
-    assert CORE.toolchain == Toolchain.ARDUINO
-    assert CORE.using_toolchain_arduino
-
-
-def test_yaml_toolchain_key_defaults_to_platformio() -> None:
-    CORE.toolchain = None
-    _resolve_toolchain({})
-    assert CORE.toolchain == Toolchain.PLATFORMIO
-
-
-def test_decode_pc_native_missing_tools_warns_once(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A stack dump of many addresses produces one missing-tool warning."""
-
-    with (
-        patch(
-            "esphome.arduino8266.toolchain.get_addr2line_path",
-            return_value=tmp_path / "missing-addr2line",
-        ),
-        patch(
-            "esphome.arduino8266.toolchain.get_elf_path",
-            return_value=tmp_path / "missing.elf",
-        ),
-    ):
-        esp8266._decode_pc({}, "40201234")
-        esp8266._decode_pc({}, "40201238")
-    assert caplog.text.count("Cannot decode crash addresses") == 1
-
-
-def test_decode_pc_platformio_missing_tools_warns_once(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """The PlatformIO branch reports a missing addr2line/ELF at the same
-    warning level as the native one; raw undecoded addresses with no
-    stated reason are undiagnosable at default log level."""
-
-    CORE.toolchain = Toolchain.PLATFORMIO
-    idedata = SimpleNamespace(addr2line_path=None, firmware_elf_path=None)
-    with patch("esphome.platformio.toolchain.get_idedata", return_value=idedata):
-        esp8266._decode_pc({}, "40201234")
-        esp8266._decode_pc({}, "40201238")
-    assert caplog.text.count("Cannot decode crash addresses") == 1
-
-
-def test_resolve_toolchain_rejects_unsupported() -> None:
-    """ESP8266 rejects a CLI toolchain it cannot serve, like every platform."""
-
-    CORE.toolchain = Toolchain.SDK_NRF
-    with pytest.raises(cv.Invalid, match="Unsupported toolchain 'sdk-nrf'"):
-        _resolve_toolchain({})
-
-
-def test_run_compile_platformio_falls_through() -> None:
-    """Under toolchain: platformio the hook returns False without touching
-    the native backend; this is what keeps existing users on PlatformIO."""
-    CORE.toolchain = Toolchain.PLATFORMIO
-    with patch("esphome.arduino8266.toolchain.run_compile") as mock_native:
-        assert esp8266.run_compile(SimpleNamespace(), {}) is False
-    mock_native.assert_not_called()
-
-
-def test_run_compile_arduino_failure_raises() -> None:
-    """A non-zero native build fails by name instead of returning success."""
-    CORE.verbose = False
-    with (
-        patch("esphome.arduino8266.toolchain.run_compile", return_value=1),
-        pytest.raises(EsphomeError, match="native build failed"),
-    ):
-        esp8266.run_compile(SimpleNamespace(), {})
-
-
-def test_copy_files_native_skips_platformio_scripts(tmp_path: Path) -> None:
-    """The native build writes no PlatformIO extra scripts."""
-    CORE.build_path = tmp_path
-    esp8266.copy_files()
-    assert list(tmp_path.iterdir()) == []

tests/unit_tests/core/test_config.py

@@ -1429,3 +1429,12 @@ async def test_add_platformio_options_native_arduino(
     assert "board_build.ldscript is ignored" in caplog.text
     assert "'arduino' toolchain" in caplog.text
     assert "upload_speed" not in caplog.text
+
+
+def test_esp8266_rejects_unsupported_cli_toolchain() -> None:
+    """Until the native backend lands, ESP8266 serves only PlatformIO."""
+    from esphome.components.esp8266 import CONFIG_SCHEMA
+
+    CORE.toolchain = Toolchain.ARDUINO
+    with pytest.raises(cv.Invalid, match="Unsupported toolchain 'arduino'"):
+        CONFIG_SCHEMA({"board": "nodemcuv2"})

tests/unit_tests/fixtures/lazy_imports/native_upload_fast_path.py

@@ -1,65 +0,0 @@
-"""Run the native-toolchain serial-upload path and report heavy modules.
-
-Executed as a subprocess by test_lazy_imports.py: heavy module names come
-in on argv, the ones found in sys.modules afterwards go out on stdout.
-``upload_using_esptool`` dispatches native toolchains through a
-toolchain-keyed table; if someone routes it back through the platform
-component packages (esp32 or esp8266), this reports the leak.
-"""
-
-import os
-from pathlib import Path
-import sys
-import tempfile
-from unittest.mock import patch
-
-from _leak_report import print_leaked_modules
-
-from esphome.__main__ import upload_using_esptool
-from esphome.const import (
-    CONF_ESPHOME,
-    KEY_CORE,
-    KEY_ESP32,
-    KEY_TARGET_PLATFORM,
-    KEY_VARIANT,
-    Toolchain,
-)
-from esphome.core import CORE
-
-# An ambient ESPHOME_USE_SUBPROCESS would route past the patched
-# run_external_command into run_external_process and confuse the checks.
-os.environ.pop("ESPHOME_USE_SUBPROCESS", None)
-
-config = {CONF_ESPHOME: {"platformio_options": {}}}
-
-with tempfile.TemporaryDirectory() as build_dir:
-    CORE.name = "leaktest"
-    CORE.build_path = build_dir
-
-    for platform, toolchain, backend in (
-        ("esp8266", Toolchain.ARDUINO, "esphome.arduino8266.toolchain"),
-        ("esp32", Toolchain.ESP_IDF, "esphome.espidf.toolchain"),
-    ):
-        CORE.data[KEY_CORE] = {KEY_TARGET_PLATFORM: platform}
-        if platform == "esp32":
-            CORE.data[KEY_ESP32] = {KEY_VARIANT: "ESP32S3"}
-        CORE.toolchain = toolchain
-
-        import importlib
-
-        image = importlib.import_module(backend).get_factory_firmware_path()
-        image.parent.mkdir(parents=True, exist_ok=True)
-        image.write_bytes(b"\x00")
-
-        with patch("esphome.__main__.run_external_command", return_value=0) as mock_run:
-            rc = upload_using_esptool(config, "/dev/ttyUSB0", None, None)
-
-        # Fail loudly if the upload path stopped doing its work; otherwise
-        # an empty leak list could just mean nothing ran.
-        if rc != 0:
-            sys.exit(f"upload_using_esptool({platform}) returned {rc}")
-        cmd = list(mock_run.call_args[0][1:])
-        if str(image) not in [str(Path(c)) for c in cmd]:
-            sys.exit(f"native factory image did not reach esptool: {cmd}")
-
-print_leaked_modules()

tests/unit_tests/test_arduino8266_toolchain.py

@@ -1,631 +0,0 @@
-"""Tests for esphome.arduino8266.toolchain (the ninja build driver)."""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from esphome.arduino8266 import framework, toolchain
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_COMPILE_PROCESS_LIMIT,
-    CONF_ESPHOME,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
-)
-from esphome.core import CORE, EsphomeError
-
-_SIZE_OUTPUT = """\
-firmware.elf  :
-section       size    addr
-.data         1924    1073643520
-.noinit       56      1073645444
-.text         496     1074790400
-.irom0.text   342804  1075843088
-.text1        27489   1074790896
-.rodata       2588    1073645504
-.bss          26504   1073648096
-Total         401861
-"""
-
-
-@pytest.fixture(autouse=True)
-def _setup_core(tmp_path: Path) -> None:
-    CORE.name = "test8266"
-    CORE.config_path = tmp_path / "test8266.yaml"
-    CORE.build_path = tmp_path
-    CORE.data[KEY_CORE] = {KEY_FRAMEWORK_VERSION: cv.Version(3, 1, 2)}
-    # run_compile verifies the produced artifacts; give every test a build
-    # that "produced" them (tests for the guard delete them again). The
-    # manifest comes first: artifacts must not be older than build.ninja.
-    build_dir = CORE.relative_pioenvs_path("test8266")
-    build_dir.mkdir(parents=True, exist_ok=True)
-    (build_dir / "build.ninja").write_text("# manifest")
-    for artifact in (
-        "firmware.elf",
-        "firmware.bin",
-        "firmware.factory.bin",
-        "firmware.ota.bin",
-    ):
-        (build_dir / artifact).write_bytes(b"")
-
-
-def _paths(tmp_path: Path) -> framework.InstalledPaths:
-    return framework.InstalledPaths(
-        framework=tmp_path / "framework",
-        toolchain=tmp_path / "toolchain",
-        ninja=tmp_path / "ninja",
-    )
-
-
-def test_path_getters(tmp_path: Path) -> None:
-    assert toolchain.get_build_dir() == CORE.relative_pioenvs_path("test8266")
-    assert toolchain.get_elf_path().name == "firmware.elf"
-    # The framework accessor owns the layout and the Windows suffix
-    suffix = ".exe" if os.name == "nt" else ""
-    assert toolchain.get_addr2line_path().name == f"xtensa-lx106-elf-addr2line{suffix}"
-    assert toolchain.get_objdump_path().name == f"xtensa-lx106-elf-objdump{suffix}"
-    assert toolchain.get_readelf_path().name == f"xtensa-lx106-elf-readelf{suffix}"
-
-
-def test_run_compile_build_failure(tmp_path: Path) -> None:
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project"),
-        patch.object(
-            toolchain.subprocess, "run", return_value=MagicMock(returncode=2)
-        ) as mock_run,
-        patch.object(toolchain, "_write_compile_commands") as mock_compdb,
-    ):
-        assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=True) == 2
-    cmd = mock_run.call_args[0][0]
-    assert "-v" in cmd
-    # The compile database is generated before the build runs, so a failed
-    # build cannot leave a stale database behind.
-    mock_compdb.assert_called_once()
-
-
-def test_run_compile_success(tmp_path: Path) -> None:
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        # An unchanged manifest is what makes the -n probe run
-        patch("esphome.build_gen.arduino8266.write_project", return_value=False),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout="", stderr=""),
-        ) as mock_run,
-        patch.object(toolchain, "_write_compile_commands") as mock_compdb,
-        patch.object(toolchain, "_print_size_summary") as mock_size,
-        patch.object(toolchain, "get_idedata") as mock_idedata,
-    ):
-        rc = toolchain.run_compile(
-            {CONF_ESPHOME: {CONF_COMPILE_PROCESS_LIMIT: 4}}, verbose=False
-        )
-    assert rc == 0
-    # The -n probe runs first, then the real build (cwd, no -C banner)
-    ninja_calls = [c for c in mock_run.call_args_list if "ninja" in str(c[0][0][0])]
-    assert "-n" in ninja_calls[0][0][0]
-    # Explicit targets: a manifest missing them fails as "unknown target"
-    assert ninja_calls[0][0][0][-1] == "firmware.ota.bin"
-    cmd = ninja_calls[1][0][0]
-    assert cmd[-4:] == ["-j", "4", "firmware.factory.bin", "firmware.ota.bin"]
-    assert "-C" not in cmd
-    assert ninja_calls[1][1]["cwd"] is not None
-    mock_compdb.assert_called_once()
-    mock_size.assert_called_once()
-    mock_idedata.assert_called_once()
-
-
-def test_run_compile_noop_skips_the_build_spawn(tmp_path: Path) -> None:
-    """A no-op rebuild stays quiet: the -n probe answers "no work to do"
-    and the real ninja spawn (and its banner) never happens."""
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        # An unchanged manifest is what makes the -n probe run
-        patch("esphome.build_gen.arduino8266.write_project", return_value=False),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(
-                returncode=0, stdout="ninja: no work to do.\n", stderr=""
-            ),
-        ) as mock_run,
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary"),
-        patch.object(toolchain, "get_idedata"),
-    ):
-        rc = toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False)
-    assert rc == 0
-    ninja_calls = [c for c in mock_run.call_args_list if "ninja" in str(c[0][0][0])]
-    assert len(ninja_calls) == 1
-    assert "-n" in ninja_calls[0][0][0]
-    # Explicit targets: a manifest missing them fails as "unknown target"
-    assert ninja_calls[0][0][0][-1] == "firmware.ota.bin"
-
-
-def test_run_compile_regenerates_stale_compdb(tmp_path: Path) -> None:
-    """An interrupted run can leave build.ninja newer than the compile DB;
-    mere existence must not skip regeneration."""
-    build_dir = toolchain.get_build_dir()
-    build_dir.mkdir(parents=True, exist_ok=True)
-    (build_dir / "build.ninja").write_text("")
-    compdb = build_dir / "compile_commands.json"
-    compdb.write_text("[]")
-    os.utime(compdb, ((build_dir / "build.ninja").stat().st_mtime - 5,) * 2)
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project", return_value=False),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(
-                returncode=0, stdout="ninja: no work to do.\n", stderr=""
-            ),
-        ),
-        patch.object(toolchain, "_write_compile_commands") as mock_compdb,
-        patch.object(toolchain, "_print_size_summary"),
-        patch.object(toolchain, "get_idedata"),
-    ):
-        assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False) == 0
-    mock_compdb.assert_called_once()
-
-
-def test_run_compile_surfaces_probe_diagnostics(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A load-time ninja diagnostic (a generator bug signal) reaches the
-    user even when the no-work branch skips the real spawn."""
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        # An unchanged manifest is what makes the -n probe run
-        patch("esphome.build_gen.arduino8266.write_project", return_value=False),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(
-                returncode=0,
-                stdout="ninja: no work to do.\n",
-                stderr="ninja: warning: multiple rules generate x\n",
-            ),
-        ),
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary"),
-        patch.object(toolchain, "get_idedata"),
-    ):
-        rc = toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False)
-    assert rc == 0
-    assert "multiple rules generate x" in caplog.text
-
-
-def test_run_compile_missing_artifact_fails(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A zero ninja exit that produced no firmware must not be a green
-    build (size summary and idedata only warn)."""
-    (toolchain.get_build_dir() / "firmware.elf").unlink()
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project"),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout="", stderr=""),
-        ),
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary") as mock_size,
-        patch.object(toolchain, "get_idedata"),
-    ):
-        rc = toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False)
-    assert rc == 1
-    assert "Build produced no" in caplog.text
-    mock_size.assert_not_called()
-
-
-def test_run_compile_warns_when_idedata_fails(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A failed idedata generation right after a successful build is visible,
-    not deferred to a misleading error in a later command."""
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project"),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout="", stderr=""),
-        ),
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary"),
-        patch.object(toolchain, "get_idedata", return_value=None),
-    ):
-        assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False) == 0
-    assert "No idedata was generated for this build" in caplog.text
-
-
-def test_write_compile_commands(tmp_path: Path) -> None:
-    build_dir = tmp_path / "build"
-    build_dir.mkdir()
-    entries = '[{"file": "a.cpp", "command": "cc"}]\n'
-    with patch.object(
-        toolchain.subprocess,
-        "run",
-        return_value=MagicMock(returncode=0, stdout=entries),
-    ):
-        toolchain._write_compile_commands(tmp_path / "ninja", build_dir, {})
-    assert (build_dir / "compile_commands.json").read_text() == entries
-
-
-@pytest.mark.parametrize(
-    ("stdout", "match"),
-    [
-        ("[]\n", "empty compile database"),
-        # A parse failure names its cause, not the rule-name story
-        ("not json", "unparsable compile database.*not json"),
-    ],
-)
-def test_write_compile_commands_bad_db_raises(
-    tmp_path: Path, stdout: str, match: str
-) -> None:
-    """An empty or unparsable compile database fails the build with its
-    actual cause and drops any stale database."""
-    build_dir = tmp_path / "build"
-    build_dir.mkdir()
-    (build_dir / "compile_commands.json").write_text("[stale]")
-    with (
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout=stdout),
-        ),
-        pytest.raises(EsphomeError, match=match),
-    ):
-        toolchain._write_compile_commands(tmp_path / "ninja", build_dir, {})
-    assert not (build_dir / "compile_commands.json").exists()
-
-
-def test_write_compile_commands_failure_removes_stale_db(tmp_path: Path) -> None:
-    """A failed compdb run must not leave a stale database behind."""
-    stale = tmp_path / "compile_commands.json"
-    stale.write_text("[]")
-    with (
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=1, stderr="boom"),
-        ),
-        pytest.raises(EsphomeError, match="compile_commands"),
-    ):
-        toolchain._write_compile_commands(tmp_path / "ninja", tmp_path, {})
-    assert not stale.exists()
-
-
-def test_parse_app_size(tmp_path: Path) -> None:
-    ld = tmp_path / "eagle.flash.4m.ld"
-    ld.write_text("MEMORY\n{\n  irom0_0_seg :  org = 0x40201010, len = 0xfeff0\n}\n")
-    with patch("esphome.build_gen.arduino8266.get_flash_ld_path", return_value=ld):
-        assert toolchain._parse_app_size(tmp_path, _paths(tmp_path)) == 0xFEFF0
-
-    ld.write_text("MEMORY { }\n")
-    with patch("esphome.build_gen.arduino8266.get_flash_ld_path", return_value=ld):
-        assert toolchain._parse_app_size(tmp_path, _paths(tmp_path)) is None
-
-    # A zero-length segment is bad data, not a budget; warn and drop it
-    ld.write_text("MEMORY\n{\n  irom0_0_seg :  org = 0x40201010, len = 0x0\n}\n")
-    with patch("esphome.build_gen.arduino8266.get_flash_ld_path", return_value=ld):
-        assert toolchain._parse_app_size(tmp_path, _paths(tmp_path)) is None
-
-    with patch(
-        "esphome.build_gen.arduino8266.get_flash_ld_path",
-        return_value=tmp_path / "missing.ld",
-    ):
-        assert toolchain._parse_app_size(tmp_path, _paths(tmp_path)) is None
-
-
-def test_print_size_summary(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
-    with (
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout=_SIZE_OUTPUT),
-        ),
-        patch.object(toolchain, "_parse_app_size", return_value=1044464),
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    out = capsys.readouterr().out
-    # Exact PlatformIO shape so script/ci_memory_impact_extract.py can parse it
-    assert "RAM:   [====      ]  37.9% (used 31016 bytes from 81920 bytes)" in out
-    assert "Flash: [====      ]  35.9% (used 375301 bytes from 1044464 bytes)" in out
-
-
-def test_print_size_summary_missing_size_tool_warns(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A missing size binary degrades to a warning; the firmware already
-    linked and must not be discarded."""
-    with patch.object(
-        toolchain.subprocess, "run", side_effect=FileNotFoundError("no size")
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    assert "Could not summarize firmware size" in caplog.text
-
-
-def test_print_size_summary_no_app_size(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    with (
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout=_SIZE_OUTPUT),
-        ),
-        patch.object(toolchain, "_parse_app_size", return_value=None),
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    out = capsys.readouterr().out
-    # Both lines are skipped together: a RAM line without Flash would skew
-    # CI's memory-impact sums across builds
-    assert out == ""
-
-
-def test_print_size_summary_size_tool_failure(
-    tmp_path: Path,
-    capsys: pytest.CaptureFixture[str],
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    with patch.object(
-        toolchain.subprocess,
-        "run",
-        return_value=MagicMock(returncode=1, stdout="", stderr="bad elf"),
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    assert capsys.readouterr().out == ""
-    assert "Could not summarize firmware size" in caplog.text
-
-
-def test_get_idedata_delegates(tmp_path: Path) -> None:
-    with (
-        patch(
-            "esphome.build_helpers.idedata.load_or_build_idedata",
-            return_value={"cc_path": "x"},
-        ) as mock_load,
-        patch.object(toolchain, "resolve_ccache_path", return_value="/cc/ccache"),
-    ):
-        assert toolchain.get_idedata() == {"cc_path": "x"}
-    compile_commands, elf, cache = mock_load.call_args[0]
-    assert compile_commands.name == "compile_commands.json"
-    assert elf.name == "firmware.elf"
-    assert cache.name == "test8266.arduino.json"
-    # The exact configured launcher string is passed for compile DB parsing
-    # (resolve_ccache_path returns a str, untouched on every platform)
-    assert mock_load.call_args.kwargs["launcher"] == "/cc/ccache"
-
-
-def test_get_idedata_no_ccache(tmp_path: Path) -> None:
-    with (
-        patch(
-            "esphome.build_helpers.idedata.load_or_build_idedata", return_value={}
-        ) as mock_load,
-        patch.object(toolchain, "resolve_ccache_path", return_value=None),
-    ):
-        toolchain.get_idedata()
-    assert mock_load.call_args.kwargs["launcher"] is None
-
-
-def test_run_compile_skips_compdb_when_ninja_unchanged(tmp_path: Path) -> None:
-    """An unchanged build.ninja means the compile DB is already current."""
-    build_dir = toolchain.get_build_dir()
-    build_dir.mkdir(parents=True, exist_ok=True)
-    # write_project (stubbed below) always leaves a build.ninja behind
-    (build_dir / "build.ninja").write_text("# manifest")
-
-    def run(regenerate_expected: bool) -> None:
-        with (
-            patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-            patch.object(framework, "get_build_env", return_value={}),
-            patch("esphome.build_gen.arduino8266.write_project", return_value=False),
-            patch.object(
-                toolchain.subprocess,
-                "run",
-                return_value=MagicMock(returncode=0, stdout="", stderr=""),
-            ),
-            patch.object(toolchain, "_write_compile_commands") as mock_compdb,
-            patch.object(toolchain, "_print_size_summary"),
-            patch.object(toolchain, "get_idedata"),
-        ):
-            assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False) == 0
-        assert mock_compdb.called == regenerate_expected
-
-    # Missing compile DB: regenerated even though build.ninja is unchanged
-    run(regenerate_expected=True)
-    # Present compile DB + unchanged build.ninja: skipped
-    (build_dir / "compile_commands.json").write_text("[]")
-    run(regenerate_expected=False)
-
-
-def test_print_size_summary_unparsable_section(
-    tmp_path: Path,
-    capsys: pytest.CaptureFixture[str],
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A totals-relevant section that fails to parse must not produce a
-    confident wrong number; an irrelevant one only warns."""
-    bad = _SIZE_OUTPUT.replace(".bss          26504", ".bss          abc")
-    with patch.object(
-        toolchain.subprocess,
-        "run",
-        return_value=MagicMock(returncode=0, stdout=bad),
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    assert capsys.readouterr().out == ""
-    assert "Unparsable size output" in caplog.text
-
-    caplog.clear()
-    harmless = _SIZE_OUTPUT + ".broken   abc   0\n"
-    with (
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout=harmless),
-        ),
-        patch.object(toolchain, "_parse_app_size", return_value=1044464),
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    assert "RAM:" in capsys.readouterr().out
-    assert "Unparsable size output" in caplog.text
-
-
-def test_print_size_summary_missing_section_skips_summary(
-    tmp_path: Path,
-    capsys: pytest.CaptureFixture[str],
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A totals section absent from the output must not default to zero."""
-    without_bss = "\n".join(
-        line for line in _SIZE_OUTPUT.splitlines() if ".bss" not in line
-    )
-    with patch.object(
-        toolchain.subprocess,
-        "run",
-        return_value=MagicMock(returncode=0, stdout=without_bss),
-    ):
-        toolchain._print_size_summary(tmp_path, _paths(tmp_path))
-    assert capsys.readouterr().out == ""
-    assert "missing section(s) .bss" in caplog.text
-
-
-def test_warn_ignored_platformio_options(caplog: pytest.LogCaptureFixture) -> None:
-    """Component-added options the native build drops are warned by name;
-    the honored ones (lib_ignore, f_cpu, ldscript, build_src_flags,
-    flash_mode) stay quiet."""
-    CORE.platformio_options = {
-        "board_build.ldscript": "eagle.flash.4m2m.ld",
-        "board_build.f_cpu": "160000000L",
-        "board_build.filesystem": "littlefs",
-        "board_build.flash_mode": "dio",
-        "build_src_flags": "-include throw_stubs.h",
-        "lib_ignore": ["Updater"],
-        "upload_speed": "460800",
-    }
-    toolchain._warn_ignored_platformio_options()
-    assert "platformio_options->board_build.filesystem is ignored" in caplog.text
-    assert "native 'arduino' toolchain" in caplog.text
-    assert "board_build.ldscript is ignored" not in caplog.text
-    assert "board_build.f_cpu is ignored" not in caplog.text
-    assert "lib_ignore" not in caplog.text
-    assert "build_src_flags" not in caplog.text
-    assert "flash_mode" not in caplog.text
-    # Component-added upload_speed never gets read under the native
-    # toolchain, so it must warn
-    assert "upload_speed" in caplog.text
-
-
-def test_run_compile_idedata_error_does_not_fail_build(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """An unusable compile DB after a successful build warns, never fails."""
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project"),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout="", stderr=""),
-        ),
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary"),
-        patch.object(
-            toolchain,
-            "get_idedata",
-            side_effect=EsphomeError("compile database is unusable"),
-        ),
-    ):
-        assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False) == 0
-    assert "Could not generate idedata: compile database is unusable" in caplog.text
-
-
-def test_run_compile_skipped_size_summary_names_consequence(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A skipped RAM/Flash summary warns about the missing metric; the
-    per-cause warnings alone are invisible to CI harnesses."""
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project"),
-        patch.object(
-            toolchain.subprocess,
-            "run",
-            return_value=MagicMock(returncode=0, stdout="", stderr=""),
-        ),
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary", return_value=False),
-        patch.object(toolchain, "get_idedata", return_value=None),
-    ):
-        assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False) == 0
-    assert "Firmware size summary unavailable for this build" in caplog.text
-
-
-def test_parse_app_size_non_utf8_ld_warns(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A corrupt (non-UTF-8) linker script degrades to the same warning as
-    an unreadable one, never a traceback after a successful link."""
-    paths = _paths(tmp_path)
-    ld = tmp_path / "corrupt.ld"
-    ld.write_bytes(b"\xff\xfe not utf8")
-    with patch("esphome.build_gen.arduino8266.get_flash_ld_path", return_value=ld):
-        assert toolchain._parse_app_size(tmp_path, paths) is None
-    assert "Cannot read linker script" in caplog.text
-
-
-def test_run_compile_failed_probe_runs_full_build(tmp_path: Path) -> None:
-    """A failing -n probe (e.g. unknown target from a defective manifest)
-    falls through to the real build so the error prints attributably."""
-    probe = MagicMock(returncode=1, stdout="", stderr="")
-    ok = MagicMock(returncode=0, stdout="", stderr="")
-
-    def fake_run(cmd, *args, **kwargs):
-        return probe if "-n" in cmd else ok
-
-    with (
-        patch.object(framework, "check_and_install", return_value=_paths(tmp_path)),
-        patch.object(framework, "get_build_env", return_value={}),
-        patch("esphome.build_gen.arduino8266.write_project", return_value=False),
-        patch.object(toolchain.subprocess, "run", side_effect=fake_run) as mock_run,
-        patch.object(toolchain, "_write_compile_commands"),
-        patch.object(toolchain, "_print_size_summary", return_value=True),
-        patch.object(toolchain, "get_idedata", return_value={}),
-    ):
-        assert toolchain.run_compile({CONF_ESPHOME: {}}, verbose=False) == 0
-    # The real build ran after the failed probe
-    assert any(
-        "firmware.ota.bin" in c[0][0] and "-n" not in c[0][0]
-        for c in mock_run.call_args_list
-    )
-
-
-def test_get_idedata_accepts_preresolved_ccache() -> None:
-    """run_compile threads its resolved ccache through; the probe must not
-    run again."""
-    with (
-        patch(
-            "esphome.build_helpers.idedata.load_or_build_idedata",
-            return_value={"ok": True},
-        ) as mock_build,
-        patch.object(toolchain, "resolve_ccache_path") as mock_resolve,
-    ):
-        assert toolchain.get_idedata("/usr/bin/ccache") == {"ok": True}
-    mock_resolve.assert_not_called()
-    assert mock_build.call_args.kwargs["launcher"] == "/usr/bin/ccache"

tests/unit_tests/test_lazy_imports.py

@@ -175,27 +175,6 @@ def test_esptool_upload_fast_path_does_not_import_heavy_modules(
     )
 
 
-def test_native_upload_fast_path_does_not_import_heavy_modules(
-    fixture_path: Path,
-    probe_env: dict[str, str],
-) -> None:
-    """The native-toolchain serial upload dispatches through a
-    toolchain-keyed backend table; resolving the flash image must not drag
-    in the esp32 or esp8266 component package or the validation stack.
-    """
-    leaked = _leaked_from_fixture(
-        fixture_path,
-        probe_env,
-        "native_upload_fast_path.py",
-        extra=("esphome.components.esp8266",),
-    )
-    assert not leaked, (
-        f"native upload_using_esptool pulls in heavy modules: {leaked}. "
-        "The upload fast path skips validation; importing a platform "
-        "component package executes its codegen module by design."
-    )
-
-
 def test_api_client_does_not_import_heavy_modules() -> None:
     """``esphome.api_client`` is on the logs fast path and must stay light.
 

tests/unit_tests/test_main.py

@@ -13,7 +13,7 @@ import sys
 import time
 from types import SimpleNamespace
 from typing import Any, Self
-from unittest.mock import AsyncMock, MagicMock, Mock, PropertyMock, patch
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
 import pytest
 from pytest import CaptureFixture
@@ -25,7 +25,6 @@ from esphome.__main__ import (
     Purpose,
     _get_configured_xtal_freq,
     _make_crystal_freq_callback,
-    _native_toolchain_module,
     _redact_with_legacy_fallback,
     _resolve_network_devices,
     _should_subscribe_states,
@@ -7133,7 +7132,7 @@ def test_command_run_rp2040_bootsel_redetects_serial_port() -> None:
 
 def test_command_idedata_esp_idf_prints_json(capsys: CaptureFixture) -> None:
     """Under the native ESP-IDF toolchain, idedata is emitted as JSON."""
-    setup_core(platform=PLATFORM_ESP32)
+    setup_core()
     CORE.toolchain = Toolchain.ESP_IDF
     data = {"cxx_path": "g++", "prog_path": "/build/firmware.elf"}
 
@@ -7147,7 +7146,7 @@ def test_command_idedata_esp_idf_prints_json(capsys: CaptureFixture) -> None:
 
 def test_command_idedata_esp_idf_no_build_errors() -> None:
     """Under ESP-IDF, a missing build (no idedata) returns an error, not a crash."""
-    setup_core(platform=PLATFORM_ESP32)
+    setup_core()
     CORE.toolchain = Toolchain.ESP_IDF
 
     with patch("esphome.espidf.toolchain.get_idedata", return_value=None):
@@ -7321,201 +7320,6 @@ def test_warn_source_tree_mismatch_falls_back_when_stat_fails(
     assert not caplog.text
 
 
-def test_upload_using_esptool_arduino_toolchain(
-    tmp_path: Path,
-    mock_run_external_command_main: Mock,
-) -> None:
-    """The native ESP8266 Arduino toolchain flashes its factory image at
-    0x0, resolved from the toolchain-keyed backend table (deliberately not
-    the platform hook: that import would break the upload fast path)."""
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path, name="test")
-    CORE.toolchain = Toolchain.ARDUINO
-    from esphome.arduino8266 import toolchain as native
-
-    factory = native.get_factory_firmware_path()
-    factory.parent.mkdir(parents=True, exist_ok=True)
-    factory.touch()
-
-    config = {CONF_ESPHOME: {"platformio_options": {}}}
-    result = upload_using_esptool(config, "/dev/ttyUSB0", None, None)
-
-    assert result == 0
-    cmd_list = list(mock_run_external_command_main.call_args[0][1:])
-    firmware_offset_idx = cmd_list.index("write-flash") + 4
-    assert cmd_list[firmware_offset_idx] == "0x0"
-    assert cmd_list[firmware_offset_idx + 1] == str(factory)
-
-
-@pytest.mark.parametrize(
-    ("toolchain", "pio_project_written"),
-    [
-        # The native toolchain generates its project at compile time, so
-        # write_cpp_file must not write a platformio.ini; the default
-        # toolchain writes the PlatformIO project files.
-        (Toolchain.ARDUINO, False),
-        (None, True),
-    ],
-)
-def test_write_cpp_file_project_generation_follows_toolchain(
-    tmp_path: Path, toolchain: Toolchain | None, pio_project_written: bool
-) -> None:
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path, name="test")
-    CORE.toolchain = toolchain
-
-    with (
-        patch("esphome.writer.write_cpp") as mock_write_cpp,
-        patch("esphome.build_gen.platformio.write_project") as mock_pio_project,
-        patch.object(
-            type(CORE), "cpp_main_section", new_callable=PropertyMock
-        ) as mock_section,
-    ):
-        mock_section.return_value = ""
-        assert main.write_cpp_file() == 0
-
-    mock_write_cpp.assert_called_once()
-    assert mock_pio_project.called is pio_project_written
-
-
-def test_command_idedata_arduino_prints_json(
-    tmp_path: Path, capsys: CaptureFixture
-) -> None:
-    """Under the native ESP8266 Arduino toolchain, idedata is emitted as JSON."""
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path)
-    CORE.toolchain = Toolchain.ARDUINO
-    data = {"cxx_path": "g++", "prog_path": "/build/firmware.elf"}
-
-    with patch(
-        "esphome.arduino8266.toolchain.get_idedata", return_value=data
-    ) as mock_get:
-        result = command_idedata(MagicMock(), CORE.config)
-
-    assert result == 0
-    mock_get.assert_called_once_with()
-    assert json.loads(capsys.readouterr().out) == data
-
-
-def test_command_idedata_arduino_no_build_errors(tmp_path: Path) -> None:
-    """A missing native build (no idedata) returns an error, not a crash."""
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path)
-    CORE.toolchain = Toolchain.ARDUINO
-
-    with patch("esphome.arduino8266.toolchain.get_idedata", return_value=None):
-        result = command_idedata(MagicMock(), CORE.config)
-
-    assert result == 1
-
-
-@pytest.mark.parametrize(
-    ("platform", "toolchain", "module"),
-    [
-        (PLATFORM_ESP8266, Toolchain.ARDUINO, "esphome.arduino8266.toolchain"),
-        (PLATFORM_ESP32, Toolchain.ESP_IDF, "esphome.espidf.toolchain"),
-    ],
-)
-def test_command_analyze_memory_native_toolchains(
-    tmp_path: Path,
-    mock_write_cpp: Mock,
-    mock_compile_program: Mock,
-    mock_get_esphome_components: Mock,
-    mock_memory_analyzer_cli: Mock,
-    mock_ram_strings_analyzer: Mock,
-    platform: str,
-    toolchain: Toolchain,
-    module: str,
-) -> None:
-    """analyze-memory uses the native toolchain's binutils instead of
-    falling into the PlatformIO branch."""
-    setup_core(platform=platform, tmp_path=tmp_path, name="test_device")
-    CORE.toolchain = toolchain
-
-    config = {CONF_ESPHOME: {CONF_NAME: "test_device"}}
-    # The tools must exist: a missing binutils now fails by name instead of
-    # silently falling back to host tools
-    objdump = tmp_path / "objdump"
-    readelf = tmp_path / "readelf"
-    objdump.write_text("")
-    readelf.write_text("")
-    # The ELF must exist too: the analyzer swallows tool failures, so a
-    # missing image would report zeroes with exit 0
-    firmware_elf = tmp_path / "firmware.elf"
-    firmware_elf.write_text("")
-    with (
-        patch(f"{module}.get_objdump_path", return_value=objdump),
-        patch(f"{module}.get_readelf_path", return_value=readelf),
-        patch(f"{module}.get_elf_path", return_value=firmware_elf),
-    ):
-        result = command_analyze_memory(MockArgs(), config)
-
-    assert result == 0
-    mock_memory_analyzer_cli.assert_called_once_with(
-        str(firmware_elf),
-        str(objdump),
-        str(readelf),
-        set(),
-        idedata=None,
-    )
-
-
-def test_command_analyze_memory_native_missing_elf_fails(
-    tmp_path: Path,
-    mock_write_cpp: Mock,
-    mock_compile_program: Mock,
-    mock_get_esphome_components: Mock,
-    mock_memory_analyzer_cli: Mock,
-    mock_ram_strings_analyzer: Mock,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A missing firmware.elf fails by name instead of an exit-0 zeroed
-    report."""
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path, name="test_device")
-    CORE.toolchain = Toolchain.ARDUINO
-
-    config = {CONF_ESPHOME: {CONF_NAME: "test_device"}}
-    objdump = tmp_path / "objdump"
-    readelf = tmp_path / "readelf"
-    objdump.write_text("")
-    readelf.write_text("")
-    module = "esphome.arduino8266.toolchain"
-    with (
-        patch(f"{module}.get_objdump_path", return_value=objdump),
-        patch(f"{module}.get_readelf_path", return_value=readelf),
-        patch(f"{module}.get_elf_path", return_value=tmp_path / "missing.elf"),
-    ):
-        result = command_analyze_memory(MockArgs(), config)
-
-    assert result == 1
-    assert "compile the configuration first" in caplog.text
-    mock_memory_analyzer_cli.assert_not_called()
-
-
-def test_command_analyze_memory_missing_binutils_fails_by_name(
-    tmp_path: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """A truncated toolchain install fails naming the missing tool instead
-    of silently analyzing with host binutils."""
-    setup_core(platform="esp8266", tmp_path=tmp_path, name="test_device")
-    CORE.toolchain = Toolchain.ARDUINO
-    config = {CONF_ESPHOME: {CONF_NAME: "test_device"}}
-    module = "esphome.arduino8266.toolchain"
-    with (
-        patch(f"{module}.get_objdump_path", return_value=tmp_path / "missing-objdump"),
-        patch(f"{module}.get_readelf_path", return_value=tmp_path / "readelf"),
-        patch("esphome.__main__.write_cpp", return_value=0),
-        patch("esphome.__main__.compile_program", return_value=0),
-    ):
-        assert command_analyze_memory(MockArgs(), config) == 1
-    assert "missing-objdump" in caplog.text
-    assert "toolchain install may be incomplete" in caplog.text
-
-
-def test_command_idedata_incompatible_toolchain(tmp_path: Path) -> None:
-    """A non-native, non-platformio toolchain errors out cleanly."""
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path)
-    CORE.toolchain = Toolchain.SDK_NRF
-
-    assert command_idedata(MagicMock(), CORE.config) == 1
-
-
 @pytest.mark.parametrize(
     "error",
     [
@@ -7592,46 +7396,6 @@ def test_compile_program_espidf_idedata_none_warns(
     assert "No idedata was generated" in caplog.text
 
 
-def test_native_toolchain_table_serves_every_native_toolchain() -> None:
-    """Every member of NATIVE_TOOLCHAINS has a backend entry; a gap would
-    surface as a targeted EsphomeError on the one affected config, and this
-    pin keeps the table from drifting when a toolchain is added."""
-    from esphome.const import NATIVE_TOOLCHAINS
-
-    assert {tc for _, tc in main._NATIVE_TOOLCHAIN_MODULES} == set(NATIVE_TOOLCHAINS)
-
-
-def test_native_toolchain_module_missing_backend_raises(tmp_path: Path) -> None:
-    """A native toolchain missing from the backend table is a bug and must
-    fail, not silently degrade to the PlatformIO path."""
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path, name="test_device")
-    CORE.toolchain = Toolchain.ARDUINO
-    with (
-        patch.dict(main._NATIVE_TOOLCHAIN_MODULES, clear=True),
-        pytest.raises(EsphomeError, match="no native build backend"),
-    ):
-        _native_toolchain_module()
-
-
-def test_command_analyze_memory_unsupported_toolchain(
-    tmp_path: Path,
-    mock_write_cpp: Mock,
-    mock_compile_program: Mock,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A hook-less non-PlatformIO toolchain is refused by name, never routed
-    into the PlatformIO branch."""
-    setup_core(platform=PLATFORM_NRF52, tmp_path=tmp_path, name="test_device")
-    CORE.toolchain = Toolchain.SDK_NRF
-    mock_write_cpp.return_value = 0
-    mock_compile_program.return_value = 0
-
-    result = command_analyze_memory(MockArgs(), {CONF_ESPHOME: {CONF_NAME: "t"}})
-
-    assert result == 1
-    assert "analyze-memory is not supported" in caplog.text
-
-
 def test_cli_toolchain_skips_the_validated_config_cache(tmp_path: Path) -> None:
     """An explicit --toolchain must run the per-platform validators, so the
     upload/logs fast path becomes a cache miss."""
@@ -7647,29 +7411,6 @@ def test_cli_toolchain_skips_the_validated_config_cache(tmp_path: Path) -> None:
     mock_read.assert_called_once()
 
 
-def test_upload_using_esptool_native_missing_firmware_raises(
-    tmp_path: Path,
-) -> None:
-    """A stale or absent firmware.bin fails by name instead of flashing air."""
-    setup_core(platform=PLATFORM_ESP8266, tmp_path=tmp_path, name="test")
-    CORE.toolchain = Toolchain.ARDUINO
-    with pytest.raises(EsphomeError, match="compile the configuration first"):
-        upload_using_esptool(
-            {CONF_ESPHOME: {"platformio_options": {}}}, "/dev/ttyUSB0", None, None
-        )
-
-
-def test_compile_program_unclaimed_native_toolchain_raises(
-    tmp_path: Path,
-) -> None:
-    """A resolved native toolchain no platform backend claims must fail,
-    never fall through to the PlatformIO project path."""
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test_device")
-    CORE.toolchain = Toolchain.ARDUINO  # esp32 has no arduino-native backend
-    with pytest.raises(EsphomeError, match="no platform backend claimed"):
-        compile_program(MockArgs(), {})
-
-
 def test_cli_toolchain_still_refreshes_the_validated_config_cache(
     tmp_path: Path,
 ) -> None:

tests/unit_tests/test_platformio_prefetch.py

@@ -661,7 +661,8 @@ def test_registry_jobs_one_bad_spec_keeps_the_rest(tmp_path: Path) -> None:
 
 
 def test_uri_jobs_head_sizes_the_bar(tmp_path: Path) -> None:
-    """HEAD sizes direct-URL specs; git and unreachable URLs are skipped."""
+    """HEAD sizes direct-URL specs; VCS specs skip the download but are
+    still installable (the pre-install clones them in parallel)."""
     m = _fake_manager(tmp_path)
     resp = MagicMock()
     resp.headers = {"content-length": "2222"}
@@ -671,14 +672,13 @@ def test_uri_jobs_head_sizes_the_bar(tmp_path: Path) -> None:
             [
                 _FakeSpec(uri="https://x/big.zip", name="big", custom_name=True),
                 _FakeSpec(uri="git+https://x/repo.git", name="repo"),
-                _FakeSpec(uri="https://x/repo.git#v1", name="barevcs"),
                 _FakeSpec(name="registry"),
             ],
             set(),
         )
     assert failed == 0
     assert [(n, s) for n, s, _ in jobs] == [("big", 2222)]
-    assert [n for n, _ in installable] == ["big"]
+    assert [n for n, _ in installable] == ["repo", "big"]
     # a successful HEAD with no Content-Length is a clean skip
     resp.headers = {}
     with patch("esphome.net_retry.http_request", return_value=resp):
@@ -687,6 +687,35 @@ def test_uri_jobs_head_sizes_the_bar(tmp_path: Path) -> None:
         ) == ([], 0, [])
 
 
+def test_uri_jobs_vcs_specs_installable_without_probe(tmp_path: Path) -> None:
+    """VCS specs never probe the network here (there is no archive); an
+    uninstalled one is handed to the pre-install, an installed one and
+    file/symlink specs are skipped."""
+    m = _fake_manager(tmp_path)
+    with patch("esphome.net_retry.http_request") as mock_head:
+        jobs, failed, installable = pf._uri_jobs(
+            m,
+            [
+                _FakeSpec(uri="git+https://x/tool.git#1.0", name="tool"),
+                _FakeSpec(uri="hg+https://x/old", name="mercurial"),
+                # Name falls back to the URL basename, fragment excluded
+                _FakeSpec(uri="git+https://x/noname#v2", name=None),
+                _FakeSpec(uri="file:///local/dir", name="local"),
+                _FakeSpec(uri="symlink:///local/dir", name="link"),
+            ],
+            set(),
+        )
+    mock_head.assert_not_called()
+    assert (jobs, failed) == ([], 0)
+    assert [n for n, _ in installable] == ["tool", "mercurial", "noname"]
+
+    m.get_package.return_value = object()  # already installed: warm and silent
+    with patch("esphome.net_retry.http_request"):
+        assert pf._uri_jobs(
+            m, [_FakeSpec(uri="git+https://x/tool.git#1.0", name="tool")], set()
+        ) == ([], 0, [])
+
+
 def test_uri_jobs_head_failure_counts_as_unresolved(
     tmp_path: Path, caplog: pytest.LogCaptureFixture
 ) -> None:
@@ -1890,3 +1919,9 @@ def test_platformio_private_api_contract() -> None:
     derived = PackageSpec("https://x/y/archive/master.zip")
     assert derived.name and not derived.has_custom_name()
     assert PackageSpec("Foo=https://x/y/archive/master.zip").has_custom_name()
+    # _is_vcs_spec_uri relies on bare .git URLs normalizing to git+, on
+    # both parse paths (raw string, and requirements= for platform tools)
+    assert PackageSpec("https://github.com/x/y.git#v1").uri.startswith("git+")
+    assert PackageSpec(
+        owner="o", name="tool-x", requirements="https://github.com/x/y.git"
+    ).uri.startswith("git+")

tests/unit_tests/test_writer.py

@@ -516,13 +516,10 @@ def test_clean_build(
     dependencies_lock = tmp_path / "dependencies.lock"
     dependencies_lock.write_text("lock file")
 
-    # idedata caches live under the data dir, not the build path; the
-    # .arduino.json variant is the native esp8266 toolchain's.
+    # idedata cache lives under the data dir, not the build path.
     idedata_cache = tmp_path / "idedata" / "test.json"
     idedata_cache.parent.mkdir()
     idedata_cache.write_text("{}")
-    arduino_idedata_cache = tmp_path / "idedata" / "test.arduino.json"
-    arduino_idedata_cache.write_text("{}")
 
     # Native ESP-IDF toolchain artifacts.
     idf_build_dir = tmp_path / "build"
@@ -583,7 +580,6 @@ def test_clean_build(
     assert not piolibdeps_dir.exists()
     assert not dependencies_lock.exists()
     assert not idedata_cache.exists()
-    assert not arduino_idedata_cache.exists()
     assert not idf_build_dir.exists()
     assert not managed_components_dir.exists()
     assert not pio_components_dir.exists()