Merge pull request #16610 from esphome/bump-2026.5.1

2026.5.1

.clang-tidy

@@ -116,6 +116,7 @@ Checks: >-
   -portability-template-virtual-member-function,
   -readability-ambiguous-smartptr-reset-call,
   -readability-avoid-nested-conditional-operator,
+  -readability-container-contains,
   -readability-container-data-pointer,
   -readability-convert-member-functions-to-static,
   -readability-else-after-return,

.clang-tidy.hash

@@ -1 +1 @@
-27aaab4e0ebfc10491720345aa746fc2dffa6a3985f73ec111b12dd99078d46f
+593fd53fa09944a59af3f38521e31d87fe10b60326b8d82bb76413c5149b312c

.github/actions/build-image/action.yaml

@@ -47,7 +47,7 @@ runs:
 
     - name: Build and push to ghcr by digest
       id: build-ghcr
-      uses: docker/build-push-action@f9f3042f7e2789586610d6e8b85c8f03e5195baf # v7.2.0
+      uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
@@ -73,7 +73,7 @@ runs:
 
     - name: Build and push to dockerhub by digest
       id: build-dockerhub
-      uses: docker/build-push-action@f9f3042f7e2789586610d6e8b85c8f03e5195baf # v7.2.0
+      uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false

.github/actions/restore-python/action.yml

@@ -27,18 +27,6 @@ runs:
         path: venv
         # yamllint disable-line rule:line-length
         key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ inputs.cache-key }}
-    - name: Set up uv
-      # Only needed on cache miss to populate the venv. ``uv pip install``
-      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
-      # downstream jobs rely on is preserved.
-      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
-      with:
-        enable-cache: true
-        # Pin uv version so the action does not have to fetch the
-        # manifest from raw.githubusercontent.com on every cache
-        # miss; that fetch flakes on Windows runners.
-        version: "0.11.15"
     - name: Create Python virtual environment
       if: steps.cache-venv.outputs.cache-hit != 'true' && runner.os != 'Windows'
       shell: bash
@@ -46,8 +34,8 @@ runs:
         python -m venv venv
         source venv/bin/activate
         python --version
-        uv pip install -r requirements.txt -r requirements_test.txt
-        uv pip install -e .
+        pip install -r requirements.txt -r requirements_test.txt
+        pip install -e .
     - name: Create Python virtual environment
       if: steps.cache-venv.outputs.cache-hit != 'true' && runner.os == 'Windows'
       shell: bash
@@ -55,5 +43,5 @@ runs:
         python -m venv venv
         source ./venv/Scripts/activate
         python --version
-        uv pip install -r requirements.txt -r requirements_test.txt
-        uv pip install -e .
+        pip install -r requirements.txt -r requirements_test.txt
+        pip install -e .

.github/workflows/ci-api-proto.yml

@@ -26,16 +26,6 @@ jobs:
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: "3.11"
-      - name: Set up uv
-        # ``--system`` (below) installs into the setup-python interpreter;
-        # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
-        with:
-          enable-cache: true
-          # Pin uv version so the action does not have to fetch the
-          # manifest from raw.githubusercontent.com on every cache
-          # miss; that fetch flakes on Windows runners.
-          version: "0.11.15"
 
       - name: Install apt dependencies
         run: |
@@ -44,7 +34,7 @@ jobs:
           sudo apt install -y protobuf-compiler
           protoc --version
       - name: Install python dependencies
-        run: uv pip install --system aioesphomeapi -c requirements.txt -r requirements_dev.txt
+        run: pip install aioesphomeapi -c requirements.txt -r requirements_dev.txt
       - name: Generate files
         run: script/api_protobuf/api_protobuf.py
       - name: Check for changes

.github/workflows/ci-docker.yml

@@ -48,7 +48,7 @@ jobs:
         with:
           python-version: "3.11"
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Set TAG
         run: |

.github/workflows/ci.yml

@@ -6,6 +6,14 @@ on:
     branches: [dev, beta, release]
 
   pull_request:
+    paths:
+      - "**"
+      - "!.github/workflows/*.yml"
+      - "!.github/actions/build-image/*"
+      - ".github/workflows/ci.yml"
+      - "!.yamllint"
+      - "!.github/dependabot.yml"
+      - "!docker/**"
   merge_group:
 
 permissions:
@@ -44,26 +52,14 @@ jobs:
           path: venv
           # yamllint disable-line rule:line-length
           key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ steps.cache-key.outputs.key }}
-      - name: Set up uv
-        # Only needed on cache miss to populate the venv. ``uv pip install``
-        # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
-        # that ``. venv/bin/activate`` see an identical layout.
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
-        with:
-          enable-cache: true
-          # Pin uv version so the action does not have to fetch the
-          # manifest from raw.githubusercontent.com on every cache
-          # miss; that fetch flakes on Windows runners.
-          version: "0.11.15"
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         run: |
           python -m venv venv
           . venv/bin/activate
           python --version
-          uv pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt pre-commit
-          uv pip install -e .
+          pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt pre-commit
+          pip install -e .
 
   pylint:
     name: Check pylint
@@ -93,8 +89,6 @@ jobs:
     runs-on: ubuntu-24.04
     needs:
       - common
-      - determine-jobs
-    if: needs.determine-jobs.outputs.core-ci == 'true'
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -173,10 +167,6 @@ jobs:
         uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           enable-cache: true
-          # Pin uv version so the action does not have to fetch the
-          # manifest from raw.githubusercontent.com on every cache
-          # miss; that fetch flakes on Windows runners.
-          version: "0.11.15"
       - name: Install device-builder + esphome from PR
         # Install device-builder with its esphome + test extras
         # first so its pinned versions of pytest/etc. land, then
@@ -191,7 +181,7 @@ jobs:
         # own CI). No ``--cov`` here -- this is purely a downstream
         # smoke check against this PR's esphome code.
         working-directory: device-builder
-        run: pytest -q -n auto --maxfail=5 --durations=30 --no-cov --ignore=tests/benchmarks
+        run: pytest -q -n auto --maxfail=5 --durations=10 --no-cov --ignore=tests/benchmarks
 
   pytest:
     name: Run pytest
@@ -217,8 +207,6 @@ jobs:
     runs-on: ${{ matrix.os }}
     needs:
       - common
-      - determine-jobs
-    if: needs.determine-jobs.outputs.core-ci == 'true'
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -234,14 +222,14 @@ jobs:
         if: matrix.os == 'windows-latest'
         run: |
           . ./venv/Scripts/activate.ps1
-          pytest -vv --cov-report=xml --tb=native --durations=30 -n auto tests --ignore=tests/integration/
+          pytest -vv --cov-report=xml --tb=native -n auto tests --ignore=tests/integration/
       - name: Run pytest
         if: matrix.os == 'ubuntu-latest' || matrix.os == 'macOS-latest'
         run: |
           . venv/bin/activate
-          pytest -vv --cov-report=xml --tb=native --durations=30 -n auto tests --ignore=tests/integration/
+          pytest -vv --cov-report=xml --tb=native -n auto tests --ignore=tests/integration/
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
       - name: Save Python virtual environment cache
@@ -257,12 +245,10 @@ jobs:
     needs:
       - common
     outputs:
-      core-ci: ${{ steps.determine.outputs.core-ci }}
       integration-tests: ${{ steps.determine.outputs.integration-tests }}
       integration-test-buckets: ${{ steps.determine.outputs.integration-test-buckets }}
       clang-tidy: ${{ steps.determine.outputs.clang-tidy }}
       clang-tidy-mode: ${{ steps.determine.outputs.clang-tidy-mode }}
-      clang-tidy-full-scan: ${{ steps.determine.outputs.clang-tidy-full-scan }}
       python-linters: ${{ steps.determine.outputs.python-linters }}
       import-time: ${{ steps.determine.outputs.import-time }}
       device-builder: ${{ steps.determine.outputs.device-builder }}
@@ -301,22 +287,15 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: |
           . venv/bin/activate
-          EXTRA_ARGS=""
-          if [[ "${{ contains(github.event.pull_request.labels.*.name, 'ci-run-all') }}" == "true" ]]; then
-            EXTRA_ARGS="--force-all"
-            echo "::notice::ci-run-all label detected -- forcing every CI job to run"
-          fi
-          output=$(python script/determine-jobs.py $EXTRA_ARGS)
+          output=$(python script/determine-jobs.py)
           echo "Test determination output:"
           echo "$output" | jq
 
           # Extract individual fields
-          echo "core-ci=$(echo "$output" | jq -r '.core_ci')" >> $GITHUB_OUTPUT
           echo "integration-tests=$(echo "$output" | jq -r '.integration_tests')" >> $GITHUB_OUTPUT
           echo "integration-test-buckets=$(echo "$output" | jq -c '.integration_test_buckets')" >> $GITHUB_OUTPUT
           echo "clang-tidy=$(echo "$output" | jq -r '.clang_tidy')" >> $GITHUB_OUTPUT
           echo "clang-tidy-mode=$(echo "$output" | jq -r '.clang_tidy_mode')" >> $GITHUB_OUTPUT
-          echo "clang-tidy-full-scan=$(echo "$output" | jq -r '.clang_tidy_full_scan')" >> $GITHUB_OUTPUT
           echo "python-linters=$(echo "$output" | jq -r '.python_linters')" >> $GITHUB_OUTPUT
           echo "import-time=$(echo "$output" | jq -r '.import_time')" >> $GITHUB_OUTPUT
           echo "device-builder=$(echo "$output" | jq -r '.device_builder')" >> $GITHUB_OUTPUT
@@ -365,24 +344,14 @@ jobs:
         with:
           path: venv
           key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
-      - name: Set up uv
-        # Only needed on cache miss to populate the venv.
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
-        with:
-          enable-cache: true
-          # Pin uv version so the action does not have to fetch the
-          # manifest from raw.githubusercontent.com on every cache
-          # miss; that fetch flakes on Windows runners.
-          version: "0.11.15"
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         run: |
           python -m venv venv
           . venv/bin/activate
           python --version
-          uv pip install -r requirements.txt -r requirements_test.txt
-          uv pip install -e .
+          pip install -r requirements.txt -r requirements_test.txt
+          pip install -e .
       - name: Register matcher
         run: echo "::add-matcher::.github/workflows/matchers/pytest.json"
       - name: Run integration tests
@@ -394,7 +363,7 @@ jobs:
           . venv/bin/activate
           mapfile -t test_files < <(echo "$BUCKET_TESTS" | jq -r '.[]')
           echo "Bucket ${{ matrix.bucket.name }}: running ${#test_files[@]} integration tests"
-          pytest -vv --no-cov --tb=native --durations=30 -n auto "${test_files[@]}"
+          pytest -vv --no-cov --tb=native -n auto "${test_files[@]}"
 
   cpp-unit-tests:
     name: Run C++ unit tests
@@ -531,13 +500,7 @@ jobs:
         id: check_full_scan
         run: |
           . venv/bin/activate
-          # determine-jobs.clang-tidy-full-scan is true when core C++ changed
-          # OR the ci-run-all label forced --force-all. Independent of the
-          # hash check, both must produce a full scan in the job itself.
-          if [ "${{ needs.determine-jobs.outputs.clang-tidy-full-scan }}" = "true" ]; then
-            echo "full_scan=true" >> $GITHUB_OUTPUT
-            echo "reason=determine_jobs" >> $GITHUB_OUTPUT
-          elif python script/clang_tidy_hash.py --check; then
+          if python script/clang_tidy_hash.py --check; then
             echo "full_scan=true" >> $GITHUB_OUTPUT
             echo "reason=hash_changed" >> $GITHUB_OUTPUT
           else
@@ -549,7 +512,7 @@ jobs:
         run: |
           . venv/bin/activate
           if [ "${{ steps.check_full_scan.outputs.full_scan }}" = "true" ]; then
-            echo "Running FULL clang-tidy scan (reason: ${{ steps.check_full_scan.outputs.reason }})"
+            echo "Running FULL clang-tidy scan (hash changed)"
             script/clang-tidy --all-headers --fix ${{ matrix.options }} ${{ matrix.ignore_errors && '|| true' || '' }}
           else
             echo "Running clang-tidy on changed files only"
@@ -609,13 +572,7 @@ jobs:
         id: check_full_scan
         run: |
           . venv/bin/activate
-          # determine-jobs.clang-tidy-full-scan is true when core C++ changed
-          # OR the ci-run-all label forced --force-all. Independent of the
-          # hash check, both must produce a full scan in the job itself.
-          if [ "${{ needs.determine-jobs.outputs.clang-tidy-full-scan }}" = "true" ]; then
-            echo "full_scan=true" >> $GITHUB_OUTPUT
-            echo "reason=determine_jobs" >> $GITHUB_OUTPUT
-          elif python script/clang_tidy_hash.py --check; then
+          if python script/clang_tidy_hash.py --check; then
             echo "full_scan=true" >> $GITHUB_OUTPUT
             echo "reason=hash_changed" >> $GITHUB_OUTPUT
           else
@@ -627,7 +584,7 @@ jobs:
         run: |
           . venv/bin/activate
           if [ "${{ steps.check_full_scan.outputs.full_scan }}" = "true" ]; then
-            echo "Running FULL clang-tidy scan (reason: ${{ steps.check_full_scan.outputs.reason }})"
+            echo "Running FULL clang-tidy scan (hash changed)"
             script/clang-tidy --all-headers --fix --environment esp32-arduino-tidy
           else
             echo "Running clang-tidy on changed files only"
@@ -704,13 +661,7 @@ jobs:
         id: check_full_scan
         run: |
           . venv/bin/activate
-          # determine-jobs.clang-tidy-full-scan is true when core C++ changed
-          # OR the ci-run-all label forced --force-all. Independent of the
-          # hash check, both must produce a full scan in the job itself.
-          if [ "${{ needs.determine-jobs.outputs.clang-tidy-full-scan }}" = "true" ]; then
-            echo "full_scan=true" >> $GITHUB_OUTPUT
-            echo "reason=determine_jobs" >> $GITHUB_OUTPUT
-          elif python script/clang_tidy_hash.py --check; then
+          if python script/clang_tidy_hash.py --check; then
             echo "full_scan=true" >> $GITHUB_OUTPUT
             echo "reason=hash_changed" >> $GITHUB_OUTPUT
           else
@@ -722,7 +673,7 @@ jobs:
         run: |
           . venv/bin/activate
           if [ "${{ steps.check_full_scan.outputs.full_scan }}" = "true" ]; then
-            echo "Running FULL clang-tidy scan (reason: ${{ steps.check_full_scan.outputs.reason }})"
+            echo "Running FULL clang-tidy scan (hash changed)"
             script/clang-tidy --all-headers --fix ${{ matrix.options }}
           else
             echo "Running clang-tidy on changed files only"
@@ -967,8 +918,7 @@ jobs:
     runs-on: ubuntu-latest
     needs:
       - common
-      - determine-jobs
-    if: github.event_name == 'pull_request' && !startsWith(github.base_ref, 'beta') && !startsWith(github.base_ref, 'release') && needs.determine-jobs.outputs.core-ci == 'true'
+    if: github.event_name == 'pull_request' && !startsWith(github.base_ref, 'beta') && !startsWith(github.base_ref, 'release')
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

.github/workflows/codeql.yml

@@ -56,7 +56,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
+        uses: github/codeql-action/init@68bde559dea0fdcac2102bfdf6230c5f70eb485e # v4.35.4
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
+        uses: github/codeql-action/analyze@68bde559dea0fdcac2102bfdf6230c5f70eb485e # v4.35.4
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/dashboard-deprecation-comment.yml

@@ -12,12 +12,6 @@ jobs:
   dashboard-deprecation-comment:
     name: Dashboard deprecation comment
     runs-on: ubuntu-latest
-    # Release-bump PRs (bump-X.Y.Z -> beta, beta -> release) inevitably
-    # roll up everything merged into dev since the last cut, which can
-    # include dashboard changes that have already been reviewed once.
-    # The bot's purpose is to warn new contributors before they invest
-    # time -- that only applies to PRs entering dev.
-    if: github.event.pull_request.base.ref == 'dev'
     steps:
       - name: Generate a token
         id: generate-token

