@@ -0,0 +1,111 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Add a `compote component pack` archive to a local file:// component mirror.
+
+Writes the layout `compote registry sync` produces:
+  <mirror>/components/<namespace>/<name>.json
+  <mirror>/components/<namespace>/<name>/<version>/<archive>, CHECKSUMS.json
+so that a project with IDF_COMPONENT_STORAGE_URL=file://<mirror> resolves
+<namespace>/<name> exactly as it would from the registry.
+"""
+
+import argparse
+import json
+import shutil
+import tarfile
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+from idf_component_tools.hash_tools.calculate import hash_dir
+from idf_component_tools.hash_tools.checksums import ChecksumsManager
+from idf_component_tools.manager import ManifestManager
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("archive", type=Path)
+    parser.add_argument("mirror", type=Path)
+    parser.add_argument("--namespace", required=True)
+    parser.add_argument("--name", required=True)
+    args = parser.parse_args()
+    archive, mirror = args.archive.resolve(), args.mirror.resolve()
+
+    with tempfile.TemporaryDirectory() as tmp:
+        with tarfile.open(archive) as tf:
+            tf.extractall(tmp, filter="data")
+        manifest = ManifestManager(tmp, args.name).load()
+        component_hash = hash_dir(
+            tmp,
+            use_gitignore=manifest.use_gitignore,
+            include=manifest.include_set,
+            exclude=set(manifest.exclude_set)
+            | {"**/.component_hash", "**/CHECKSUMS.json"},
+            exclude_default=False,
+        )
+        version = str(manifest.version)
+        rel_dir = Path("components") / args.namespace / args.name / version
+        (mirror / rel_dir).mkdir(parents=True, exist_ok=True)
+        shutil.copy2(archive, mirror / rel_dir / archive.name)
+        ChecksumsManager(Path(tmp)).dump(mirror / rel_dir)
+
+    dependencies = []
+    for requirement in manifest.requirements:
+        namespace, _, name = requirement.name.rpartition("/")
+        is_idf = requirement.source.type == "idf"
+        dependencies.append(
+            {
+                "spec": requirement.version_spec,
+                "source": requirement.source.type,
+                "registry_url": None,
+                "is_public": requirement.is_public,
+                "require": requirement.is_required,
+                "name": None if is_idf else name,
+                "namespace": None if is_idf else namespace,
+                "rules": [],
+                "matches": [],
+            }
+        )
+    created_at = datetime.now(timezone.utc).isoformat()
+    entry = {
+        "id": "local",
+        "version": version,
+        "created_at": created_at,
+        "description": manifest.description,
+        "component_hash": component_hash,
+        "url": (rel_dir / archive.name).as_posix(),
+        "targets": list(manifest.targets or []),
+        "maintainers": [],
+        "docs": {},
+        "dependencies": dependencies,
+        "license": None,
+        "examples": [],
+        "tags": [],
+        "checksums": (rel_dir / "CHECKSUMS.json").as_posix(),
+        "yanked_at": None,
+        "yanked_message": None,
+    }
+    index = mirror / "components" / args.namespace / f"{args.name}.json"
+    data = (
+        json.loads(index.read_text())
+        if index.exists()
+        else {
+            "name": args.name,
+            "namespace": args.namespace,
+            "created_at": created_at,
+            "featured": False,
+            "versions": [],
+        }
+    )
+    data["versions"] = [v for v in data["versions"] if v["version"] != version]
+    data["versions"].append(entry)
+    index.write_text(json.dumps(data))
+    print(f"{args.namespace}/{args.name} {version} -> {index}")
+
+
+if __name__ == "__main__":
+    main()
@@ -50,15 +50,16 @@ python examples/espressif/export_espnn_test_programs.py --output-dir "${build_di
     --only conv-act-pool-linear 2>&1 | tee -a "${build_dir}/export.log"
 cp "${build_dir}/espnn/conv-act-pool-linear.bpte" "${build_dir}/delegate.bpte"
 split=examples/espressif/idf_component_smoke/split_bundled_program.py
-python "${split}" "${build_dir}/smoke.bpte" --atol 0 --rtol 0
+# Each case twice, so a second execute of the same method is checked too.
+python "${split}" "${build_dir}/smoke.bpte" --atol 0 --rtol 0 --repeat 2
 # The tolerance test_mul.py uses.
-python "${split}" "${build_dir}/mul.bpte" --atol 0 --rtol 1.2e-7
+python "${split}" "${build_dir}/mul.bpte" --atol 0 --rtol 1.2e-7 --repeat 2
 read -r atol rtol < <(python -c '
 import json, sys
 (entry,) = json.load(open(sys.argv[1]))
 print(entry["atol"], entry["rtol"])
 ' "${build_dir}/espnn/manifest.json")
-python "${split}" "${build_dir}/delegate.bpte" --atol "${atol}" --rtol "${rtol}"
+python "${split}" "${build_dir}/delegate.bpte" --atol "${atol}" --rtol "${rtol}" --repeat 2
 cpu_models="${build_dir}/smoke.pte;${build_dir}/mul.pte"
 models="${cpu_models};${build_dir}/delegate.pte"
 
 
@@ -0,0 +1,181 @@
+#!/usr/bin/env bash
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Builds the ExecuTorch ESP-IDF component the way a project using the published
+# component gets it: generates and packs the component, adds the archive to a
+# file:// component mirror, and builds the idf_component_consumer project, which
+# resolves executorch from that mirror, with ESP-IDF's own Python environment
+# (no ExecuTorch) and with source and build paths that have a space. Each build
+# runs the smoke model on the emulator; the ESP32-S3 and ESP32-C6 builds also
+# run a Cadence-quantized streaming wake word model frame by frame against
+# PyTorch.
+# ESPRESSIF_IDF_VERSION selects the ESP-IDF release: v6.1 builds every target
+# an emulator runs (QEMU for ESP32, esp-emu for the rest), other releases
+# ESP32-S3 and ESP32-C6. Also lints the component's manifest.
+
+set -euo pipefail
+
+et_root=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)
+idf_version="${ESPRESSIF_IDF_VERSION:-v6.1}"
+build_dir="${ESPRESSIF_BUILD_DIR:-${et_root}/cmake-out-esp-idf-consumer-${idf_version}}"
+export ESPRESSIF_TOOLS_DIR="${ESPRESSIF_TOOLS_DIR:-${RUNNER_TEMP:-/tmp}/executorch-espressif-${idf_version}}"
+mkdir -p "${build_dir}"
+build_dir=$(cd "${build_dir}" && pwd)
+cd "${et_root}"
+
+if [[ "${idf_version}" == v6.1 ]]; then
+    targets=(esp32s3 esp32 esp32c3 esp32c5 esp32c6 esp32p4)
+else
+    targets=(esp32s3 esp32c6)
+fi
+
+collect_artifacts() {
+    if [[ -n "${RUNNER_ARTIFACT_DIR:-}" ]]; then
+        mkdir -p "${RUNNER_ARTIFACT_DIR}/esp-idf-consumer"
+        cp "${build_dir}"/*.log "${RUNNER_ARTIFACT_DIR}/esp-idf-consumer/" || true
+    fi
+}
+trap collect_artifacts EXIT
+
+# ESP-IDF's QEMU needs these libraries, and setup.sh fails its install check
+# without them.
+if [[ " ${targets[*]} " == *" esp32 "* ]] && ! python -c '
+import ctypes
+ctypes.CDLL("libSDL2-2.0.so.0")
+ctypes.CDLL("libslirp.so.0")' 2> /dev/null; then
+    sudo apt-get update
+    sudo apt-get install -y --no-install-recommends libsdl2-2.0-0 libslirp0
+fi
+bash examples/espressif/setup.sh --minimal --idf-version="${idf_version}" \
+    --targets="$(IFS=,; echo "${targets[*]}")" 2>&1 | tee "${build_dir}/setup.log"
+# shellcheck source=/dev/null
+source "${ESPRESSIF_TOOLS_DIR}/setup_path.sh"
+
+python examples/espressif/export_smoke_model.py --output "${build_dir}/smoke.bpte" \
+    2>&1 | tee "${build_dir}/export.log"
+python examples/espressif/export_wakeword_model.py --output "${build_dir}/wakeword.bpte" \
+    2>&1 | tee -a "${build_dir}/export.log"
+split=examples/espressif/idf_component_smoke/split_bundled_program.py
+python "${split}" "${build_dir}/smoke.bpte" --atol 0 --rtol 0 --repeat 2
+python "${split}" "${build_dir}/wakeword.bpte" --atol 1e-6 --rtol 0
+
+component_dir="${build_dir}/component/executorch"
+bash examples/espressif/build_idf_component.sh --out "${component_dir}" \
+    2>&1 | tee "${build_dir}/generate.log"
+compote manifest lint "${component_dir}/idf_component.yml"
+version=$(sed -n 's/^version: "\(.*\)"$/\1/p' "${component_dir}/idf_component.yml")
+(cd "${component_dir}" && compote component pack --name executorch --dest-dir "${build_dir}/dist")
+archive="${build_dir}/dist/executorch_${version}.tgz"
+mirror="${build_dir}/mirror"
+rm -rf "${mirror}"
+python .ci/scripts/esp_idf_mirror.py "${archive}" "${mirror}" \
+    --namespace pytorch --name executorch
+
+kernels() {
+    local out=$1
+    shift
+    python "${component_dir}/tools/gen_kernels.py" "$@" --out "${out}" \
+        2>&1 | tee -a "${build_dir}/gen_kernels.log"
+}
+kernels "${build_dir}/smoke_kernels" --pte "${build_dir}/smoke.pte"
+kernels "${build_dir}/wakeword_kernels" --pte "${build_dir}/smoke.pte" \
+    --pte "${build_dir}/wakeword.pte"
+
+# A fresh ESP-IDF Python environment, which cannot import executorch.
+idf_python_env="${build_dir}/idf_python_env"
+mkdir -p "${idf_python_env}"
+IDF_PYTHON_ENV_PATH="${idf_python_env}" python "${IDF_PATH}/tools/idf_tools.py" \
+    install-python-env 2>&1 | tee "${build_dir}/idf_python_env.log"
+# Built from a copy, so the component manager's state and the consumer's
+# generated manifest stay out of the source tree, under a path with a space.
+sources="${build_dir}/consumer sources"
+rm -rf "${sources}"
+mkdir -p "${sources}/idf_component_smoke"
+cp -r examples/espressif/idf_component_consumer "${sources}/"
+cp -r examples/espressif/idf_component_smoke/main \
+    examples/espressif/idf_component_smoke/sdkconfig.defaults "${sources}/idf_component_smoke/"
+project="${sources}/idf_component_consumer"
+firmware_root="${build_dir}/consumer builds"
+
+# Runs idf.py on the consumer with ESP-IDF's Python and the mirror: build name,
+# target, then idf.py arguments.
+consumer() {
+    local name=$1 target=$2
+    shift 2
+    IDF_TARGET="${target}" IDF_PYTHON_ENV_PATH="${idf_python_env}" \
+        IDF_COMPONENT_STORAGE_URL="file://${mirror};default" \
+        "${idf_python_env}/bin/python" "${IDF_PATH}/tools/idf.py" -C "${project}" \
+        -B "${firmware_root}/${name}" -DSDKCONFIG="${firmware_root}/${name}/sdkconfig" \
+        -DET_COMPONENT_VERSION="${version}" "$@"
+}
+
+# Runs a build on its emulator and checks its output: build name, target, then
+# the per-model markers.
+run_firmware() {
+    local name=$1 target=$2
+    shift 2
+    local firmware_dir="${firmware_root}/${name}" log="${build_dir}/emulator-${name}.log"
+    if [[ "${target}" == esp32 ]]; then
+        # QEMU has no exit-on string, so stop it once the app is done.
+        setsid bash -c 'consumer "$@" qemu' _ "${name}" "${target}" < /dev/null > "${log}" 2>&1 &
+        local pid=$!
+        for _ in $(seq 240); do
+            if grep -qF "Program complete." "${log}"; then
+                break
+            fi
+            sleep 0.5
+        done
+        kill -- "-${pid}" 2> /dev/null || true
+        wait "${pid}" || true
+    else
+        consumer "${name}" "${target}" merge-bin > "${build_dir}/merge-${name}.log" 2>&1
+        timeout 130s esp-emu --chip "${target}" \
+            --firmware "${firmware_dir}/merged-binary.bin" \
+            --elf "${firmware_dir}/et_component_smoke.elf" \
+            --net user --timeout 120s --exit-on 'Program complete.' \
+            > "${log}" 2>&1 || true
+    fi
+    for marker in "$@" "ET_COMPONENT_SMOKE: PASS" "Program complete."; do
+        if ! grep -qF "${marker}" "${log}"; then
+            echo "FAIL: ${name} printed no '${marker}'; see emulator-${name}.log" >&2
+            exit 1
+        fi
+    done
+    echo "OK: ${name} passed on the ${target} emulator"
+}
+export -f consumer
+export idf_python_env mirror project firmware_root version
+
+for target in "${targets[@]}"; do
+    if [[ "${target}" == esp32s3 || "${target}" == esp32c6 ]]; then
+        consumer "${target}" "${target}" \
+            -DET_SMOKE_MODELS="${build_dir}/smoke.pte;${build_dir}/wakeword.pte" \
+            -DET_SMOKE_KERNELS="${build_dir}/wakeword_kernels" build \
+            > "${build_dir}/firmware-${target}.log" 2>&1
+        run_firmware "${target}" "${target}" "smoke: PASS" "wakeword: PASS, 40/40 cases"
+    else
+        consumer "${target}" "${target}" -DET_SMOKE_MODELS="${build_dir}/smoke.pte" \
+            -DET_SMOKE_KERNELS="${build_dir}/smoke_kernels" build \
+            > "${build_dir}/firmware-${target}.log" 2>&1
+        run_firmware "${target}" "${target}" "smoke: PASS"
+    fi
+    python - "${project}/dependencies.lock" "${mirror}/components/pytorch/executorch.json" <<'PY'
+import json
+import sys
+
+import yaml
+
+entry = yaml.safe_load(open(sys.argv[1]))["dependencies"]["pytorch/executorch"]
+(mirrored,) = json.load(open(sys.argv[2]))["versions"]
+if (str(entry["version"]), entry.get("component_hash")) != (
+    mirrored["version"],
+    mirrored["component_hash"],
+):
+    sys.exit(f"FAIL: pytorch/executorch did not come from the mirror: {entry}")
+PY
+done
+echo "PASS: the packed ESP-IDF component built from a mirror and ran on every target."
@@ -9,10 +9,23 @@ on:
     paths:
       - backends/espressif/**
       - examples/espressif/**
+      # Vendored into the ESP-IDF component.
+      - runtime/**
+      - kernels/**
+      - schema/**
+      - extension/**
+      - codegen/**
+      - backends/cadence/**
+      - shim_et/xplat/executorch/build/build_variables.bzl
+      # Exported by the consumer test.
+      - examples/models/mlperf_tiny/**
+      - devtools/bundled_program/**
       - tools/cmake/preset/esp_baremetal.cmake
       - CMakePresets.json
       - .ci/scripts/test_espressif.sh
       - .ci/scripts/test_espressif_idf_component.sh
+      - .ci/scripts/test_espressif_idf_consumer.sh
+      - .ci/scripts/esp_idf_mirror.py
       - .github/workflows/test-espressif.yml
   schedule:
     - cron: '0 4 * * 1'
@@ -74,3 +87,29 @@ jobs:
         source .ci/scripts/utils.sh
         install_executorch --use-pt-pinned-commit --minimal
         bash .ci/scripts/test_espressif_idf_component.sh
+
+  test-idf-consumer:
+    name: ESP-IDF component consumer (${{ matrix.idf-version }})
+    needs: docker-image
+    strategy:
+      fail-fast: false
+      matrix:
+        idf-version: [v6.1, v6.0.1]
+    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
+    permissions:
+      id-token: write
+      contents: read
+    with:
+      runner: mt-l-x86iavx512-8-64
+      docker-image: ${{ needs.docker-image.outputs.docker-registry }}/ci-image:executorch-ubuntu-22.04-clang12-${{ needs.docker-image.outputs.ci-docker-hash }}
+      submodules: recursive
+      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+      timeout: 45
+      upload-artifact: test-report-esp-idf-consumer-${{ matrix.idf-version }}
+      script: |
+        set -euo pipefail
+        CONDA_ENV=$(conda env list --json | jq -r '.envs | .[-1]')
+        conda activate "${CONDA_ENV}"
+        source .ci/scripts/utils.sh
+        install_executorch --use-pt-pinned-commit --minimal
+        ESPRESSIF_IDF_VERSION="${{ matrix.idf-version }}" bash .ci/scripts/test_espressif_idf_consumer.sh
@@ -6,3 +6,4 @@ sdkconfig
 sdkconfig.old
 __pycache__/
 camera_stream/models/
+idf_component_consumer/main/idf_component.yml
@@ -35,8 +35,11 @@ application.
 Consumers need ESP-IDF, plus the `executorch` Python package of the
 same release to make kernel bundles — no host CMake build, no flatc.
 `idf_component_smoke/` is a minimal consumer that CI generates, builds
-and runs on the ESP32-S3 emulator
-(`.ci/scripts/test_espressif_idf_component.sh`).
+and runs on the emulator (`.ci/scripts/test_espressif_idf_component.sh`).
+`idf_component_consumer/` builds the same app from the packed component
+through the component manager, with ESP-IDF's own Python, for every
+target an emulator runs, on ESP-IDF 6.1 and 6.0.1
+(`.ci/scripts/test_espressif_idf_consumer.sh`).
 
 The executor runner below remains the reference for the prebuilt-library
 flow and for benchmarking.
@@ -262,6 +265,9 @@ prints the corresponding activation command. It also accepts `IDF_PATH` and
 `IDF_TOOLS_PATH` for an existing ESP-IDF installation. The setup script checks
 the SDK version before installing dependencies into the active environment.
 Use `--skip-idf` or `--skip-emulator` to install only the tools you need.
+`--targets=<chip>,...` installs the compilers for other targets (and, for
+`esp32`, ESP-IDF's QEMU), and `--idf-version=v6.0.1` installs that ESP-IDF
+release instead of 6.1; use a separate `ESPRESSIF_TOOLS_DIR` for it.
 
 ### 2. Export the test model