.github/workflows/pr-title-check.yml

@@ -29,11 +29,10 @@ jobs:
             } = require('./.github/scripts/detect-tags.js');
 
             const title = context.payload.pull_request.title;
-            const user = context.payload.pull_request.user;
+            const author = context.payload.pull_request.user.login;
 
-            // Skip bot PRs (e.g. dependabot, esphome[bot] device-class sync) -
-            // they have their own title formats.
-            if (user.type === 'Bot') {
+            // Skip bot PRs (e.g. dependabot) - they have their own title format
+            if (author === 'dependabot[bot]') {
               return;
             }
 
@@ -69,15 +68,14 @@ jobs:
               return;
             }
 
-            // Check for MDX syntax characters not wrapped in backticks.
-            // Astro docs MDX treats bare `<` as JSX component opening tags and
-            // bare `{` as JS expressions, so both must be escaped in changelog entries.
+            // Check for angle brackets not wrapped in backticks.
+            // Astro docs MDX treats bare < as JSX component opening tags.
             const stripped = title.replace(/`[^`]*`/g, '');
-            if (/[<>{}]/.test(stripped)) {
+            if (/[<>]/.test(stripped)) {
               core.setFailed(
-                'PR title contains `<`, `>`, `{`, or `}` not wrapped in backticks.\n' +
-                'Astro docs MDX interprets bare `<` as JSX components and bare `{` as JS expressions.\n' +
-                'Please wrap these characters with backticks, e.g.: [component] Add `<feature>` support'
+                'PR title contains `<` or `>` not wrapped in backticks.\n' +
+                'Astro docs MDX interprets bare `<` as JSX components.\n' +
+                'Please wrap angle brackets with backticks, e.g.: [component] Add `<feature>` support'
               );
               return;
             }

.github/workflows/release.yml

@@ -99,15 +99,15 @@ jobs:
           python-version: "3.11"
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Log in to docker hub
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           username: ${{ secrets.DOCKER_USER }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Log in to the GitHub container registry
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -178,17 +178,17 @@ jobs:
           merge-multiple: true
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
 
       - name: Log in to docker hub
         if: matrix.registry == 'dockerhub'
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           username: ${{ secrets.DOCKER_USER }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Log in to the GitHub container registry
         if: matrix.registry == 'ghcr'
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}

.github/workflows/stale.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Stale
-        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
+        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
         with:
           debug-only: ${{ github.ref != 'refs/heads/dev' }} # Dry-run when not run on dev branch
           remove-stale-when-updated: true

.github/workflows/sync-device-classes.yml

@@ -41,56 +41,19 @@ jobs:
         with:
           python-version: "3.14"
 
-      - name: Set up uv
-        # An order of magnitude faster than pip on cold boots, with its
-        # own wheel cache. ``--system`` (below) installs into the
-        # setup-python interpreter so subsequent ``pre-commit`` /
-        # ``script/run-in-env.py`` steps find the deps without a
-        # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
-        with:
-          enable-cache: true
-          # Pin uv version so the action does not have to fetch the
-          # manifest from raw.githubusercontent.com on every cache
-          # miss; that fetch flakes on Windows runners.
-          version: "0.11.15"
-
       - name: Install Home Assistant
         run: |
-          uv pip install --system -e lib/home-assistant
-          uv pip install --system -r requirements.txt -r requirements_test.txt pre-commit
+          python -m pip install --upgrade pip
+          pip install -e lib/home-assistant
+          pip install -r requirements_test.txt pre-commit
 
       - name: Sync
         run: |
           python ./script/sync-device_class.py
 
-      - name: Apply pre-commit auto-fixes
-        # First pass: let formatters (ruff, end-of-file-fixer, etc.) modify
-        # files. pre-commit exits non-zero whenever a hook touches anything,
-        # which would otherwise abort the workflow before the auto-fixes
-        # can flow into the sync PR.
-        #
-        # SKIP:
-        #   - no-commit-to-branch is a local guard against committing on
-        #     dev/release/beta; CI runs on dev by definition, and
-        #     peter-evans/create-pull-request creates the branch itself.
-        #   - pylint surfaces import-error / relative-beyond-top-level
-        #     noise here because this workflow installs only a subset of
-        #     the runtime deps (HA + requirements*.txt); main CI already
-        #     gates pylint on real PRs.
-        env:
-          SKIP: pylint,no-commit-to-branch
-        run: python script/run-in-env.py pre-commit run --all-files || true
-
-      - name: Verify pre-commit clean
-        # Second pass: re-run all hooks against the now-fixed tree.
-        # Auto-fixers exit 0 (nothing to change); any remaining failure
-        # from a check-only hook (flake8 / yamllint / ci-custom) is a
-        # real issue and fails the workflow loudly. Same SKIP list as
-        # above for the same reasons.
-        env:
-          SKIP: pylint,no-commit-to-branch
-        run: python script/run-in-env.py pre-commit run --all-files
+      - name: Run pre-commit hooks
+        run: |
+          python script/run-in-env.py pre-commit run --all-files
 
       - name: Commit changes
         uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.15.14
+    rev: v0.15.12
     hooks:
       # Run the linter.
       - id: ruff

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.6.0-dev
+PROJECT_NUMBER         = 2026.5.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/bundle.py

@@ -260,20 +260,42 @@ class ConfigBundleCreator:
     def _discover_yaml_includes(self) -> None:
         """Discover YAML files loaded during config parsing.
 
-        Delegates to :func:`yaml_util.discover_user_yaml_files`, which does a
-        fresh re-parse and force-loads every deferred ``IncludeFile`` so that
-        *all* potentially-reachable includes are captured (even branches not
-        selected by local substitutions). Bundles are meant to be compiled on
-        another system where command-line substitution overrides may choose a
-        different branch — e.g. ``!include network/${eth_model}/config.yaml``
-        must ship every candidate so the remote build can pick any one.
+        Deliberately uses a fresh re-parse and force-loads every deferred
+        ``IncludeFile`` to include *all* potentially-reachable includes,
+        even branches not selected by the local substitutions. Bundles are
+        meant to be compiled on another system where command-line
+        substitution overrides may choose a different branch — e.g.
+        ``!include network/${eth_model}/config.yaml`` must ship every
+        candidate so the remote build can pick any one.
+
+        Entries with unresolved substitution variables in the filename
+        path are skipped with a warning (they cannot be resolved without
+        the substitution pass).
+
+        Secrets files are tracked separately so we can filter them to
+        only include the keys this config actually references.
         """
-        discovered = yaml_util.discover_user_yaml_files(self._config_path)
-        self._secrets_paths.update(discovered.secrets)
-        config_resolved = self._config_path.resolve()
-        for fpath in discovered.files:
-            if fpath == config_resolved:
+        # Must be a fresh parse: IncludeFile.load() caches its result in
+        # _content, and we discover files by listening for loader calls. On
+        # an already-parsed tree the cache is populated, .load() returns
+        # without calling the loader, the listener never fires, and the
+        # referenced files would be silently dropped from the bundle.
+        with yaml_util.track_yaml_loads() as loaded_files:
+            try:
+                data = yaml_util.load_yaml(self._config_path)
+            except EsphomeError:
+                _LOGGER.debug(
+                    "Bundle: re-loading YAML for include discovery failed, "
+                    "proceeding with partial file list"
+                )
+            else:
+                _force_load_include_files(data)
+
+        for fpath in loaded_files:
+            if fpath == self._config_path.resolve():
                 continue  # Already added as config
+            if fpath.name in const.SECRETS_FILES:
+                self._secrets_paths.add(fpath)
             self._add_file(fpath)
 
     def _discover_component_files(self) -> None:
@@ -603,6 +625,57 @@ def _add_bytes_to_tar(tar: tarfile.TarFile, name: str, data: bytes) -> None:
     tar.addfile(info, io.BytesIO(data))
 
 
+def _force_load_include_files(obj: Any, _seen: set[int] | None = None) -> None:
+    """Recursively resolve any ``IncludeFile`` instances in a YAML tree.
+
+    Nested ``!include`` returns a deferred ``IncludeFile`` that is only
+    resolved during the substitution pass. During bundle discovery we need
+    the referenced files to actually load so the ``track_yaml_loads``
+    listener fires for them.
+
+    ``IncludeFile`` instances with unresolved substitution variables in the
+    filename cannot be loaded — we skip and warn about those.
+    """
+    if _seen is None:
+        _seen = set()
+
+    if isinstance(obj, yaml_util.IncludeFile):
+        if id(obj) in _seen:
+            return
+        _seen.add(id(obj))
+        if obj.has_unresolved_expressions():
+            _LOGGER.warning(
+                "Bundle: cannot resolve !include %s (referenced from %s) "
+                "with substitutions in path",
+                obj.file,
+                obj.parent_file,
+            )
+            return
+        try:
+            loaded = obj.load()
+        except EsphomeError as err:
+            _LOGGER.warning(
+                "Bundle: failed to load !include %s (referenced from %s): %s",
+                obj.file,
+                obj.parent_file,
+                err,
+            )
+            return
+        _force_load_include_files(loaded, _seen)
+    elif isinstance(obj, dict):
+        if id(obj) in _seen:
+            return
+        _seen.add(id(obj))
+        for value in obj.values():
+            _force_load_include_files(value, _seen)
+    elif isinstance(obj, (list, tuple)):
+        if id(obj) in _seen:
+            return
+        _seen.add(id(obj))
+        for item in obj:
+            _force_load_include_files(item, _seen)
+
+
 def _resolve_include_path(include_path: Any) -> Path | None:
     """Resolve an include path to absolute, skipping system includes."""
     if isinstance(include_path, str) and include_path.startswith("<"):

esphome/components/audio/__init__.py

@@ -335,7 +335,7 @@ async def to_code(config):
 
     add_idf_component(
         name="esphome/esp-audio-libs",
-        ref="3.1.0",
+        ref="3.0.0",
     )
 
     data = _get_data()

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -135,12 +135,26 @@ void BluetoothConnection::loop() {
   // - For V3_WITH_CACHE: Services are never sent, disable after INIT state
   // - For V3_WITHOUT_CACHE: Disable only after service discovery is complete
   //   (send_service_ == DONE_SENDING_SERVICES, which is only set after services are sent)
-  if (this->state() != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
-                                                    this->send_service_ == DONE_SENDING_SERVICES)) {
+  // Never disable while DISCONNECTING — BLEClientBase::loop() needs to keep running so the
+  // 10s safety timeout can force IDLE if CLOSE_EVT is never delivered.
+  if (this->state() != espbt::ClientState::INIT && this->state() != espbt::ClientState::DISCONNECTING &&
+      (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
+       this->send_service_ == DONE_SENDING_SERVICES)) {
     this->disable_loop();
   }
 }
 
+void BluetoothConnection::on_disconnect_complete(esp_err_t reason) {
+  // Called from both the CLOSE_EVT handler and the DISCONNECTING safety timeout in the
+  // base class. Free the proxy slot, notify the API client, and reset send_service_.
+  // address_ may already be 0 if reset_connection_ ran earlier on this teardown.
+  if (this->address_ == 0) {
+    return;
+  }
+  ESP_LOGD(TAG, "[%d] [%s] Close, reason=0x%02x, freeing slot", this->connection_index_, this->address_str_, reason);
+  this->reset_connection_(reason);
+}
+
 void BluetoothConnection::reset_connection_(esp_err_t reason) {
   // Send disconnection notification
   this->proxy_->send_device_connection(this->address_, false, 0, reason);
@@ -372,14 +386,6 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       this->proxy_->send_device_connection(this->address_, false, 0, param->disconnect.reason);
       break;
     }
-    case ESP_GATTC_CLOSE_EVT: {
-      ESP_LOGD(TAG, "[%d] [%s] Close, reason=0x%02x, freeing slot", this->connection_index_, this->address_str_,
-               param->close.reason);
-      // Now the GATT connection is fully closed and controller resources are freed
-      // Safe to mark the connection slot as available
-      this->reset_connection_(param->close.reason);
-      break;
-    }
     case ESP_GATTC_OPEN_EVT: {
       if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
         this->reset_connection_(param->open.status);

esphome/components/bluetooth_proxy/bluetooth_connection.h

@@ -33,6 +33,8 @@ class BluetoothConnection final : public esp32_ble_client::BLEClientBase {
  protected:
   friend class BluetoothProxy;
 
+  void on_disconnect_complete(esp_err_t reason) override;
+
   bool supports_efficient_uuids_() const;
   void send_service_for_discovery_();
   void reset_connection_(esp_err_t reason);

esphome/components/esp32/__init__.py

@@ -1816,12 +1816,12 @@ async def to_code(config):
                 Path(__file__).parent / "iram_fix.py.script",
             )
     else:
-        cg.add_build_flag("-Wno-error=format")
-        cg.add_build_flag("-Wno-error=maybe-uninitialized")
-        cg.add_build_flag("-Wno-error=overloaded-virtual")
-        cg.add_build_flag("-Wno-error=reorder")
-        cg.add_build_flag("-Wno-error=volatile")
-        cg.add_build_flag("-Wno-error=cpp")
+        # Demote IDF's blanket -Werror to warnings so third-party libs
+        # and user lambdas don't need a -Wno-error=<class> per warning.
+        # The sdkconfig knob disables IDF's rewrite to -Werror=all (which
+        # can't be globally undone); -Wno-error then handles the demotion.
+        add_idf_sdkconfig_option("CONFIG_COMPILER_DISABLE_DEFAULT_ERRORS", False)
+        cg.add_build_flag("-Wno-error")
         # -Wno- (not -Wno-error=): suppress entirely, too noisy on C++ aggregates
         cg.add_build_flag("-Wno-missing-field-initializers")
 
@@ -2011,7 +2011,7 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_HEAP_PLACE_FUNCTION_INTO_FLASH", True)
 
     # Setup watchdog
-    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_INIT", True)
+    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT", True)
     add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_PANIC", True)
     add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
     add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
@@ -2053,8 +2053,7 @@ async def to_code(config):
     if not advanced[CONF_ENABLE_LWIP_MDNS_QUERIES]:
         add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
     if not advanced[CONF_ENABLE_LWIP_BRIDGE_INTERFACE]:
-        # Kconfig range is [1,63]; 0 gets clamped to the default.
-        add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 1)
+        add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
 
     _configure_lwip_max_sockets(conf)
 
@@ -2146,6 +2145,7 @@ async def to_code(config):
         for key, flag in ASSERTION_LEVELS.items():
             add_idf_sdkconfig_option(flag, assertion_level == key)
 
+    add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
     compiler_optimization = advanced[CONF_COMPILER_OPTIMIZATION]
     for key, flag in COMPILER_OPTIMIZATIONS.items():
         add_idf_sdkconfig_option(flag, compiler_optimization == key)
@@ -2300,8 +2300,7 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 2)
     elif advanced[CONF_DISABLE_FATFS]:
         add_idf_sdkconfig_option("CONFIG_FATFS_LFN_NONE", True)
-        # Kconfig range is [1,10]; 0 gets clamped to the default.
-        add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 1)
+        add_idf_sdkconfig_option("CONFIG_FATFS_VOLUME_COUNT", 0)
 
     for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
         add_idf_sdkconfig_option(name, RawSdkconfigValue(value))

esphome/components/esp32/core.cpp

@@ -3,7 +3,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
 #include "preferences.h"
-#include <esp_attr.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
@@ -15,14 +14,10 @@ extern "C" __attribute__((weak)) void initArduino() {}
 namespace esphome {
 
 // HAL functions live in hal.cpp. This file keeps only the loop task setup.
-// Force the static TCB and stack into internal DRAM. Otherwise the linker may
-// place them in PSRAM under configs like CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY,
-// which is unsafe when CONFIG_SPIRAM_XIP_FROM_PSRAM is enabled because the running
-// task's stack must be reachable while the flash cache is disabled.
-TaskHandle_t loop_task_handle = nullptr;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static StaticTask_t DRAM_ATTR loop_task_tcb{};  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static StackType_t DRAM_ATTR
-    loop_task_stack[ESPHOME_LOOP_TASK_STACK_SIZE]{};  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+TaskHandle_t loop_task_handle = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static StaticTask_t loop_task_tcb;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static StackType_t
+    loop_task_stack[ESPHOME_LOOP_TASK_STACK_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void loop_task(void *pv_params) {
   setup();

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -72,6 +72,7 @@ void BLEClientBase::loop() {
     // never delivered CLOSE_EVT/DISCONNECT_EVT, services would leak without this call.
     this->release_services();
     this->set_idle_();
+    this->on_disconnect_complete(ESP_GATT_CONN_TIMEOUT);
   }
 }
 
@@ -418,6 +419,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       this->log_gattc_lifecycle_event_("CLOSE");
       this->release_services();
       this->set_idle_();
+      this->on_disconnect_complete(param->close.reason);
       break;
     }
     case ESP_GATTC_SEARCH_RES_EVT: {

esphome/components/esp32_ble_client/ble_client_base.h

@@ -140,6 +140,12 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void log_gattc_warning_(const char *operation, esp_err_t err);
   void log_connection_params_(const char *param_type);
   void handle_connection_result_(esp_err_t ret);
+  /// Hook called once a connection has been fully torn down (after release_services() and
+  /// set_idle_()), from both the CLOSE_EVT handler and the DISCONNECTING safety timeout.
+  /// Subclasses with extra per-connection accounting (e.g. bluetooth_proxy slot state)
+  /// override this to release that state. `reason` is the controller reason code, or
+  /// ESP_GATT_CONN_TIMEOUT for the safety-timeout path.
+  virtual void on_disconnect_complete(esp_err_t reason) {}
   /// Transition to IDLE and reset conn_id — call when the connection is fully dead.
   void set_idle_() {
     this->set_state(espbt::ClientState::IDLE);
@@ -149,6 +155,10 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void set_disconnecting_() {
     this->disconnecting_started_ = millis();
     this->set_state(espbt::ClientState::DISCONNECTING);
+    // BluetoothConnection::loop() disables the component loop after service discovery
+    // completes, so the DISCONNECTING timeout check in loop() would never run if CLOSE_EVT
+    // gets lost. Re-enable the loop so the 10s safety timeout can force IDLE.
+    this->enable_loop();
   }
   // Compact error logging helpers to reduce flash usage
   void log_error_(const char *message);

esphome/components/esp32_ble_server/ble_characteristic.cpp

@@ -196,35 +196,42 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
         (*this->on_read_callback_)(param->read.conn_id);
       }
 
-      // Use the client-supplied offset for long reads; short reads always start at 0.
-      // The Bluedroid stack truncates ATT_READ_RSP / ATT_READ_BLOB_RSP to MTU-1, so we
-      // just provide as much data as we have from the requested offset and let the stack
-      // handle framing. The client issues subsequent blob reads with increasing offsets
-      // until it has received the whole value.
-      const uint16_t offset = param->read.is_long ? param->read.offset : 0;
-      esp_gatt_status_t status = ESP_GATT_OK;
-      esp_gatt_rsp_t response;
-      response.attr_value.offset = offset;
+      uint16_t max_offset = 22;
 
-      if (offset > this->value_.size()) {
-        status = ESP_GATT_INVALID_OFFSET;
-        response.attr_value.len = 0;
-      } else {
-        size_t remaining = this->value_.size() - offset;
-        if (remaining > ESP_GATT_MAX_ATTR_LEN) {
-          ESP_LOGW(TAG, "Characteristic length %u exceeds buffer size of %u, truncating",
-                   static_cast<unsigned>(remaining), ESP_GATT_MAX_ATTR_LEN);
-          remaining = ESP_GATT_MAX_ATTR_LEN;
+      esp_gatt_rsp_t response;
+      if (param->read.is_long) {
+        if (this->value_read_offset_ >= this->value_.size()) {
+          response.attr_value.len = 0;
+          response.attr_value.offset = this->value_read_offset_;
+          this->value_read_offset_ = 0;
+        } else if (this->value_.size() - this->value_read_offset_ < max_offset) {
+          //  Last message in the chain
+          response.attr_value.len = this->value_.size() - this->value_read_offset_;
+          response.attr_value.offset = this->value_read_offset_;
+          memcpy(response.attr_value.value, this->value_.data() + response.attr_value.offset, response.attr_value.len);
+          this->value_read_offset_ = 0;
+        } else {
+          response.attr_value.len = max_offset;
+          response.attr_value.offset = this->value_read_offset_;
+          memcpy(response.attr_value.value, this->value_.data() + response.attr_value.offset, response.attr_value.len);
+          this->value_read_offset_ += max_offset;
         }
-        response.attr_value.len = remaining;
-        memcpy(response.attr_value.value, this->value_.data() + offset, remaining);
+      } else {
+        response.attr_value.offset = 0;
+        if (this->value_.size() + 1 > max_offset) {
+          response.attr_value.len = max_offset;
+          this->value_read_offset_ = max_offset;
+        } else {
+          response.attr_value.len = this->value_.size();
+        }
+        memcpy(response.attr_value.value, this->value_.data(), response.attr_value.len);
       }
 
       response.attr_value.handle = this->handle_;
       response.attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE;
 
       esp_err_t err =
-          esp_ble_gatts_send_response(gatts_if, param->read.conn_id, param->read.trans_id, status, &response);
+          esp_ble_gatts_send_response(gatts_if, param->read.conn_id, param->read.trans_id, ESP_GATT_OK, &response);
       if (err != ESP_OK) {
         ESP_LOGE(TAG, "esp_ble_gatts_send_response failed: %d", err);
       }

esphome/components/esp32_ble_server/ble_characteristic.h

@@ -79,6 +79,7 @@ class BLECharacteristic {
   esp_gatt_char_prop_t properties_;
   uint16_t handle_{0xFFFF};
 
+  uint16_t value_read_offset_{0};
   std::vector<uint8_t> value_;
   std::vector<BLEDescriptor *> descriptors_;
 

esphome/components/esp8266/hal.h

@@ -58,12 +58,6 @@ __attribute__((always_inline)) inline const char *progmem_read_ptr(const char *c
 __attribute__((always_inline)) inline uint16_t progmem_read_uint16(const uint16_t *addr) {
   return pgm_read_word(addr);  // NOLINT
 }
-// Bulk PROGMEM copy: routes to the SDK's aligned-flash `memcpy_P` so callers
-// don't have to drop to a byte-by-byte `progmem_read_byte` loop, which on
-// ESP8266 is ~4x as many flash accesses as the bulk path.
-__attribute__((always_inline)) inline void progmem_memcpy(void *dst, const void *src, size_t len) {
-  memcpy_P(dst, src, len);  // NOLINT
-}
 
 // NOLINTNEXTLINE(readability-identifier-naming)
 __attribute__((always_inline)) inline void delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }

esphome/components/homeassistant/sensor/homeassistant_sensor.cpp

@@ -17,9 +17,9 @@ void HomeassistantSensor::setup() {
     }
 
     if (this->attribute_ != nullptr) {
-      ESP_LOGV(TAG, "'%s::%s': Got attribute state %.2f", this->entity_id_, this->attribute_, *val);
+      ESP_LOGD(TAG, "'%s::%s': Got attribute state %.2f", this->entity_id_, this->attribute_, *val);
     } else {
-      ESP_LOGV(TAG, "'%s': Got state %.2f", this->entity_id_, *val);
+      ESP_LOGD(TAG, "'%s': Got state %.2f", this->entity_id_, *val);
     }
     this->publish_state(*val);
   });

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -2,7 +2,6 @@
 
 #ifdef USE_ESP32
 
-#include <driver/gpio.h>
 #include <driver/i2s_std.h>
 
 #include "esphome/components/audio/audio.h"
@@ -300,15 +299,6 @@ void I2SAudioSpeakerBase::stop_i2s_driver_() {
     i2s_channel_disable(this->tx_handle_);
     i2s_del_channel(this->tx_handle_);
     this->tx_handle_ = nullptr;
-
-    // i2s_del_channel() leaves dout wired to this port's data-out signal in the GPIO matrix: it only
-    // clears an internal reservation mask, never the esp_rom_gpio_connect_out_signal() routing that
-    // setup installed. If another speaker reuses this port (shared bus), its audio still reaches our
-    // dout. Detach the pin and drive it low so a stale output stops driving downstream hardware: a
-    // SPDIF optical transmitter would otherwise stay lit, and an analog DAC would emit noise.
-    gpio_reset_pin(this->dout_pin_);
-    gpio_set_direction(this->dout_pin_, GPIO_MODE_OUTPUT);
-    gpio_set_level(this->dout_pin_, 0);
   }
   this->parent_->unlock();
 }

esphome/components/light/__init__.py

@@ -86,22 +86,10 @@ class EffectRef:
     component_path: list[str | int]  # path_context when the action was validated
 
 
-@dataclass
-class EffectCycleRef:
-    """A pending light.effect.next/previous action to validate.
-
-    Records that the referenced light needs at least one effect configured.
-    """
-
-    light_id: ID
-    component_path: list[str | int]
-
-
 @dataclass
 class LightData:
     gamma_tables: dict = field(default_factory=dict)  # gamma_value -> fwd_arr
     effect_refs: list[EffectRef] = field(default_factory=list)
-    effect_cycle_refs: list[EffectCycleRef] = field(default_factory=list)
 
 
 def _get_data() -> LightData:
@@ -172,15 +160,13 @@ def _final_validate(config: ConfigType) -> ConfigType:
     this never runs — but the ID validator will catch the missing light ID separately.
     """
     data = _get_data()
-    if not data.effect_refs and not data.effect_cycle_refs:
+    if not data.effect_refs:
         return config
 
-    # Drain the lists so we only validate once even though
+    # Drain the list so we only validate once even though
     # FINAL_VALIDATE_SCHEMA runs for each light platform instance.
     refs = data.effect_refs
     data.effect_refs = []
-    cycle_refs = data.effect_cycle_refs
-    data.effect_cycle_refs = []
 
     fconf = fv.full_config.get()
 
@@ -202,21 +188,6 @@ def _final_validate(config: ConfigType) -> ConfigType:
                 path=[cv.ROOT_CONFIG_PATH] + ref.component_path,
             )
 
-    for ref in cycle_refs:
-        try:
-            light_path = fconf.get_path_for_id(ref.light_id)[:-1]
-            light_config = fconf.get_config_for_path(light_path)
-        except KeyError:
-            continue
-
-        if not light_config.get(CONF_EFFECTS):
-            raise cv.FinalExternalInvalid(
-                f"Light '{ref.light_id}' has no effects configured, but a "
-                f"'light.effect.next' or 'light.effect.previous' action "
-                f"references it. Add at least one effect to the light.",
-                path=[cv.ROOT_CONFIG_PATH] + ref.component_path,
-            )
-
     return config
 
 

esphome/components/light/automation.h

@@ -104,47 +104,6 @@ template<bool HasTransitionLength, typename... Ts> class DimRelativeAction : pub
       transition_length_{};
 };
 
-// Cycle through the light's configured effects. `Forward` selects direction
-// at compile time so the chosen branch is the only one that gets instantiated
-// per action site. `include_none` is runtime so a single set of templates
-// covers both the "wrap through None" and "skip None" variants.
-template<bool Forward, typename... Ts> class LightEffectCycleAction : public Action<Ts...> {
- public:
-  explicit LightEffectCycleAction(LightState *parent) : parent_(parent) {}
-
-  void set_include_none(bool include_none) { this->include_none_ = include_none; }
-
-  void play(const Ts &...) override {
-    size_t count = this->parent_->get_effect_count();
-    if (count == 0) {
-      return;
-    }
-    uint32_t current = this->parent_->get_current_effect_index();
-    uint32_t next;
-    if (this->include_none_) {
-      uint32_t total = static_cast<uint32_t>(count) + 1;
-      if constexpr (Forward) {
-        next = (current + 1) % total;
-      } else {
-        next = (current + total - 1) % total;
-      }
-    } else {
-      if constexpr (Forward) {
-        next = (current % static_cast<uint32_t>(count)) + 1;
-      } else {
-        next = (current <= 1) ? static_cast<uint32_t>(count) : current - 1;
-      }
-    }
-    auto call = this->parent_->turn_on();
-    call.set_effect(next);
-    call.perform();
-  }
-
- protected:
-  LightState *parent_;
-  bool include_none_{false};
-};
-
 template<typename... Ts> class LightIsOnCondition : public Condition<Ts...> {
  public:
   explicit LightIsOnCondition(LightState *state) : state_(state) {}

esphome/components/light/automation.py

@@ -26,8 +26,8 @@ from esphome.const import (
     CONF_WARM_WHITE,
     CONF_WHITE,
 )
-from esphome.core import CORE, ID, EsphomeError, Lambda
-from esphome.cpp_generator import LambdaExpression, MockObj, TemplateArgsType
+from esphome.core import CORE, EsphomeError, Lambda
+from esphome.cpp_generator import LambdaExpression
 from esphome.types import ConfigType
 
 from .types import (
@@ -39,15 +39,12 @@ from .types import (
     DimRelativeAction,
     LightCall,
     LightControlAction,
-    LightEffectCycleAction,
     LightIsOffCondition,
     LightIsOnCondition,
     LightState,
     ToggleAction,
 )
 
-CONF_INCLUDE_NONE = "include_none"
-
 
 @automation.register_action(
     "light.toggle",
@@ -256,75 +253,6 @@ async def light_control_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg, paren, apply_lambda)
 
 
-def _record_effect_cycle_ref(config: ConfigType) -> ConfigType:
-    """Record a cycle-action reference for later validation against the target light."""
-    from . import EffectCycleRef, _get_data
-
-    _get_data().effect_cycle_refs.append(
-        EffectCycleRef(
-            light_id=config[CONF_ID],
-            component_path=path_context.get(),
-        )
-    )
-    return config
-
-
-LIGHT_EFFECT_CYCLE_ACTION_BASE_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_ID): cv.use_id(LightState),
-        cv.Optional(CONF_INCLUDE_NONE, default=False): cv.boolean,
-    }
-)
-LIGHT_EFFECT_CYCLE_ACTION_BASE_SCHEMA.add_extra(_record_effect_cycle_ref)
-
-LIGHT_EFFECT_CYCLE_ACTION_SCHEMA = automation.maybe_simple_id(
-    LIGHT_EFFECT_CYCLE_ACTION_BASE_SCHEMA
-)
-
-
-@automation.register_action(
-    "light.effect.next",
-    LightEffectCycleAction,
-    LIGHT_EFFECT_CYCLE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def light_effect_next_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return await _light_effect_cycle_to_code(config, action_id, template_arg, True)
-
-
-@automation.register_action(
-    "light.effect.previous",
-    LightEffectCycleAction,
-    LIGHT_EFFECT_CYCLE_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def light_effect_previous_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return await _light_effect_cycle_to_code(config, action_id, template_arg, False)
-
-
-async def _light_effect_cycle_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    forward: bool,
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    cycle_template_arg = cg.TemplateArguments(forward, *template_arg)
-    var = cg.new_Pvariable(action_id, cycle_template_arg, paren)
-    cg.add(var.set_include_none(config[CONF_INCLUDE_NONE]))
-    return var
-
-
 CONF_RELATIVE_BRIGHTNESS = "relative_brightness"
 LIGHT_DIM_RELATIVE_ACTION_SCHEMA = cv.Schema(
     {

esphome/components/light/types.py

@@ -39,7 +39,6 @@ LIMIT_MODES = {
 # Actions
 ToggleAction = light_ns.class_("ToggleAction", automation.Action)
 LightControlAction = light_ns.class_("LightControlAction", automation.Action)
-LightEffectCycleAction = light_ns.class_("LightEffectCycleAction", automation.Action)
 DimRelativeAction = light_ns.class_("DimRelativeAction", automation.Action)
 AddressableSet = light_ns.class_("AddressableSet", automation.Action)
 LightIsOnCondition = light_ns.class_("LightIsOnCondition", automation.Condition)

esphome/components/lvgl/lvgl_esphome.cpp

@@ -572,7 +572,7 @@ void LvButtonMatrixType::set_obj(lv_obj_t *lv_obj) {
         auto key_idx = lv_buttonmatrix_get_selected_button(self->obj);
         if (key_idx == LV_BUTTONMATRIX_BUTTON_NONE)
           return;
-        if (self->key_map_.contains(key_idx)) {
+        if (self->key_map_.count(key_idx) != 0) {
           self->send_key_(self->key_map_[key_idx]);
           return;
         }

esphome/components/lvgl/schemas.py

@@ -1,5 +1,4 @@
 from collections.abc import Callable
-from typing import Any
 
 from esphome import config_validation as cv
 from esphome.automation import Trigger, validate_automation
@@ -535,16 +534,7 @@ def strip_defaults(schema: cv.Schema):
     return cv.Schema({cv.Optional(k): v for k, v in schema.schema.items()})
 
 
-# Keyed by (id(widget_type), id(extras)); strong refs in the value keep both
-# alive so id() can't be recycled.
-_CONTAINER_SCHEMA_CACHE: dict[
-    tuple[int, int], tuple[Any, Any, Callable[[Any], Any]]
-] = {}
-
-
-def container_schema(
-    widget_type: WidgetType, extras: Any = None
-) -> Callable[[Any], Any]:
+def container_schema(widget_type: WidgetType, extras=None):
     """
     Create a schema for a container widget of a given type. All obj properties are available, plus
     the extras passed in, plus any defined for the specific widget being specified.
@@ -552,31 +542,19 @@ def container_schema(
     :param extras:  Additional options to be made available, e.g. layout properties for children
     :return: The schema for this type of widget.
     """
-    cache_key = (id(widget_type), id(extras))
-    cached = _CONTAINER_SCHEMA_CACHE.get(cache_key)
-    if cached is not None:
-        cached_widget_type, cached_extras, cached_validator = cached
-        if cached_widget_type is widget_type and cached_extras is extras:
-            return cached_validator
+    schema = obj_schema(widget_type).extend(
+        {cv.GenerateID(): cv.declare_id(widget_type.w_type)}
+    )
+    if extras:
+        schema = schema.extend(extras)
+    # Delayed evaluation for recursion
 
-    cached_schema: cv.Schema | None = None
+    schema = schema.extend(widget_type.schema)
 
-    def get_schema() -> cv.Schema:
-        nonlocal cached_schema
-        if cached_schema is None:
-            schema = obj_schema(widget_type).extend(
-                {cv.GenerateID(): cv.declare_id(widget_type.w_type)}
-            )
-            if extras:
-                schema = schema.extend(extras)
-            cached_schema = schema.extend(widget_type.schema)
-        return cached_schema
-
-    def validator(value: Any) -> Any:
+    def validator(value):
         value = value or {}
-        return append_layout_schema(get_schema(), value)(value)
+        return append_layout_schema(schema, value)(value)
 
-    _CONTAINER_SCHEMA_CACHE[cache_key] = (widget_type, extras, validator)
     return validator
 
 

esphome/components/lvgl/widgets/__init__.py

@@ -1,6 +1,4 @@
-from collections.abc import Callable
 import sys
-from typing import Any
 
 from esphome import codegen as cg, config_validation as cv
 from esphome.automation import register_action
@@ -17,7 +15,6 @@ from esphome.const import (
 from esphome.core import ID, EsphomeError, TimePeriod
 from esphome.coroutine import FakeAwaitable
 from esphome.cpp_generator import MockObj
-from esphome.schema_extractors import EnableSchemaExtraction
 from esphome.types import Expression
 
 from ..defines import (
@@ -76,34 +73,6 @@ from ..types import (
 EVENT_LAMB = "event_lamb__"
 
 
-def _build_update_schema(widget_type: "WidgetType") -> Schema:
-    # Local import: ..schemas imports WidgetType from this module.
-    from ..schemas import base_update_schema
-
-    return base_update_schema(widget_type, widget_type.parts).extend(
-        widget_type.modify_schema
-    )
-
-
-def _update_action_schema(
-    widget_type: "WidgetType",
-) -> Schema | Callable[[Any], Any]:
-    # Eager when extracting so build_language_schema.py sees the mapping;
-    # lazy otherwise to skip ~200 ms of import-time voluptuous work.
-    if EnableSchemaExtraction:
-        return _build_update_schema(widget_type)
-
-    cached: Schema | None = None
-
-    def validator(value: Any) -> Any:
-        nonlocal cached
-        if cached is None:
-            cached = _build_update_schema(widget_type)
-        return cached(value)
-
-    return validator
-
-
 class WidgetType:
     """
     Describes a type of Widget, e.g. "bar" or "line"
@@ -144,17 +113,18 @@ class WidgetType:
 
         # Local import to avoid circular import
         from ..automation import update_to_code
-        from ..schemas import WIDGET_TYPES
+        from ..schemas import WIDGET_TYPES, base_update_schema
 
         if not is_mock:
             if self.name in WIDGET_TYPES:
                 raise EsphomeError(f"Duplicate definition of widget type '{self.name}'")
             WIDGET_TYPES[self.name] = self
 
+            # Register the update action automatically, adding widget-specific properties
             register_action(
                 f"lvgl.{self.name}.update",
                 ObjUpdateAction,
-                _update_action_schema(self),
+                base_update_schema(self, self.parts).extend(self.modify_schema),
                 synchronous=True,
             )(update_to_code)
 

esphome/components/nextion/display.py

@@ -1,5 +1,3 @@
-import logging
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import display, esp32, uart
@@ -41,8 +39,6 @@ from .base_component import (
     CONF_WAKE_UP_PAGE,
 )
 
-_LOGGER = logging.getLogger(__name__)
-
 CODEOWNERS = ["@senexcrenshaw", "@edwardtfn"]
 DEPENDENCIES = ["uart"]
 
@@ -59,15 +55,6 @@ NextionSetBrightnessAction = nextion_ns.class_(
 )
 
 
-def _deprecated_dump_device_info(value):
-    _LOGGER.warning(
-        "'dump_device_info' is deprecated and will be removed in ESPHome 2026.11.0. "
-        "Device info is now always logged at connection time. "
-        "Please remove this option from your configuration."
-    )
-    return value
-
-
 def _validate_tft_upload(config):
     has_tft_url = CONF_TFT_URL in config
     for conf_key in (
@@ -94,10 +81,7 @@ CONFIG_SCHEMA = cv.All(
                 cv.positive_time_period_milliseconds,
                 cv.Range(max=TimePeriod(milliseconds=255)),
             ),
-            # Deprecated — device info is now always logged. Remove before 2026.11.0.
-            cv.Optional(CONF_DUMP_DEVICE_INFO): cv.All(
-                cv.boolean, _deprecated_dump_device_info
-            ),
+            cv.Optional(CONF_DUMP_DEVICE_INFO, default=False): cv.boolean,
             cv.Optional(CONF_EXIT_REPARSE_ON_START, default=False): cv.boolean,
             cv.Optional(CONF_MAX_QUEUE_AGE, default="8000ms"): cv.All(
                 cv.positive_time_period_milliseconds,
@@ -293,6 +277,9 @@ async def to_code(config):
 
     cg.add(var.set_auto_wake_on_touch(config[CONF_AUTO_WAKE_ON_TOUCH]))
 
+    if config[CONF_DUMP_DEVICE_INFO]:
+        cg.add_define("USE_NEXTION_CONFIG_DUMP_DEVICE_INFO")
+
     if config[CONF_EXIT_REPARSE_ON_START]:
         cg.add_define("USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START")
 

esphome/components/nextion/nextion.cpp

@@ -117,41 +117,30 @@ bool Nextion::check_connect_() {
 
   ESP_LOGN(TAG, "connect: %s", response.c_str());
 
-  // Parse comok response fields directly
-  // Format: comok <touch>,<reserved>,<model>,<fw>,<mcu_code>,<serial>,<flash>
-  size_t field_count = 0;
-  size_t start = 0;
+  size_t start;
   size_t end = 0;
-  auto copy_field = [&](char *dst, size_t cap) {
-    size_t len = (end == std::string::npos ? response.size() : end) - start;
-    size_t n = len < cap ? len : cap;
-    std::memcpy(dst, response.data() + start, n);
-    dst[n] = '\0';
-  };
+  std::vector<std::string> connect_info;
   while ((start = response.find_first_not_of(',', end)) != std::string::npos) {
     end = response.find(',', start);
-    switch (field_count) {
-      case 2:
-        copy_field(this->device_model_, this->NEXTION_MODEL_MAX);
-        break;
-      case 3:
-        copy_field(this->firmware_version_, this->NEXTION_FW_MAX);
-        break;
-      case 5:
-        copy_field(this->serial_number_, this->NEXTION_SERIAL_MAX);
-        break;
-      case 6:
-        this->flash_size_ = static_cast<uint32_t>(std::strtoul(response.data() + start, nullptr, 10));
-        break;
-      default:
-        break;
-    }
-    ++field_count;
+    connect_info.push_back(response.substr(start, end - start));
   }
 
-  this->is_detected_ = (field_count == 7);
+  this->is_detected_ = (connect_info.size() == 7);
   if (this->is_detected_) {
-    ESP_LOGN(TAG, "Connect info: %zu fields", field_count);
+    ESP_LOGN(TAG, "Connect info: %zu", connect_info.size());
+#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+    this->device_model_ = connect_info[2];
+    this->firmware_version_ = connect_info[3];
+    this->serial_number_ = connect_info[5];
+    this->flash_size_ = connect_info[6];
+#else   // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+    ESP_LOGI(TAG,
+             "  Device Model:   %s\n"
+             "  FW Version:     %s\n"
+             "  Serial Number:  %s\n"
+             "  Flash Size:     %s\n",
+             connect_info[2].c_str(), connect_info[3].c_str(), connect_info[5].c_str(), connect_info[6].c_str());
+#endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
   } else {
     ESP_LOGE(TAG, "Bad connect value: '%s'", response.c_str());
   }
@@ -189,26 +178,24 @@ void Nextion::dump_config() {
 #ifdef USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
   ESP_LOGCONFIG(TAG, "  Skip handshake: YES");
 #else  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
-  if (this->is_setup()) {
-    ESP_LOGCONFIG(TAG,
-                  "  Device Model: %s\n"
-                  "  FW Version: %s\n"
-                  "  Serial Number: %s\n"
-                  "  Flash Size: %" PRIu32 " bytes",
-                  this->device_model_, this->firmware_version_, this->serial_number_, this->flash_size_);
-  } else {
-    ESP_LOGCONFIG(TAG, "  Device info: not yet detected");
-  }
+#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
   ESP_LOGCONFIG(TAG,
-#ifdef USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
-                "  Exit reparse: YES\n"
-#endif  // USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
+                "  Device Model: %s\n"
+                "  FW Version: %s\n"
+                "  Serial Number: %s\n"
+                "  Flash Size: %s\n"
                 "  Max queue age: %u ms\n"
-                "  Startup override: %u ms\n"
+                "  Startup override: %u ms\n",
+                this->device_model_.c_str(), this->firmware_version_.c_str(), this->serial_number_.c_str(),
+                this->flash_size_.c_str(), this->max_q_age_ms_, this->startup_override_ms_);
+#endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+#ifdef USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
+  ESP_LOGCONFIG(TAG, "  Exit reparse: YES\n");
+#endif  // USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
+  ESP_LOGCONFIG(TAG,
                 "  Wake On Touch: %s\n"
                 "  Touch Timeout: %" PRIu16,
-                this->max_q_age_ms_, this->startup_override_ms_, YESNO(this->connection_state_.auto_wake_on_touch_),
-                this->touch_sleep_timeout_);
+                YESNO(this->connection_state_.auto_wake_on_touch_), this->touch_sleep_timeout_);
 #endif  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
 
 #ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP

esphome/components/nextion/nextion.h

@@ -1610,15 +1610,12 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   nextion_writer_t writer_;
   optional<float> brightness_;
 
-  // Device info populated from comok response (fixed-size, no heap allocation).
-  // Sizes derived from Nextion Upload Protocol documentation and observed hardware.
-  static constexpr size_t NEXTION_MODEL_MAX = 24;   ///< Max observed ~18 chars from product numbering rules
-  static constexpr size_t NEXTION_FW_MAX = 7;       ///< 'S' prefix + integer (e.g. 'S99' or `123`)
-  static constexpr size_t NEXTION_SERIAL_MAX = 20;  ///< Consistently 16 hex chars across all documented examples
-  char device_model_[NEXTION_MODEL_MAX + 1]{};
-  char firmware_version_[NEXTION_FW_MAX + 1]{};
-  char serial_number_[NEXTION_SERIAL_MAX + 1]{};
-  uint32_t flash_size_ = 0;  ///< Flash size in bytes — plain integer, no string needed
+#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+  std::string device_model_;
+  std::string firmware_version_;
+  std::string serial_number_;
+  std::string flash_size_;
+#endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
 
   void remove_front_no_sensors_();
 

esphome/components/sensor/__init__.py

@@ -96,7 +96,6 @@ from esphome.const import (
     DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_TEMPERATURE_DELTA,
     DEVICE_CLASS_TIMESTAMP,
-    DEVICE_CLASS_UPTIME,
     DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
     DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS_PARTS,
     DEVICE_CLASS_VOLTAGE,
@@ -175,7 +174,6 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_TEMPERATURE_DELTA,
     DEVICE_CLASS_TIMESTAMP,
-    DEVICE_CLASS_UPTIME,
     DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
     DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS_PARTS,
     DEVICE_CLASS_VOLTAGE,

esphome/components/spi/spi.cpp

@@ -16,7 +16,7 @@ GPIOPin *const NullPin::NULL_PIN = new NullPin();  // NOLINT(cppcoreguidelines-a
 
 SPIDelegate *SPIComponent::register_device(SPIClient *device, SPIMode mode, SPIBitOrder bit_order, uint32_t data_rate,
                                            GPIOPin *cs_pin, bool release_device, bool write_only) {
-  if (this->devices_.contains(device)) {
+  if (this->devices_.count(device) != 0) {
     ESP_LOGE(TAG, "Device already registered");
     return this->devices_[device];
   }
@@ -27,7 +27,7 @@ SPIDelegate *SPIComponent::register_device(SPIClient *device, SPIMode mode, SPIB
 }
 
 void SPIComponent::unregister_device(SPIClient *device) {
-  if (!this->devices_.contains(device)) {
+  if (this->devices_.count(device) == 0) {
     esph_log_e(TAG, "Device not registered");
     return;
   }

esphome/components/touchscreen/touchscreen.cpp

@@ -78,7 +78,7 @@ void Touchscreen::add_raw_touch_position_(uint8_t id, int16_t x_raw, int16_t y_r
   if (this->swap_x_y_) {
     std::swap(x_raw, y_raw);
   }
-  if (!this->touches_.contains(id)) {
+  if (this->touches_.count(id) == 0) {
     tp.state = STATE_PRESSED;
     tp.id = id;
   } else {

esphome/components/uponor_smatrix/uponor_smatrix.cpp

@@ -154,7 +154,7 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) {
   }
 
   // Log unknown device addresses
-  if (!found && !this->unknown_devices_.contains(device_address)) {
+  if (!found && !this->unknown_devices_.count(device_address)) {
     ESP_LOGI(TAG, "Received packet for unknown device address 0x%08" PRIX32 " ", device_address);
     this->unknown_devices_.insert(device_address);
   }

esphome/components/uptime/sensor/__init__.py

@@ -4,7 +4,7 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_TIME_ID,
     DEVICE_CLASS_DURATION,
-    DEVICE_CLASS_UPTIME,
+    DEVICE_CLASS_TIMESTAMP,
     ENTITY_CATEGORY_DIAGNOSTIC,
     ICON_TIMER,
     STATE_CLASS_TOTAL_INCREASING,
@@ -33,8 +33,9 @@ CONFIG_SCHEMA = cv.typed_schema(
         ).extend(cv.polling_component_schema("60s")),
         "timestamp": sensor.sensor_schema(
             UptimeTimestampSensor,
+            icon=ICON_TIMER,
             accuracy_decimals=0,
-            device_class=DEVICE_CLASS_UPTIME,
+            device_class=DEVICE_CLASS_TIMESTAMP,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
         )
         .extend(

esphome/components/web_server/web_server.cpp

@@ -2638,9 +2638,9 @@ bool WebServer::isRequestHandlerTrivial() const { return false; }
 
 void WebServer::add_sorting_info_(JsonObject &root, EntityBase *entity) {
 #ifdef USE_WEBSERVER_SORTING
-  if (this->sorting_entitys_.contains(entity)) {
+  if (this->sorting_entitys_.find(entity) != this->sorting_entitys_.end()) {
     root[ESPHOME_F("sorting_weight")] = this->sorting_entitys_[entity].weight;
-    if (this->sorting_groups_.contains(this->sorting_entitys_[entity].group_id)) {
+    if (this->sorting_groups_.find(this->sorting_entitys_[entity].group_id) != this->sorting_groups_.end()) {
       root[ESPHOME_F("sorting_group")] = this->sorting_groups_[this->sorting_entitys_[entity].group_id].name;
     }
   }

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.6.0-dev"
+__version__ = "2026.5.1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -1367,7 +1367,6 @@ DEVICE_CLASS_TEMPERATURE = "temperature"
 DEVICE_CLASS_TEMPERATURE_DELTA = "temperature_delta"
 DEVICE_CLASS_TIMESTAMP = "timestamp"
 DEVICE_CLASS_UPDATE = "update"
-DEVICE_CLASS_UPTIME = "uptime"
 DEVICE_CLASS_VIBRATION = "vibration"
 DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS = "volatile_organic_compounds"
 DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS_PARTS = "volatile_organic_compounds_parts"

esphome/core/__init__.py

@@ -5,7 +5,7 @@ import math
 import os
 from pathlib import Path
 import re
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from esphome.const import (
     CONF_COMMENT,
@@ -569,12 +569,6 @@ class EsphomeCore:
         self.build_path: Path | None = None
         # The validated configuration, this is None until the config has been validated
         self.config: ConfigType | None = None
-        # YAML frontmatter loaded from user YAML files. Frontmatter is a leading
-        # YAML document separated by `---` from the actual configuration. It is
-        # ignored by config validation and code generation, but kept here so it
-        # can be inspected by callers (tooling, future features). Keyed by the
-        # resolved Path of the source file.
-        self.frontmatter: dict[Path, Any] = {}
         # The pending tasks in the task queue (mostly for C++ generation)
         # This is a priority queue (with heapq)
         # Each item is a tuple of form: (-priority, unique number, task)
@@ -640,7 +634,6 @@ class EsphomeCore:
         self.config_path = None
         self.build_path = None
         self.config = None
-        self.frontmatter = {}
         self.event_loop = _FakeEventLoop()
         self.task_counter = 0
         self.variables = {}

esphome/core/defines.h

@@ -134,6 +134,7 @@
 #define USE_MEDIA_SOURCE
 #define USE_NEXTION_COMMAND_SPACING
 #define USE_NEXTION_CONF_START_UP_PAGE
+#define USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
 #define USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
 #define USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
 #define USE_NEXTION_MAX_COMMANDS_PER_LOOP

esphome/core/hal.h

@@ -1,7 +1,6 @@
 #pragma once
-#include <cstdint>
-#include <cstring>
 #include <string>
+#include <cstdint>
 #include "gpio.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/time_64.h"
@@ -43,9 +42,6 @@ void __attribute__((noreturn)) arch_restart();
 inline uint8_t progmem_read_byte(const uint8_t *addr) { return *addr; }
 inline const char *progmem_read_ptr(const char *const *addr) { return *addr; }
 inline uint16_t progmem_read_uint16(const uint16_t *addr) { return *addr; }
-// Bulk copy out of PROGMEM. PROGMEM is a no-op everywhere except ESP8266, so a
-// plain `std::memcpy` is correct and the fast path here.
-inline void progmem_memcpy(void *dst, const void *src, size_t len) { std::memcpy(dst, src, len); }
 #endif
 
 }  // namespace esphome

esphome/espidf/framework.py

@@ -27,18 +27,16 @@ _LOGGER = logging.getLogger(__name__)
 _SCRIPTS_DIR = Path(__file__).parent
 
 
-def _str_to_lst_of_str(a: str | list[str]) -> list[str]:
+def _str_to_lst_of_str(a: str) -> list[str]:
     """
     Convert a string to a list of string
 
     Args:
-        a: A string containing semicolon-separated values, or an already-split list
+        a: A string containing semicolon-separated values
 
     Returns:
         list of strings
     """
-    if isinstance(a, list):
-        return a
     return list(f.strip() for f in a.split(";") if f.strip())
 
 
@@ -70,11 +68,10 @@ ESPHOME_IDF_DEFAULT_FEATURES = _str_to_lst_of_str(
 )
 
 ESPHOME_IDF_FRAMEWORK_MIRRORS = _str_to_lst_of_str(
-    os.environ.get("ESPHOME_IDF_FRAMEWORK_MIRRORS")
-    or [
-        "https://github.com/esphome-libs/esp-idf/releases/download/v{VERSION}/esp-idf-v{VERSION}.tar.xz",
-        "https://github.com/esphome-libs/esp-idf/releases/download/v{MAJOR}.{MINOR}/esp-idf-v{MAJOR}.{MINOR}.tar.xz",
-    ]
+    os.environ.get(
+        "ESPHOME_IDF_FRAMEWORK_MIRRORS",
+        "https://github.com/esphome-libs/esp-idf/releases/download/v{VERSION}/esp-idf-v{VERSION}.tar.xz;https://github.com/esphome-libs/esp-idf/releases/download/v{MAJOR}.{MINOR}/esp-idf-v{MAJOR}.{MINOR}.tar.xz",
+    )
 )
 
 ESP_IDF_CONSTRAINTS_MIRRORS = _str_to_lst_of_str(

esphome/idf_component.yml

@@ -2,7 +2,7 @@ dependencies:
   bblanchon/arduinojson:
     version: "7.4.2"
   esphome/esp-audio-libs:
-    version: 3.1.0
+    version: 3.0.0
   esphome/esp-micro-speech-features:
     version: 1.2.3
   esphome/micro-decoder:

esphome/writer.py

@@ -87,21 +87,6 @@ def replace_file_content(text, pattern, repl):
 
 
 def storage_should_clean(old: StorageJSON | None, new: StorageJSON) -> bool:
-    """Return True when the build tree must be wiped before reuse.
-
-    Predicate is True when *old* is missing (first build),
-    ``src_version`` differs, ``build_path`` differs, or a previously
-    loaded integration was removed in *new*. Adding integrations or
-    changing unrelated fields (friendly name, esphome version, etc.)
-    does not trigger a clean.
-
-    Used by esphome-device-builder (esphome/device-builder) to gate
-    its remote-build artifact materialiser so a local → remote → local
-    cycle preserves PlatformIO's local object cache instead of wiping
-    it on every cycle. The signature, semantics, and ``None`` handling
-    for *old* are part of the public contract; keep them stable so the
-    offloader's wipe decision tracks core's.
-    """
     if old is None:
         return True
 

esphome/yaml_util.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from collections.abc import Callable, Generator
 from contextlib import contextmanager, suppress
-from dataclasses import dataclass, field
 import functools
 import inspect
 from io import BytesIO, TextIOBase, TextIOWrapper
@@ -234,130 +233,6 @@ class IncludeFile:
         return has_substitution_or_expression(str(self.file))
 
 
-def force_load_include_files(
-    obj: Any,
-    *,
-    warn_on_unresolved: bool = True,
-    _seen: set[int] | None = None,
-) -> None:
-    """Recursively resolve any deferred ``IncludeFile`` instances in a YAML tree.
-
-    Nested ``!include`` returns a deferred ``IncludeFile`` that is only resolved
-    later (substitution / packages pass). Callers that need every referenced
-    file to actually load — bundle discovery, on-device YAML recovery — invoke
-    this while a :func:`track_yaml_loads` listener is active so the underlying
-    loader fires and records every reachable file.
-
-    ``IncludeFile`` instances whose path contains unresolved substitution
-    variables cannot be loaded. By default a warning is logged for each one;
-    pass ``warn_on_unresolved=False`` (used by discovery paths that run on a
-    fresh re-parse where substitutions haven't been applied yet) to demote it
-    to a debug log.
-    """
-    if _seen is None:
-        _seen = set()
-
-    if isinstance(obj, IncludeFile):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        if obj.has_unresolved_expressions():
-            log = _LOGGER.warning if warn_on_unresolved else _LOGGER.debug
-            log(
-                "Cannot resolve !include %s (referenced from %s) with substitutions in path",
-                obj.file,
-                obj.parent_file,
-            )
-            return
-        try:
-            loaded = obj.load()
-        except EsphomeError as err:
-            _LOGGER.warning(
-                "Failed to load !include %s (referenced from %s): %s",
-                obj.file,
-                obj.parent_file,
-                err,
-            )
-            return
-        force_load_include_files(
-            loaded, warn_on_unresolved=warn_on_unresolved, _seen=_seen
-        )
-    elif isinstance(obj, dict):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        for value in obj.values():
-            force_load_include_files(
-                value, warn_on_unresolved=warn_on_unresolved, _seen=_seen
-            )
-    elif isinstance(obj, (list, tuple)):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        for item in obj:
-            force_load_include_files(
-                item, warn_on_unresolved=warn_on_unresolved, _seen=_seen
-            )
-
-
-@dataclass(slots=True)
-class DiscoveredYamlFiles:
-    """Result of :func:`discover_user_yaml_files`.
-
-    ``files`` contains every resolved path the YAML loader touched while we
-    were re-parsing the user's config; ``secrets`` is the subset whose
-    *un-resolved* filename matched :data:`esphome.const.SECRETS_FILES` (so
-    a ``secrets.yaml`` symlinked to a differently-named target is still
-    flagged as secrets).
-    """
-
-    files: list[Path] = field(default_factory=list)
-    secrets: set[Path] = field(default_factory=set)
-
-
-def discover_user_yaml_files(config_path: Path) -> DiscoveredYamlFiles:
-    """Fresh-re-parse ``config_path`` and report every file the YAML loader
-    pulled in, plus which of them came in under a secrets filename.
-
-    Does NOT run schema validation, substitutions, or package resolution — so
-    component-internal YAML loaded by validators (LVGL helpers, dashboard
-    imports, etc.) is *not* captured. Deferred ``!include`` references whose
-    paths don't depend on substitutions are force-loaded here so they're
-    captured too.
-
-    Must run on a fresh parse because :meth:`IncludeFile.load` caches its
-    result; on an already-resolved tree :meth:`load` returns without invoking
-    the loader and the listener would not fire for the referenced files.
-    """
-    from esphome.const import SECRETS_FILES
-
-    secrets: set[Path] = set()
-
-    def _capture_secret(fname: Path) -> None:
-        if Path(fname).name in SECRETS_FILES:
-            secrets.add(Path(fname).resolve())
-
-    with track_yaml_loads() as loaded:
-        _load_listeners.append(_capture_secret)
-        try:
-            try:
-                data = load_yaml(config_path)
-            except EsphomeError:
-                return DiscoveredYamlFiles(list(loaded), secrets)
-            force_load_include_files(data, warn_on_unresolved=False)
-        finally:
-            _load_listeners.remove(_capture_secret)
-
-    # Deduplicate while preserving first-seen order.
-    seen: set[Path] = set()
-    unique: list[Path] = []
-    for path in loaded:
-        if path not in seen:
-            seen.add(path)
-            unique.append(path)
-    return DiscoveredYamlFiles(unique, secrets)
-
-
 def _add_data_ref(fn):
     @functools.wraps(fn)
     def wrapped(loader, node):
@@ -768,35 +643,10 @@ def _load_yaml_internal_with_type(
     content: TextIOWrapper,
     yaml_loader: Callable[[Path], dict[str, Any]],
 ) -> Any:
-    """Load a YAML file.
-
-    Supports an optional leading YAML frontmatter document: when the file
-    contains two YAML documents separated by ``---``, the first document is
-    treated as metadata and stored in :attr:`CORE.frontmatter` keyed by the
-    resolved file path, while the second document is returned as the actual
-    configuration. Frontmatter is ignored by config validation and code
-    generation.
-    """
+    """Load a YAML file."""
     loader = loader_type(content, fname, yaml_loader)
     try:
-        documents: list[Any] = []
-        while loader.check_data():
-            documents.append(loader.get_data())
-        if len(documents) > 2:
-            raise EsphomeError(
-                f"YAML file '{fname}' contains {len(documents)} documents but "
-                f"at most two are supported (an optional frontmatter document "
-                f"followed by the configuration)."
-            )
-        if len(documents) == 2:
-            frontmatter = documents[0]
-            config = documents[1]
-            if frontmatter is not None:
-                CORE.frontmatter[Path(fname).resolve()] = frontmatter
-            return config if config is not None else OrderedDict()
-        if len(documents) == 1:
-            return documents[0] or OrderedDict()
-        return OrderedDict()
+        return loader.get_single_data() or OrderedDict()
     except yaml.YAMLError as exc:
         raise EsphomeError(exc) from exc
     finally:

requirements.txt

@@ -19,12 +19,12 @@ ruamel.yaml==0.19.1 # dashboard_import
 ruamel.yaml.clib==0.2.15 # dashboard_import
 esphome-glyphsets==0.2.0
 pillow==12.2.0
-resvg-py==0.3.2
+resvg-py==0.3.1
 freetype-py==2.5.1
 jinja2==3.1.6
 bleak==2.1.1
 smpclient==6.0.0
-requests==2.34.2
+requests==2.34.1
 
 # esp-idf >= 5.0 requires this
 pyparsing >= 3.3.2

requirements_test.txt

@@ -1,6 +1,6 @@
 pylint==4.0.5
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.15.14  # also change in .pre-commit-config.yaml when updating
+ruff==0.15.12  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
 pre-commit
 
@@ -16,7 +16,7 @@ hypothesis==6.92.1
 # CodSpeed benchmarks under tests/benchmarks/python/
 # (skipped via pytest.importorskip when missing -- only required for the
 # benchmarks job in .github/workflows/ci.yml)
-pytest-codspeed==5.0.3
+pytest-codspeed==5.0.1
 
 # Used by the import-time regression check (.github/workflows/ci.yml → import-time job)
 importtime-waterfall==1.0.0

script/determine-jobs.py

@@ -5,7 +5,6 @@ This script is a centralized way to determine which CI jobs need to run based on
 what files have changed. It outputs JSON with the following structure:
 
 {
-  "core_ci": true/false,
   "integration_tests": true/false,
   "integration_test_buckets": [{"name": "1/3", "tests": ["tests/integration/test_foo.py", ...]}, ...],
   "clang_tidy": true/false,
@@ -23,11 +22,6 @@ what files have changed. It outputs JSON with the following structure:
 }
 
 The CI workflow uses this information to:
-- Gate the unconditional jobs (ci-custom, pytest, pre-commit-ci-lite) via core_ci;
-  false when a pull_request only touches CI-irrelevant meta paths (other workflow
-  files, .github/actions/build-image/*, .yamllint, .github/dependabot.yml, docker/**)
-  so workflow-only PRs satisfy the required CI Status check without running the
-  unconditional jobs. Always true on non-pull_request events and under --force-all.
 - Skip or run integration tests
 - Skip or run clang-tidy (and whether to do a full scan)
 - Skip or run clang-format
@@ -718,69 +712,6 @@ def should_run_benchmarks(branch: str | None = None) -> bool:
     return any(get_component_from_path(f) in benchmarked_components for f in files)
 
 
-# Files / path patterns whose changes alone don't warrant running the
-# unconditional CI jobs (`ci-custom`, `pytest`, `pre-commit-ci-lite`).
-# Single source of truth for what we treat as "CI-irrelevant" on
-# pull_request events; ci.yml used to encode this in its own
-# `pull_request.paths` filter, but that hid the required `CI Status`
-# check on PRs that only touched these files (dependabot Action bumps,
-# dependabot.yml edits, docker/ changes, etc.) and forced admin
-# force-merges.
-#
-# ci.yml itself is deliberately *not* ignored — editing the CI workflow
-# must still run CI. Workflows that have their own dedicated triggers
-# (codeql.yml, ci-docker.yml, ...) are matched via the
-# `.github/workflows/*.yml` prefix below and exclude ci.yml explicitly.
-CI_IRRELEVANT_EXACT_FILES = frozenset(
-    {
-        ".yamllint",
-        ".github/dependabot.yml",
-    }
-)
-
-
-def _is_ci_irrelevant_path(path: str) -> bool:
-    """Whether a single changed path is irrelevant to the unconditional CI jobs."""
-    if path in CI_IRRELEVANT_EXACT_FILES:
-        return True
-    # docker/** — all descendants
-    if path.startswith("docker/"):
-        return True
-    # .github/workflows/*.yml — top-level workflow files other than ci.yml
-    # (ci.yml itself must still trigger full CI when edited).
-    if path.startswith(".github/workflows/") and path.endswith(".yml"):
-        if path == ".github/workflows/ci.yml":
-            return False
-        if "/" not in path[len(".github/workflows/") :]:
-            return True
-    # .github/actions/build-image/* — direct children only, matches the
-    # single-star glob the workflow used to encode.
-    if path.startswith(".github/actions/build-image/"):
-        rest = path[len(".github/actions/build-image/") :]
-        if rest and "/" not in rest:
-            return True
-    return False
-
-
-def should_run_core_ci(branch: str | None = None) -> bool:
-    """Determine if the unconditional CI jobs (ci-custom/pytest/pre-commit-ci-lite) should run.
-
-    Returns False only when every changed file is in the CI-irrelevant set
-    above (see ``_is_ci_irrelevant_path``). Empty diffs return True so we
-    never accidentally skip CI when the diff probe fails.
-
-    Args:
-        branch: Branch to compare against. If None, uses default.
-
-    Returns:
-        True if the unconditional CI jobs should run, False otherwise.
-    """
-    files = changed_files(branch)
-    if not files:
-        return True
-    return any(not _is_ci_irrelevant_path(f) for f in files)
-
-
 def _any_changed_file_endswith(branch: str | None, extensions: tuple[str, ...]) -> bool:
     """Check if a changed file ends with any of the specified extensions."""
     return any(file.endswith(extensions) for file in changed_files(branch))
@@ -1131,52 +1062,22 @@ def main() -> None:
     parser.add_argument(
         "-b", "--branch", help="Branch to compare changed files against"
     )
-    parser.add_argument(
-        "--force-all",
-        action="store_true",
-        help=(
-            "Force every job to run regardless of what changed. Used by CI "
-            "when the ci-run-all label is applied to a PR (escape hatch for "
-            "changes that need full-matrix validation but don't touch enough "
-            "files to trigger it organically)."
-        ),
-    )
     args = parser.parse_args()
 
     # Determine what should run
-    # core_ci gates the unconditional jobs in ci.yml (ci-custom, pytest,
-    # pre-commit-ci-lite). Non-pull_request events (push to dev/beta/release
-    # and merge_group) always run them so behavior like venv-cache saves on
-    # push to dev is preserved.
-    event_name = os.environ.get("GITHUB_EVENT_NAME", "")
-    run_core_ci = (
-        True
-        if args.force_all or event_name != "pull_request"
-        else should_run_core_ci(args.branch)
+    integration_run_all, integration_test_files = determine_integration_tests(
+        args.branch
     )
-    if args.force_all:
-        integration_run_all, integration_test_files = True, []
-        run_clang_tidy = True
-        run_clang_format = True
-        run_python_linters = True
-        run_import_time = True
-        run_device_builder = True
-        native_idf_components = sorted(NATIVE_IDF_TEST_COMPONENTS)
-        run_native_idf = True
-    else:
-        integration_run_all, integration_test_files = determine_integration_tests(
-            args.branch
-        )
-        run_clang_tidy = should_run_clang_tidy(args.branch)
-        run_clang_format = should_run_clang_format(args.branch)
-        run_python_linters = should_run_python_linters(args.branch)
-        run_import_time = should_run_import_time(args.branch)
-        run_device_builder = should_run_device_builder(args.branch)
-        native_idf_components = native_idf_components_to_test(args.branch)
-        run_native_idf = bool(native_idf_components)
     run_integration, integration_test_buckets = _compute_integration_test_buckets(
         integration_run_all, integration_test_files
     )
+    run_clang_tidy = should_run_clang_tidy(args.branch)
+    run_clang_format = should_run_clang_format(args.branch)
+    run_python_linters = should_run_python_linters(args.branch)
+    run_import_time = should_run_import_time(args.branch)
+    run_device_builder = should_run_device_builder(args.branch)
+    native_idf_components = native_idf_components_to_test(args.branch)
+    run_native_idf = bool(native_idf_components)
     changed_cpp_file_count = count_changed_cpp_files(args.branch)
 
     # Get changed components
@@ -1205,27 +1106,11 @@ def main() -> None:
         changed_components = changed_components_result
         is_core_change = False
 
-    if args.force_all:
-        # Force every component with tests into the CI matrix. Each disk entry
-        # under tests/components/<name> is treated as a component; filtered
-        # below by _component_has_tests so components without YAML tests are
-        # still excluded.
-        tests_root = Path(root_path) / ESPHOME_TESTS_COMPONENTS_PATH
-        all_components = sorted(d.name for d in tests_root.iterdir() if d.is_dir())
-        changed_components_with_tests = [
-            component for component in all_components if _component_has_tests(component)
-        ]
-        # Treat as a core change so downstream logic (clang-tidy full scan,
-        # dep expansion) sees the same world as when esphome/core/ changes.
-        is_core_change = True
-    else:
-        # Filter to only components that have test files
-        # Components without tests shouldn't generate CI test jobs
-        changed_components_with_tests = [
-            component
-            for component in changed_components
-            if _component_has_tests(component)
-        ]
+    # Filter to only components that have test files
+    # Components without tests shouldn't generate CI test jobs
+    changed_components_with_tests = [
+        component for component in changed_components if _component_has_tests(component)
+    ]
 
     # Get directly changed components with tests (for isolated testing)
     # These will be tested WITHOUT --testing-mode in CI to enable full validation
@@ -1258,10 +1143,8 @@ def main() -> None:
     memory_impact = detect_memory_impact_config(args.branch)
 
     # Determine clang-tidy mode based on actual files that will be checked
-    is_full_scan = False
     if run_clang_tidy:
         # Full scan needed if: hash changed OR core files changed
-        # (is_core_change is forced True under --force-all)
         is_full_scan = _is_clang_tidy_full_scan() or is_core_change
 
         if is_full_scan:
@@ -1294,12 +1177,10 @@ def main() -> None:
 
     # Build output
     # Determine which C++ unit tests to run
-    if args.force_all:
-        cpp_run_all, cpp_components = True, []
-        run_benchmarks = True
-    else:
-        cpp_run_all, cpp_components = determine_cpp_unit_tests(args.branch)
-        run_benchmarks = should_run_benchmarks(args.branch)
+    cpp_run_all, cpp_components = determine_cpp_unit_tests(args.branch)
+
+    # Determine if benchmarks should run
+    run_benchmarks = should_run_benchmarks(args.branch)
 
     # Split components into batches for CI testing
     # This intelligently groups components with similar bus configurations
@@ -1334,12 +1215,10 @@ def main() -> None:
         component_test_batches = []
 
     output: dict[str, Any] = {
-        "core_ci": run_core_ci,
         "integration_tests": run_integration,
         "integration_test_buckets": integration_test_buckets,
         "clang_tidy": run_clang_tidy,
         "clang_tidy_mode": clang_tidy_mode,
-        "clang_tidy_full_scan": is_full_scan,
         "clang_format": run_clang_format,
         "python_linters": run_python_linters,
         "import_time": run_import_time,

tests/component_tests/light/test_effect_validation.py

@@ -9,17 +9,13 @@ import pytest
 
 from esphome import config_validation as cv
 from esphome.components.light import (
-    EffectCycleRef,
     EffectRef,
     _final_validate,
     _get_data,
     available_effects_str,
     find_effect_index,
 )
-from esphome.components.light.automation import (
-    _record_effect_cycle_ref,
-    _record_effect_ref,
-)
+from esphome.components.light.automation import _record_effect_ref
 from esphome.config import Config, path_context
 from esphome.const import CONF_EFFECT, CONF_EFFECTS, CONF_ID, CONF_NAME
 from esphome.core import ID, Lambda
@@ -219,111 +215,6 @@ def test_final_validate_drains_refs() -> None:
         fv.full_config.reset(token)
 
 
-# --- _final_validate: EffectCycleRef ---
-
-
-def _setup_cycle_final_validate(
-    cycle_refs: list[EffectCycleRef],
-    light_configs: list[ConfigType],
-    declare_ids: list[tuple[ID, list[str | int]]],
-) -> Token:
-    """Set up CORE.data and fv.full_config for EffectCycleRef final_validate tests."""
-    data = _get_data()
-    data.effect_cycle_refs = cycle_refs
-
-    full_conf = Config()
-    full_conf["light"] = light_configs
-    for id_, path in declare_ids:
-        full_conf.declare_ids.append((id_, path))
-
-    return fv.full_config.set(full_conf)
-
-
-def test_final_validate_cycle_accepts_light_with_effects() -> None:
-    """Cycle ref against a light with effects should not raise."""
-    light_id = ID("led1", is_declaration=True)
-    token = _setup_cycle_final_validate(
-        cycle_refs=[
-            EffectCycleRef(light_id=light_id, component_path=["esphome"]),
-        ],
-        light_configs=[{CONF_ID: light_id, CONF_EFFECTS: _make_effects("Fast Pulse")}],
-        declare_ids=[(light_id, ["light", 0, CONF_ID])],
-    )
-    try:
-        _final_validate({})
-    finally:
-        fv.full_config.reset(token)
-
-
-def test_final_validate_cycle_rejects_light_without_effects_key() -> None:
-    """Cycle ref against a light with no CONF_EFFECTS key should raise."""
-    light_id = ID("led1", is_declaration=True)
-    token = _setup_cycle_final_validate(
-        cycle_refs=[
-            EffectCycleRef(light_id=light_id, component_path=["esphome"]),
-        ],
-        light_configs=[{CONF_ID: light_id}],
-        declare_ids=[(light_id, ["light", 0, CONF_ID])],
-    )
-    try:
-        with pytest.raises(cv.FinalExternalInvalid, match="no effects configured"):
-            _final_validate({})
-    finally:
-        fv.full_config.reset(token)
-
-
-def test_final_validate_cycle_rejects_light_with_empty_effects() -> None:
-    """Cycle ref against a light with empty effects list should raise."""
-    light_id = ID("led1", is_declaration=True)
-    token = _setup_cycle_final_validate(
-        cycle_refs=[
-            EffectCycleRef(light_id=light_id, component_path=["esphome"]),
-        ],
-        light_configs=[{CONF_ID: light_id, CONF_EFFECTS: []}],
-        declare_ids=[(light_id, ["light", 0, CONF_ID])],
-    )
-    try:
-        with pytest.raises(cv.FinalExternalInvalid, match="no effects configured"):
-            _final_validate({})
-    finally:
-        fv.full_config.reset(token)
-
-
-def test_final_validate_cycle_unknown_light_id_skipped() -> None:
-    """Cycle refs to unknown light IDs should be silently skipped."""
-    data = _get_data()
-    data.effect_cycle_refs = [
-        EffectCycleRef(
-            light_id=ID("nonexistent", is_declaration=True),
-            component_path=["esphome"],
-        )
-    ]
-
-    full_conf = Config()
-    token = fv.full_config.set(full_conf)
-    try:
-        _final_validate({})
-    finally:
-        fv.full_config.reset(token)
-
-
-def test_final_validate_drains_cycle_refs() -> None:
-    """Cycle refs should be drained after validation to avoid redundant runs."""
-    light_id = ID("led1", is_declaration=True)
-    token = _setup_cycle_final_validate(
-        cycle_refs=[
-            EffectCycleRef(light_id=light_id, component_path=["esphome"]),
-        ],
-        light_configs=[{CONF_ID: light_id, CONF_EFFECTS: _make_effects("Fast Pulse")}],
-        declare_ids=[(light_id, ["light", 0, CONF_ID])],
-    )
-    try:
-        _final_validate({})
-        assert _get_data().effect_cycle_refs == []
-    finally:
-        fv.full_config.reset(token)
-
-
 # --- _record_effect_ref ---
 
 
@@ -387,19 +278,3 @@ def test_record_effect_ref_skips_no_effect_key() -> None:
     config: ConfigType = {CONF_ID: ID("led1", is_declaration=True)}
     _record_effect_ref(config)
     assert _get_data().effect_refs == []
-
-
-# --- _record_effect_cycle_ref ---
-
-
-@pytest.mark.usefixtures("_path_ctx")
-def test_record_effect_cycle_ref() -> None:
-    """Cycle-action config should be recorded with light_id and path."""
-    light_id = ID("led1", is_declaration=True)
-    config: ConfigType = {CONF_ID: light_id}
-    result = _record_effect_cycle_ref(config)
-    assert result is config
-    data = _get_data()
-    assert len(data.effect_cycle_refs) == 1
-    assert data.effect_cycle_refs[0].light_id is light_id
-    assert data.effect_cycle_refs[0].component_path == ["esphome"]

tests/component_tests/lvgl/test_container_schema_cache.py

@@ -1,87 +0,0 @@
-"""Tests for container_schema() memoization and lazy build."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-from unittest.mock import patch
-
-import pytest
-
-from esphome import config_validation as cv
-import esphome.components.lvgl  # noqa: F401
-from esphome.components.lvgl import schemas as lvgl_schemas
-from esphome.components.lvgl.schemas import WIDGET_TYPES, container_schema
-
-
-@pytest.fixture(autouse=True)
-def _clear_container_schema_cache() -> Generator[None]:
-    cache = getattr(lvgl_schemas, "_CONTAINER_SCHEMA_CACHE", None)
-    if cache is not None:
-        cache.clear()
-    yield
-    if cache is not None:
-        cache.clear()
-
-
-def _widget_type(name: str = "obj"):
-    wt = WIDGET_TYPES.get(name)
-    assert wt is not None, f"widget type {name!r} not registered"
-    return wt
-
-
-def test_same_args_return_same_validator() -> None:
-    wt = _widget_type("obj")
-    assert container_schema(wt) is container_schema(wt)
-
-
-def test_extras_none_vs_truthy_get_different_validators() -> None:
-    wt = _widget_type("obj")
-    no_extras = container_schema(wt)
-    extras = {cv.Optional("custom_extra"): cv.string}
-    assert no_extras is not container_schema(wt, extras)
-
-
-def test_different_widget_types_get_different_validators() -> None:
-    assert container_schema(_widget_type("obj")) is not container_schema(
-        _widget_type("label")
-    )
-
-
-def test_schema_build_is_deferred_until_first_validation() -> None:
-    wt = _widget_type("obj")
-    with patch.object(
-        lvgl_schemas, "obj_schema", wraps=lvgl_schemas.obj_schema
-    ) as obj_schema_mock:
-        validator = container_schema(wt)
-        assert obj_schema_mock.call_count == 0
-        validator({})
-        assert obj_schema_mock.call_count == 1
-        validator({})
-        assert obj_schema_mock.call_count == 1
-
-
-def test_cached_validator_produces_equivalent_output() -> None:
-    wt = _widget_type("obj")
-    cached = container_schema(wt)
-    cached_result = cached({})
-    lvgl_schemas._CONTAINER_SCHEMA_CACHE.clear()
-    reference = container_schema(wt)
-    assert cached is not reference
-    assert cached_result == reference({})
-
-
-def test_id_recycling_is_caught_by_identity_guard() -> None:
-    wt = _widget_type("obj")
-    real_extras = {cv.Optional("a"): cv.int_}
-    validator_a = container_schema(wt, real_extras)
-
-    cache_key = (id(wt), id(real_extras))
-    cached_entry = lvgl_schemas._CONTAINER_SCHEMA_CACHE[cache_key]
-    sentinel = {cv.Optional("a"): cv.int_}
-    lvgl_schemas._CONTAINER_SCHEMA_CACHE[cache_key] = (
-        cached_entry[0],
-        sentinel,
-        cached_entry[2],
-    )
-
-    assert container_schema(wt, real_extras) is not validator_a

tests/component_tests/lvgl/test_update_action_lazy.py

@@ -1,53 +0,0 @@
-"""Tests for lvgl.<widget>.update lazy schema build."""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-
-from esphome.automation import ACTION_REGISTRY
-import esphome.components.lvgl  # noqa: F401
-from esphome.components.lvgl.schemas import WIDGET_TYPES
-from esphome.components.lvgl.widgets import _update_action_schema
-from esphome.config_validation import Schema
-
-
-def _widget_type(name: str = "obj"):
-    wt = WIDGET_TYPES.get(name)
-    assert wt is not None, f"widget type {name!r} not registered"
-    return wt
-
-
-def test_registry_entry_uses_lazy_validator() -> None:
-    entry = ACTION_REGISTRY["lvgl.label.update"]
-    assert callable(entry.raw_schema)
-    assert not isinstance(entry.raw_schema, Schema)
-
-
-def test_lazy_validator_defers_build_until_first_call() -> None:
-    wt = _widget_type("label")
-    with patch(
-        "esphome.components.lvgl.widgets._build_update_schema",
-        wraps=lambda w: Schema({}),
-    ) as build_mock:
-        validator = _update_action_schema(wt)
-        assert build_mock.call_count == 0
-        validator({})
-        assert build_mock.call_count == 1
-        validator({})
-        assert build_mock.call_count == 1
-
-
-def test_eager_build_when_schema_extraction_enabled() -> None:
-    wt = _widget_type("label")
-    with patch("esphome.components.lvgl.widgets.EnableSchemaExtraction", True):
-        result = _update_action_schema(wt)
-    assert isinstance(result, Schema)
-
-
-def test_lazy_and_eager_produce_equivalent_validation() -> None:
-    wt = _widget_type("label")
-    with patch("esphome.components.lvgl.widgets.EnableSchemaExtraction", True):
-        eager = _update_action_schema(wt)
-    lazy = _update_action_schema(wt)
-    sample = {"id": "label_id"}
-    assert lazy(sample) == eager(sample)

tests/components/light/common.yaml

@@ -103,16 +103,6 @@ esphome:
             - light.turn_on:
                 id: test_monochromatic_light
                 effect: !lambda 'return iteration > 1 ? "Strobe" : "none";'
-      # Cycle through configured effects (skip "None")
-      - light.effect.next: test_monochromatic_light
-      - light.effect.previous: test_monochromatic_light
-      # Cycle through effects including "None"
-      - light.effect.next:
-          id: test_monochromatic_light
-          include_none: true
-      - light.effect.previous:
-          id: test_monochromatic_light
-          include_none: true
       - light.dim_relative:
           id: test_monochromatic_light
           relative_brightness: 5%

tests/components/nextion/common.yaml

@@ -276,6 +276,7 @@ display:
     auto_wake_on_touch: true
     brightness: 80%
     command_spacing: 5ms
+    dump_device_info: true
     exit_reparse_on_start: true
     lambda: |-
         ESP_LOGD("display","Display is being tested!");

tests/script/test_determine_jobs.py

@@ -775,88 +775,6 @@ def test_should_run_import_time_with_branch() -> None:
         mock_changed.assert_called_once_with("release")
 
 
-@pytest.mark.parametrize(
-    ("path", "expected_result"),
-    [
-        # Exact-file matches in the CI-irrelevant set.
-        (".yamllint", True),
-        (".github/dependabot.yml", True),
-        # Other top-level workflow files are irrelevant; ci.yml itself is not.
-        (".github/workflows/codeql.yml", True),
-        (".github/workflows/release.yml", True),
-        (".github/workflows/ci.yml", False),
-        # Nested files under workflows/ are not matched by the single-star glob.
-        (".github/workflows/matchers/gcc.json", False),
-        # build-image action: direct children only (single-star glob).
-        (".github/actions/build-image/action.yml", True),
-        (".github/actions/build-image/nested/file.yml", False),
-        # Other actions are CI-relevant.
-        (".github/actions/restore-python/action.yml", False),
-        # docker/** covers everything under docker/.
-        ("docker/Dockerfile", True),
-        ("docker/scripts/run.sh", True),
-        # Regular source files are CI-relevant.
-        ("esphome/__main__.py", False),
-        ("esphome/components/wifi/wifi_component.cpp", False),
-        ("README.md", False),
-        ("tests/script/test_determine_jobs.py", False),
-    ],
-)
-def test_is_ci_irrelevant_path(path: str, expected_result: bool) -> None:
-    """Test _is_ci_irrelevant_path mirrors the historic ci.yml path filter."""
-    assert determine_jobs._is_ci_irrelevant_path(path) == expected_result
-
-
-@pytest.mark.parametrize(
-    ("changed_files", "expected_result"),
-    [
-        # Empty diffs default to True — don't accidentally skip CI on a
-        # broken probe.
-        ([], True),
-        # Any CI-relevant file flips the result to True.
-        (["esphome/__main__.py"], True),
-        (["esphome/components/wifi/wifi_component.cpp"], True),
-        (["README.md"], True),
-        # All-irrelevant diffs return False.
-        ([".github/workflows/codeql.yml"], False),
-        (
-            [".github/workflows/codeql.yml", ".github/workflows/release.yml"],
-            False,
-        ),
-        ([".yamllint"], False),
-        ([".github/dependabot.yml"], False),
-        (["docker/Dockerfile"], False),
-        (
-            [
-                ".github/workflows/codeql.yml",
-                ".github/dependabot.yml",
-                "docker/Dockerfile",
-            ],
-            False,
-        ),
-        # Mixed diffs always trigger CI.
-        (
-            [".github/workflows/codeql.yml", "esphome/__main__.py"],
-            True,
-        ),
-        # ci.yml itself is treated as CI-relevant.
-        ([".github/workflows/ci.yml"], True),
-    ],
-)
-def test_should_run_core_ci(changed_files: list[str], expected_result: bool) -> None:
-    """Test should_run_core_ci function."""
-    with patch.object(determine_jobs, "changed_files", return_value=changed_files):
-        assert determine_jobs.should_run_core_ci() == expected_result
-
-
-def test_should_run_core_ci_with_branch() -> None:
-    """Test should_run_core_ci passes the branch through to changed_files."""
-    with patch.object(determine_jobs, "changed_files") as mock_changed:
-        mock_changed.return_value = []
-        determine_jobs.should_run_core_ci("release")
-        mock_changed.assert_called_once_with("release")
-
-
 @pytest.mark.parametrize(
     ("changed_files", "expected_result"),
     [
@@ -1600,7 +1518,6 @@ def test_clang_tidy_mode_full_scan(
     mock_should_run_clang_tidy: Mock,
     mock_should_run_clang_format: Mock,
     mock_should_run_python_linters: Mock,
-    mock_determine_cpp_unit_tests: Mock,
     mock_changed_files: Mock,
     capsys: pytest.CaptureFixture[str],
     monkeypatch: pytest.MonkeyPatch,
@@ -1612,9 +1529,6 @@ def test_clang_tidy_mode_full_scan(
     mock_should_run_clang_tidy.return_value = True
     mock_should_run_clang_format.return_value = False
     mock_should_run_python_linters.return_value = False
-    # Without this mock, main() runs the real determine_cpp_unit_tests
-    # which loads the full component graph (~5s import of every component).
-    mock_determine_cpp_unit_tests.return_value = (False, [])
 
     # Mock changed_files to return no component files
     mock_changed_files.return_value = []
@@ -1670,7 +1584,6 @@ def test_clang_tidy_mode_targeted_scan(
     mock_should_run_clang_tidy: Mock,
     mock_should_run_clang_format: Mock,
     mock_should_run_python_linters: Mock,
-    mock_determine_cpp_unit_tests: Mock,
     mock_changed_files: Mock,
     capsys: pytest.CaptureFixture[str],
     monkeypatch: pytest.MonkeyPatch,
@@ -1682,9 +1595,6 @@ def test_clang_tidy_mode_targeted_scan(
     mock_should_run_clang_tidy.return_value = True
     mock_should_run_clang_format.return_value = False
     mock_should_run_python_linters.return_value = False
-    # Without this mock, main() runs the real determine_cpp_unit_tests
-    # which loads the full component graph (~5s import of every component).
-    mock_determine_cpp_unit_tests.return_value = (False, [])
 
     # Create component names
     components = [f"comp{i}" for i in range(component_count)]
@@ -2692,151 +2602,3 @@ def test_main_validate_only_excludes_transitive_components(
     # Only foo (directly changed, validate-only). bar is a transitive dep
     # and still needs compile despite no source change of its own.
     assert output["validate_only_components"] == ["foo"]
-
-
-def test_main_force_all_overrides_detection(
-    mock_determine_integration_tests: Mock,
-    mock_should_run_clang_tidy: Mock,
-    mock_should_run_clang_format: Mock,
-    mock_should_run_python_linters: Mock,
-    mock_should_run_import_time: Mock,
-    mock_should_run_device_builder: Mock,
-    mock_native_idf_components_to_test: Mock,
-    mock_determine_cpp_unit_tests: Mock,
-    mock_changed_files: Mock,
-    capsys: pytest.CaptureFixture[str],
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """--force-all bypasses per-feature detection and runs every job.
-
-    Detection mocks all return False/empty (which would normally skip
-    everything) -- the flag must override them. Also verifies clang-tidy
-    goes to ``split`` (full scan) and the component-test matrix is
-    populated from disk rather than from changed-files.
-    """
-    monkeypatch.delenv("GITHUB_ACTIONS", raising=False)
-
-    mock_determine_integration_tests.return_value = (False, [])
-    mock_should_run_clang_tidy.return_value = False
-    mock_should_run_clang_format.return_value = False
-    mock_should_run_python_linters.return_value = False
-    mock_should_run_import_time.return_value = False
-    mock_should_run_device_builder.return_value = False
-    mock_native_idf_components_to_test.return_value = []
-    mock_determine_cpp_unit_tests.return_value = (False, [])
-    mock_changed_files.return_value = []
-
-    with (
-        patch("sys.argv", ["determine-jobs.py", "--force-all"]),
-        patch.object(determine_jobs, "get_changed_components", return_value=[]),
-        patch.object(
-            determine_jobs, "filter_component_and_test_files", return_value=False
-        ),
-        patch.object(
-            determine_jobs, "get_components_with_dependencies", return_value=[]
-        ),
-        patch.object(
-            determine_jobs,
-            "detect_memory_impact_config",
-            return_value={"should_run": "false"},
-        ),
-        patch.object(determine_jobs, "should_run_benchmarks", return_value=False),
-        # create_intelligent_batches scans every tests/components/<name>/*.yaml
-        # under --force-all (~2500 YAML loads, ~10s in CI). This test only
-        # asserts that main() routes to it and returns non-empty -- the
-        # batching logic itself has its own dedicated tests.
-        patch.object(
-            determine_jobs,
-            "create_intelligent_batches",
-            return_value=([["fake_batch"]], None),
-        ),
-    ):
-        determine_jobs.main()
-
-    output = json.loads(capsys.readouterr().out)
-
-    assert output["integration_tests"] is True
-    assert output["clang_tidy"] is True
-    assert output["clang_tidy_mode"] == "split"
-    assert output["clang_tidy_full_scan"] is True
-    assert output["clang_format"] is True
-    assert output["python_linters"] is True
-    assert output["import_time"] is True
-    assert output["device_builder"] is True
-    assert output["native_idf"] is True
-    # native_idf_components is a CSV of NATIVE_IDF_TEST_COMPONENTS
-    assert "esp32" in output["native_idf_components"].split(",")
-    assert output["cpp_unit_tests_run_all"] is True
-    assert output["cpp_unit_tests_components"] == []
-    assert output["benchmarks"] is True
-    # Detection helpers must not be consulted when --force-all is set
-    mock_determine_integration_tests.assert_not_called()
-    mock_should_run_clang_tidy.assert_not_called()
-    mock_should_run_clang_format.assert_not_called()
-    mock_should_run_python_linters.assert_not_called()
-    mock_should_run_import_time.assert_not_called()
-    mock_should_run_device_builder.assert_not_called()
-    mock_native_idf_components_to_test.assert_not_called()
-    mock_determine_cpp_unit_tests.assert_not_called()
-    # Component matrix is populated from disk (tests/components/ in the repo)
-    assert output["component_test_count"] > 0
-    assert len(output["component_test_batches"]) > 0
-
-
-def test_main_force_all_off_uses_detection(
-    mock_determine_integration_tests: Mock,
-    mock_should_run_clang_tidy: Mock,
-    mock_should_run_clang_format: Mock,
-    mock_should_run_python_linters: Mock,
-    mock_should_run_import_time: Mock,
-    mock_should_run_device_builder: Mock,
-    mock_native_idf_components_to_test: Mock,
-    mock_determine_cpp_unit_tests: Mock,
-    mock_changed_files: Mock,
-    capsys: pytest.CaptureFixture[str],
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Without --force-all, detection helpers drive the decision (regression guard)."""
-    monkeypatch.delenv("GITHUB_ACTIONS", raising=False)
-
-    mock_determine_integration_tests.return_value = (False, [])
-    mock_should_run_clang_tidy.return_value = False
-    mock_should_run_clang_format.return_value = False
-    mock_should_run_python_linters.return_value = False
-    mock_should_run_import_time.return_value = False
-    mock_should_run_device_builder.return_value = False
-    mock_native_idf_components_to_test.return_value = []
-    mock_determine_cpp_unit_tests.return_value = (False, [])
-    mock_changed_files.return_value = []
-
-    with (
-        patch("sys.argv", ["determine-jobs.py"]),
-        patch.object(determine_jobs, "get_changed_components", return_value=[]),
-        patch.object(
-            determine_jobs, "filter_component_and_test_files", return_value=False
-        ),
-        patch.object(
-            determine_jobs, "get_components_with_dependencies", return_value=[]
-        ),
-        patch.object(
-            determine_jobs,
-            "detect_memory_impact_config",
-            return_value={"should_run": "false"},
-        ),
-        patch.object(
-            determine_jobs, "create_intelligent_batches", return_value=([], {})
-        ),
-        patch.object(determine_jobs, "should_run_benchmarks", return_value=False),
-    ):
-        determine_jobs.main()
-
-    output = json.loads(capsys.readouterr().out)
-
-    assert output["integration_tests"] is False
-    assert output["clang_tidy"] is False
-    assert output["clang_format"] is False
-    assert output["python_linters"] is False
-    assert output["native_idf"] is False
-    assert output["component_test_count"] == 0
-    mock_determine_integration_tests.assert_called_once()
-    mock_should_run_clang_tidy.assert_called_once()

tests/unit_tests/test_bundle.py

@@ -22,13 +22,13 @@ from esphome.bundle import (
     _add_bytes_to_tar,
     _default_target_dir,
     _find_used_secret_keys,
+    _force_load_include_files,
     extract_bundle,
     is_bundle_path,
     prepare_bundle_for_compile,
     read_bundle_manifest,
 )
 from esphome.core import CORE, EsphomeError
-from esphome.yaml_util import force_load_include_files
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -947,7 +947,7 @@ def test_discover_files_nested_include_load_failure(
     paths = [f.path for f in files]
     assert "test.yaml" in paths
     assert any(
-        "failed to load !include" in r.message.lower() and "missing.yaml" in r.message
+        "failed to load !include" in r.message and "missing.yaml" in r.message
         for r in caplog.records
     )
 
@@ -974,8 +974,8 @@ def test_force_load_skips_duplicate_include_file() -> None:
     # Same instance appears twice — second visit must hit the _seen guard.
     tree = {"a": stub, "b": [stub]}
 
-    with patch("esphome.yaml_util.IncludeFile", _StubInclude):
-        force_load_include_files(tree)
+    with patch("esphome.bundle.yaml_util.IncludeFile", _StubInclude):
+        _force_load_include_files(tree)
 
     assert stub.load_calls == 1
 
@@ -989,8 +989,8 @@ def test_force_load_handles_cyclic_containers() -> None:
     cyclic_list.append(cyclic_list)
 
     # Should return without recursing forever
-    force_load_include_files(cyclic_dict)
-    force_load_include_files(cyclic_list)
+    _force_load_include_files(cyclic_dict)
+    _force_load_include_files(cyclic_list)
 
 
 def test_discover_files_yaml_reload_failure(

tests/unit_tests/test_yaml_util.py

@@ -12,15 +12,11 @@ import esphome.config_validation as cv
 from esphome.core import DocumentLocation, DocumentRange, EsphomeError
 from esphome.util import OrderedDict
 from esphome.yaml_util import (
-    DiscoveredYamlFiles,
     ESPHomeDataBase,
     ESPLiteralValue,
-    discover_user_yaml_files,
-    force_load_include_files,
     format_path,
     make_data_base,
     make_literal,
-    track_yaml_loads,
 )
 
 
@@ -34,14 +30,6 @@ def clear_secrets_cache() -> None:
     yaml_util._SECRET_CACHE.clear()
 
 
-@pytest.fixture(autouse=True)
-def clear_core_frontmatter() -> None:
-    """Reset CORE.frontmatter between tests."""
-    core.CORE.frontmatter = {}
-    yield
-    core.CORE.frontmatter = {}
-
-
 def test_include_with_vars(fixture_path: Path) -> None:
     yaml_file = fixture_path / "yaml_util" / "includetest.yaml"
 
@@ -978,365 +966,3 @@ def test_make_literal_blocks_substitution() -> None:
     # undefined in the context.
     assert result == {"pin": "${PIN}"}
     assert isinstance(result, ESPLiteralValue)
-
-
-# ---------------------------------------------------------------------------
-# force_load_include_files / discover_user_yaml_files
-# ---------------------------------------------------------------------------
-
-
-class _StubInclude:
-    """Stand-in for `IncludeFile` that records how `load()` was called.
-
-    Patched in via `esphome.yaml_util.IncludeFile` so the recursion in
-    `force_load_include_files` treats instances as deferred includes without
-    needing an actual on-disk file.
-    """
-
-    def __init__(
-        self,
-        file: str = "stub.yaml",
-        parent_file: Path | None = None,
-        *,
-        unresolved: bool = False,
-        load_result: object = None,
-        raise_on_load: EsphomeError | None = None,
-    ) -> None:
-        self.file = Path(file)
-        self.parent_file = parent_file or Path("/tmp/parent.yaml")
-        self._unresolved = unresolved
-        self._load_result = load_result if load_result is not None else {}
-        self._raise = raise_on_load
-        self.load_calls = 0
-
-    def has_unresolved_expressions(self) -> bool:
-        return self._unresolved
-
-    def load(self) -> object:
-        self.load_calls += 1
-        if self._raise is not None:
-            raise self._raise
-        return self._load_result
-
-
-@pytest.fixture
-def patch_include_file():
-    """Replace `IncludeFile` with `_StubInclude` so isinstance checks in
-    `force_load_include_files` match the stubs constructed by tests."""
-    with patch("esphome.yaml_util.IncludeFile", _StubInclude):
-        yield
-
-
-def test_force_load_include_files_resolves_nested_includes(
-    patch_include_file: None,
-) -> None:
-    """A tree of dict/list/IncludeFile is walked and every IncludeFile is loaded."""
-    inner = _StubInclude("inner.yaml")
-    outer = _StubInclude("outer.yaml", load_result={"nested": inner})
-    force_load_include_files([{"a": outer}, "scalar"])
-    assert outer.load_calls == 1
-    assert inner.load_calls == 1
-
-
-def test_force_load_include_files_seen_guard_prevents_double_load(
-    patch_include_file: None,
-) -> None:
-    """The same IncludeFile referenced from two branches loads once."""
-    stub = _StubInclude("once.yaml")
-    force_load_include_files({"a": stub, "b": [stub]})
-    assert stub.load_calls == 1
-
-
-def test_force_load_include_files_handles_cyclic_containers() -> None:
-    """Cyclic dict/list references don't trigger infinite recursion."""
-    cyclic_dict: dict[str, object] = {}
-    cyclic_dict["self"] = cyclic_dict
-    cyclic_list: list[object] = []
-    cyclic_list.append(cyclic_list)
-    # Both calls must return without recursing forever.
-    force_load_include_files(cyclic_dict)
-    force_load_include_files(cyclic_list)
-
-
-@pytest.mark.parametrize(
-    ("warn_on_unresolved", "expect_level"),
-    [
-        pytest.param(True, "WARNING", id="default-warns"),
-        pytest.param(False, "DEBUG", id="opt-in-demotes"),
-    ],
-)
-def test_force_load_include_files_unresolved_log_level(
-    patch_include_file: None,
-    caplog: pytest.LogCaptureFixture,
-    warn_on_unresolved: bool,
-    expect_level: str,
-) -> None:
-    """Substitution-templated include paths skip the load and log at the
-    level chosen by `warn_on_unresolved`."""
-    stub = _StubInclude("${var}.yaml", unresolved=True)
-    with caplog.at_level("DEBUG", logger="esphome.yaml_util"):
-        force_load_include_files({"k": stub}, warn_on_unresolved=warn_on_unresolved)
-    assert stub.load_calls == 0
-    matching = [
-        r.levelname for r in caplog.records if "Cannot resolve !include" in r.message
-    ]
-    assert matching == [expect_level]
-
-
-def test_force_load_include_files_warns_on_load_failure(
-    patch_include_file: None,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """An `EsphomeError` raised by `load()` is caught and logged, not propagated."""
-    stub = _StubInclude("missing.yaml", raise_on_load=EsphomeError("boom"))
-    with caplog.at_level("WARNING", logger="esphome.yaml_util"):
-        force_load_include_files({"k": stub})
-    assert any(
-        "Failed to load !include" in r.message and "missing.yaml" in r.message
-        for r in caplog.records
-    )
-
-
-def test_discovered_yaml_files_holds_files_and_secrets() -> None:
-    """`DiscoveredYamlFiles` is a small data carrier; both fields are mandatory."""
-    files = [Path("/tmp/a.yaml")]
-    secrets = {Path("/tmp/a.yaml")}
-    discovered = DiscoveredYamlFiles(files, secrets)
-    assert discovered.files is files
-    assert discovered.secrets is secrets
-
-
-def _write(tmp_path: Path, name: str, content: str) -> Path:
-    """Write `content` to `tmp_path/name`, creating parent dirs as needed."""
-    path = tmp_path / name
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content)
-    return path
-
-
-def _write_entry_including(tmp_path: Path, included_name: str) -> Path:
-    """Write a minimal entry yaml that `!include`s `included_name`."""
-    return _write(
-        tmp_path,
-        "entry.yaml",
-        f"esphome:\n  name: test\nwifi: !include {included_name}\n",
-    )
-
-
-def test_discover_user_yaml_files_captures_includes(tmp_path: Path) -> None:
-    """A `!include` in the entry yaml is force-loaded so the listener fires."""
-    _write(tmp_path, "wifi.yaml", "ssid: my_ssid\npassword: my_pw\n")
-    discovered = discover_user_yaml_files(_write_entry_including(tmp_path, "wifi.yaml"))
-    names = {p.name for p in discovered.files}
-    assert names == {"entry.yaml", "wifi.yaml"}
-    assert discovered.secrets == set()
-
-
-@pytest.mark.parametrize(
-    "secret_name",
-    [
-        pytest.param("secrets.yaml", id="yaml"),
-        pytest.param("secrets.yml", id="yml"),
-    ],
-)
-def test_discover_user_yaml_files_flags_secrets_filename(
-    tmp_path: Path, secret_name: str
-) -> None:
-    """Both `secrets.yaml` and `secrets.yml` get flagged in `.secrets`."""
-    _write(tmp_path, secret_name, "key: value\n")
-    discovered = discover_user_yaml_files(_write_entry_including(tmp_path, secret_name))
-    assert (tmp_path / secret_name).resolve() in discovered.secrets
-
-
-def test_discover_user_yaml_files_flags_secrets_symlink(tmp_path: Path) -> None:
-    """`secrets.yaml` symlinked to a non-secrets-named target is still flagged
-    because the un-resolved basename is what gets recorded."""
-    target = _write(tmp_path, "real_creds.yaml", "key: value\n")
-    (tmp_path / "secrets.yaml").symlink_to(target)
-    discovered = discover_user_yaml_files(
-        _write_entry_including(tmp_path, "secrets.yaml")
-    )
-    # The recorded "secret path" is the resolved target — even though its
-    # basename is `real_creds.yaml`, it's still in `.secrets`.
-    assert target.resolve() in discovered.secrets
-
-
-def test_discover_user_yaml_files_swallows_parse_errors(tmp_path: Path) -> None:
-    """A YAML parse failure returns whatever was tracked so far without raising."""
-    entry = _write(tmp_path, "entry.yaml", "esphome: [unterminated\n")
-    discovered = discover_user_yaml_files(entry)
-    assert isinstance(discovered, DiscoveredYamlFiles)
-
-
-def test_discover_user_yaml_files_deduplicates(tmp_path: Path) -> None:
-    """The same file referenced twice appears once in `.files`."""
-    _write(tmp_path, "wifi.yaml", "ssid: a\n")
-    entry = _write(
-        tmp_path,
-        "entry.yaml",
-        "esphome:\n  name: test\nwifi: !include wifi.yaml\nfoo: !include wifi.yaml\n",
-    )
-    discovered = discover_user_yaml_files(entry)
-    wifi_resolved = (tmp_path / "wifi.yaml").resolve()
-    assert discovered.files.count(wifi_resolved) == 1
-
-
-def test_track_yaml_loads_records_resolved_paths(tmp_path: Path) -> None:
-    """`track_yaml_loads` is the building block — sanity-check it resolves
-    symlinks so callers can dedupe by identity."""
-    target = _write(tmp_path, "actual.yaml", "esphome:\n  name: t\n")
-    link = tmp_path / "alias.yaml"
-    link.symlink_to(target)
-    with track_yaml_loads() as loaded:
-        yaml_util.load_yaml(link)
-    assert target.resolve() in loaded
-
-
-# ---------------------------------------------------------------------------
-# YAML frontmatter
-# ---------------------------------------------------------------------------
-
-
-def test_frontmatter_parsed_and_stored_on_core(tmp_path: Path) -> None:
-    """A leading `---`-separated YAML document is stored as frontmatter and
-    stripped from the returned config."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text(
-        "author: Jesse\nlabels: [office, climate]\n---\nesphome:\n  name: my_node\n"
-    )
-
-    config = yaml_util.load_yaml(yaml_file)
-
-    # Config does not contain frontmatter keys
-    assert "author" not in config
-    assert "labels" not in config
-    assert config["esphome"]["name"] == "my_node"
-
-    # Frontmatter is stored on CORE keyed by resolved path
-    frontmatter = core.CORE.frontmatter[yaml_file.resolve()]
-    assert frontmatter["author"] == "Jesse"
-    assert frontmatter["labels"] == ["office", "climate"]
-
-
-def test_frontmatter_absent_when_single_document(tmp_path: Path) -> None:
-    """A YAML file with a single document does not populate CORE.frontmatter."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text("esphome:\n  name: my_node\n")
-
-    yaml_util.load_yaml(yaml_file)
-    assert yaml_file.resolve() not in core.CORE.frontmatter
-
-
-def test_frontmatter_absent_when_leading_doc_separator(tmp_path: Path) -> None:
-    """A leading `---` with no content above it is just a document start marker,
-    not frontmatter, and must not populate CORE.frontmatter."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text("---\nesphome:\n  name: my_node\n")
-
-    config = yaml_util.load_yaml(yaml_file)
-    assert config["esphome"]["name"] == "my_node"
-    assert yaml_file.resolve() not in core.CORE.frontmatter
-
-
-def test_frontmatter_supports_arbitrary_keys(tmp_path: Path) -> None:
-    """Frontmatter keys are not validated — any structure is accepted."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text(
-        "any_key: any_value\n"
-        "nested:\n"
-        "  count: 42\n"
-        "  items:\n"
-        "    - a\n"
-        "    - b\n"
-        "---\n"
-        "esphome:\n"
-        "  name: t\n"
-    )
-
-    yaml_util.load_yaml(yaml_file)
-    frontmatter = core.CORE.frontmatter[yaml_file.resolve()]
-    assert frontmatter["any_key"] == "any_value"
-    assert frontmatter["nested"]["count"] == 42
-    assert frontmatter["nested"]["items"] == ["a", "b"]
-
-
-def test_frontmatter_supports_deeply_nested_paths(tmp_path: Path) -> None:
-    """Frontmatter preserves deeply nested dict/list structures intact."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text(
-        "device:\n"
-        "  metadata:\n"
-        "    location:\n"
-        "      building: HQ\n"
-        "      floor: 3\n"
-        "      room:\n"
-        "        number: 302\n"
-        "        occupants:\n"
-        "          - name: Jesse\n"
-        "            role:\n"
-        "              title: maintainer\n"
-        "              since: 2021\n"
-        "          - name: Alice\n"
-        "            role:\n"
-        "              title: contributor\n"
-        "              since: 2024\n"
-        "---\n"
-        "esphome:\n"
-        "  name: t\n"
-    )
-
-    yaml_util.load_yaml(yaml_file)
-    fm = core.CORE.frontmatter[yaml_file.resolve()]
-    room = fm["device"]["metadata"]["location"]["room"]
-    assert room["number"] == 302
-    assert room["occupants"][0]["name"] == "Jesse"
-    assert room["occupants"][0]["role"]["title"] == "maintainer"
-    assert room["occupants"][0]["role"]["since"] == 2021
-    assert room["occupants"][1]["role"]["title"] == "contributor"
-
-
-def test_frontmatter_more_than_two_documents_raises(tmp_path: Path) -> None:
-    """Three or more YAML documents is unsupported and must raise."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text("a: 1\n---\nb: 2\n---\nc: 3\n")
-
-    with pytest.raises(EsphomeError, match="at most two are supported"):
-        yaml_util.load_yaml(yaml_file)
-
-
-def test_frontmatter_empty_frontmatter_doc_not_stored(tmp_path: Path) -> None:
-    """An empty (null) frontmatter document is treated as no frontmatter."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text("---\n---\nesphome:\n  name: t\n")
-
-    config = yaml_util.load_yaml(yaml_file)
-    assert config["esphome"]["name"] == "t"
-    assert yaml_file.resolve() not in core.CORE.frontmatter
-
-
-def test_frontmatter_empty_config_doc(tmp_path: Path) -> None:
-    """An empty config document after a frontmatter document yields an empty config."""
-    yaml_file = tmp_path / "main.yaml"
-    yaml_file.write_text("only: frontmatter\n---\n")
-
-    config = yaml_util.load_yaml(yaml_file)
-    assert config == {}
-    assert core.CORE.frontmatter[yaml_file.resolve()]["only"] == "frontmatter"
-
-
-def test_frontmatter_included_file_stored(tmp_path: Path) -> None:
-    """Frontmatter on an !include'd file is also captured on CORE, keyed by
-    that file's resolved path."""
-    inc = tmp_path / "child.yaml"
-    inc.write_text("child_meta: hello\n---\nchild_key: value\n")
-    main = tmp_path / "main.yaml"
-    main.write_text("esphome:\n  name: t\nchild: !include child.yaml\n")
-
-    config = yaml_util.load_yaml(main)
-    # !include is deferred; force resolution so the child file actually loads
-    force_load_include_files(config)
-    assert config["child"].load()["child_key"] == "value"
-    # Main file has no frontmatter
-    assert main.resolve() not in core.CORE.frontmatter
-    # Included file's frontmatter is captured
-    assert core.CORE.frontmatter[inc.resolve()]["child_meta"] == "hello"