[test] Trigger device-builder downstream CI

DO NOT MERGE -- chained test PR to verify the new device-builder CI job from #16214 actually runs and exercises esphome/device-builder against the PR's Python code. Touches a Python file under esphome/ to trip the should_run_device_builder gate in determine-jobs.py.
[ci] Address Copilot review on device-builder gate
2026-07-09 16:35:35 +00:00 · 2026-05-03 09:12:10 -05:00 · 2026-05-03 09:12:04 -05:00 · 2026-05-03 09:08:54 -05:00 · 2026-05-03 08:49:59 -05:00 · 2026-05-03 03:40:09 -05:00
439 changed files with 15962 additions and 3202 deletions
@@ -5,24 +5,30 @@ Checks: >-
  -altera-*,
  -android-*,
  -boost-*,
+  -bugprone-derived-method-shadowing-base-method,
  -bugprone-easily-swappable-parameters,
  -bugprone-implicit-widening-of-multiplication-result,
+  -bugprone-invalid-enum-default-initialization,
  -bugprone-multi-level-implicit-pointer-conversion,
  -bugprone-narrowing-conversions,
+  -bugprone-tagged-union-member-count,
  -bugprone-signed-char-misuse,
  -bugprone-switch-missing-default-case,
  -cert-dcl50-cpp,
  -cert-err33-c,
  -cert-err58-cpp,
+  -cert-int09-c,
  -cert-oop57-cpp,
  -cert-str34-c,
  -clang-analyzer-optin.core.EnumCastOutOfRange,
  -clang-analyzer-optin.cplusplus.UninitializedObject,
  -clang-analyzer-osx.*,
+  -clang-analyzer-security.ArrayBound,
  -clang-diagnostic-delete-abstract-non-virtual-dtor,
  -clang-diagnostic-delete-non-abstract-non-virtual-dtor,
  -clang-diagnostic-deprecated-declarations,
  -clang-diagnostic-ignored-optimization-argument,
+  -clang-diagnostic-missing-designated-field-initializers,
  -clang-diagnostic-missing-field-initializers,
  -clang-diagnostic-shadow-field,
  -clang-diagnostic-unused-const-variable,
@@ -42,6 +48,7 @@ Checks: >-
  -cppcoreguidelines-owning-memory,
  -cppcoreguidelines-prefer-member-initializer,
  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
  -cppcoreguidelines-pro-bounds-constant-array-index,
  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
  -cppcoreguidelines-pro-type-const-cast,
@@ -54,12 +61,13 @@ Checks: >-
  -cppcoreguidelines-rvalue-reference-param-not-moved,
  -cppcoreguidelines-special-member-functions,
  -cppcoreguidelines-use-default-member-init,
+  -cppcoreguidelines-use-enum-class,
  -cppcoreguidelines-virtual-class-destructor,
+  -fuchsia-default-arguments-calls,
+  -fuchsia-default-arguments-declarations,
  -fuchsia-multiple-inheritance,
  -fuchsia-overloaded-operator,
  -fuchsia-statically-constructed-objects,
-  -fuchsia-default-arguments-declarations,
-  -fuchsia-default-arguments-calls,
  -google-build-using-namespace,
  -google-explicit-constructor,
  -google-readability-braces-around-statements,
@@ -71,16 +79,23 @@ Checks: >-
  -llvm-else-after-return,
  -llvm-header-guard,
  -llvm-include-order,
+  -llvm-prefer-static-over-anonymous-namespace,
  -llvm-qualified-auto,
+  -llvm-use-ranges,
  -llvmlibc-*,
  -misc-const-correctness,
  -misc-include-cleaner,
+  -misc-multiple-inheritance,
  -misc-no-recursion,
  -misc-non-private-member-variables-in-classes,
+  -misc-override-with-different-visibility,
  -misc-unused-parameters,
  -misc-use-anonymous-namespace,
+  -misc-use-internal-linkage,
  -modernize-avoid-bind,
+  -modernize-avoid-variadic-functions,
  -modernize-avoid-c-arrays,
+  -modernize-avoid-c-style-cast,
  -modernize-concat-nested-namespaces,
  -modernize-macro-to-enum,
  -modernize-return-braced-init-list,
@@ -88,32 +103,42 @@ Checks: >-
  -modernize-use-auto,
  -modernize-use-constraints,
  -modernize-use-default-member-init,
+  -modernize-use-designated-initializers,
  -modernize-use-equals-default,
+  -modernize-use-integer-sign-comparison,
  -modernize-use-nodiscard,
  -modernize-use-nullptr,
-  -modernize-use-nodiscard,
-  -modernize-use-nullptr,
+  -modernize-use-ranges,
  -modernize-use-trailing-return-type,
  -mpi-*,
  -objc-*,
  -performance-enum-size,
+  -portability-avoid-pragma-once,
+  -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,
+  -readability-enum-initial-value,
  -readability-function-cognitive-complexity,
  -readability-implicit-bool-conversion,
  -readability-isolate-declaration,
  -readability-magic-numbers,
  -readability-make-member-function-const,
+  -readability-math-missing-parentheses,
  -readability-named-parameter,
  -readability-redundant-casting,
  -readability-redundant-inline-specifier,
  -readability-redundant-member-init,
+  -readability-redundant-parentheses,
  -readability-redundant-string-init,
+  -readability-redundant-typename,
  -readability-uppercase-literal-suffix,
  -readability-use-anyofallof,
+  -readability-use-std-min-max,
+  -readability-use-concise-preprocessor-directives,
 WarningsAsErrors: '*'
 FormatStyle:     google
 CheckOptions:
@@ -1 +1 @@
-256216e144a626c8c9d1a458920a9db3de7dfc8c6a1b44b87946b9752e81026c
+0c7f309d70eca8e3efd510092ddb23c530f3934c49371717efa124b788d761f8
@@ -41,16 +41,36 @@ function generateReviewMessages(finalLabels, originalLabelCount, deprecatedInfo,

    let message = `${TOO_BIG_MARKER}\n### 📦 Pull Request Size\n\n`;

+    message +=
+      `Hey @${prAuthor}, thanks for the contribution! Just a heads up, ` +
+      `this PR is on the large side `;
+
    if (tooManyLabels && tooManyChanges) {
-      message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${originalLabelCount} different components/areas.`;
+      message +=
+        `(${nonTestChanges} line changes excluding tests, across ` +
+        `${originalLabelCount} different components/areas)`;
    } else if (tooManyLabels) {
-      message += `This PR affects ${originalLabelCount} different components/areas.`;
+      message +=
+        `(it touches ${originalLabelCount} different components/areas)`;
    } else {
-      message += `This PR is too large with ${nonTestChanges} line changes (excluding tests).`;
+      message += `(${nonTestChanges} line changes excluding tests)`;
    }

-    message += ` Please consider breaking it down into smaller, focused PRs to make review easier and reduce the risk of conflicts.\n\n`;
-    message += `For guidance on breaking down large PRs, see: https://developers.esphome.io/contributing/submitting-your-work/#how-to-approach-large-submissions`;
+    message += `, which makes it harder for maintainers to review.\n\n`;
+    message +=
+      `Smaller, focused PRs tend to be reviewed much faster since they ` +
+      `fit into the short gaps between other maintainer work; large ones ` +
+      `often have to wait for a rare long uninterrupted block of time. ` +
+      `If you can break this up into smaller pieces that can be reviewed ` +
+      `independently, it will almost certainly land faster overall.\n\n`;
+    message +=
+      `Before putting more time in, it's also worth popping into ` +
+      `\`#devs\` on [Discord](https://esphome.io/chat) so we can help ` +
+      `you scope things and flag anything already in flight.\n\n`;
+    message +=
+      `For more details (including how to split the work up), see: ` +
+      `https://developers.esphome.io/contributing/submitting-your-work/` +
+      `#how-to-approach-large-submissions`;

    messages.push(message);
  }
@@ -27,9 +27,9 @@ jobs:

      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v2
+        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
-          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
+          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}

      - name: Auto Label PR
@@ -39,7 +39,7 @@ jobs:
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Generate cache-key
        id: cache-key
-        run: echo key="${{ hashFiles('requirements.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
+        run: echo key="${{ hashFiles('requirements.txt', 'requirements_dev.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -58,7 +58,7 @@ jobs:
          python -m venv venv
          . venv/bin/activate
          python --version
-          pip install -r requirements.txt -r requirements_test.txt pre-commit
+          pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt pre-commit
          pip install -e .

  pylint:
@@ -108,6 +108,81 @@ jobs:
          script/generate-esp32-boards.py --check
          script/generate-rp2040-boards.py --check

+  import-time:
+    name: Check import esphome.__main__ time
+    runs-on: ubuntu-24.04
+    needs:
+      - common
+      - determine-jobs
+    if: needs.determine-jobs.outputs.import-time == 'true'
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Restore Python
+        uses: ./.github/actions/restore-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          cache-key: ${{ needs.common.outputs.cache-key }}
+      - name: Check import time against budget and write waterfall HAR
+        run: |
+          . venv/bin/activate
+          script/check_import_time.py --check --har importtime.har
+      - name: Upload waterfall HAR
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: import-time-waterfall
+          path: importtime.har
+          if-no-files-found: ignore
+          retention-days: 14
+
+  device-builder:
+    name: Test downstream esphome/device-builder
+    runs-on: ubuntu-24.04
+    needs:
+      - common
+      - determine-jobs
+    if: needs.determine-jobs.outputs.device-builder == 'true'
+    steps:
+      - name: Check out esphome (this PR)
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          path: esphome
+      - name: Check out esphome/device-builder
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          repository: esphome/device-builder
+          ref: main
+          path: device-builder
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.13"
+      - name: Set up uv
+        # Mirrors the install shape device-builder's own CI uses
+        # (esphome/device-builder#192): uv replaces pip for the
+        # install step (order-of-magnitude faster on cold boots,
+        # with its own wheel cache). actions/setup-python still
+        # provides the interpreter.
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          enable-cache: true
+      - 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
+        # overlay the PR's esphome so the downstream tests run
+        # against this PR's Python code. ``--system`` installs into
+        # the runner's Python instead of a venv.
+        run: |
+          uv pip install --system -e './device-builder[esphome,test]'
+          uv pip install --system -e ./esphome
+      - name: Run device-builder pytest
+        # ``-n auto`` runs under pytest-xdist (matches device-builder's
+        # 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=10 --no-cov --ignore=tests/benchmarks
+
  pytest:
    name: Run pytest
    strategy:
@@ -171,11 +246,12 @@ jobs:
      - common
    outputs:
      integration-tests: ${{ steps.determine.outputs.integration-tests }}
-      integration-tests-run-all: ${{ steps.determine.outputs.integration-tests-run-all }}
-      integration-test-files: ${{ steps.determine.outputs.integration-test-files }}
+      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 }}
      python-linters: ${{ steps.determine.outputs.python-linters }}
+      import-time: ${{ steps.determine.outputs.import-time }}
+      device-builder: ${{ steps.determine.outputs.device-builder }}
      changed-components: ${{ steps.determine.outputs.changed-components }}
      changed-components-with-tests: ${{ steps.determine.outputs.changed-components-with-tests }}
      directly-changed-components-with-tests: ${{ steps.determine.outputs.directly-changed-components-with-tests }}
@@ -214,11 +290,12 @@ jobs:

          # Extract individual fields
          echo "integration-tests=$(echo "$output" | jq -r '.integration_tests')" >> $GITHUB_OUTPUT
-          echo "integration-tests-run-all=$(echo "$output" | jq -r '.integration_tests_run_all')" >> $GITHUB_OUTPUT
-          echo "integration-test-files=$(echo "$output" | jq -c '.integration_test_files')" >> $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 "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
          echo "changed-components=$(echo "$output" | jq -c '.changed_components')" >> $GITHUB_OUTPUT
          echo "changed-components-with-tests=$(echo "$output" | jq -c '.changed_components_with_tests')" >> $GITHUB_OUTPUT
          echo "directly-changed-components-with-tests=$(echo "$output" | jq -c '.directly_changed_components_with_tests')" >> $GITHUB_OUTPUT
@@ -237,12 +314,16 @@ jobs:
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}

  integration-tests:
-    name: Run integration tests
+    name: Run integration tests (${{ matrix.bucket.name }})
    runs-on: ubuntu-latest
    needs:
      - common
      - determine-jobs
    if: needs.determine-jobs.outputs.integration-tests == 'true'
+    strategy:
+      fail-fast: false
+      matrix:
+        bucket: ${{ fromJson(needs.determine-jobs.outputs.integration-test-buckets) }}
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -269,19 +350,14 @@ jobs:
        run: echo "::add-matcher::.github/workflows/matchers/pytest.json"
      - name: Run integration tests
        env:
-          INTEGRATION_TEST_FILES: ${{ needs.determine-jobs.outputs.integration-test-files }}
-          INTEGRATION_TESTS_RUN_ALL: ${{ needs.determine-jobs.outputs.integration-tests-run-all }}
+          # JSON array of test paths; parsed into a bash array below to avoid
+          # shell word-splitting / glob hazards.
+          BUCKET_TESTS: ${{ toJson(matrix.bucket.tests) }}
        run: |
          . venv/bin/activate
-          if [[ "$INTEGRATION_TESTS_RUN_ALL" == "true" ]]; then
-            echo "Running all integration tests"
-            pytest -vv --no-cov --tb=native -n auto tests/integration/
-          else
-            # Parse JSON array into bash array to avoid shell expansion issues
-            mapfile -t test_files < <(echo "$INTEGRATION_TEST_FILES" | jq -r '.[]')
-            echo "Running ${#test_files[@]} specific integration tests"
-            pytest -vv --no-cov --tb=native -n auto "${test_files[@]}"
-          fi
+          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 -n auto "${test_files[@]}"

  cpp-unit-tests:
    name: Run C++ unit tests
@@ -339,7 +415,7 @@ jobs:
          echo "binary=$BINARY" >> $GITHUB_OUTPUT

      - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@658a901452bb54c799643e060733b7afe9121b8d # v4.14.0
+        uses: CodSpeedHQ/action@c381be0bfd20e844fb45594f6aa182ffcd94545c # v4.15.0
        with:
          run: ${{ steps.build.outputs.binary }}
          mode: simulation
@@ -1036,6 +1112,7 @@ jobs:
      - clang-tidy-nosplit
      - clang-tidy-split
      - determine-jobs
+      - device-builder
      - test-build-components-split
      - pre-commit-ci-lite
      - memory-impact-target-branch
@@ -0,0 +1,72 @@
+name: Close PR From Fork Default Branch
+
+on:
+  # pull_request_target is required so we have permission to comment and close PRs from forks.
+  pull_request_target:
+    types: [opened, reopened]
+
+permissions:
+  pull-requests: write
+  issues: write
+
+jobs:
+  close:
+    name: Close PR opened from fork's default branch
+    runs-on: ubuntu-latest
+    if: >-
+      github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+      && github.event.pull_request.head.ref == github.event.repository.default_branch
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const prNumber = context.payload.pull_request.number;
+            const author = context.payload.pull_request.user.login;
+            const defaultBranch = context.payload.repository.default_branch;
+            const headRepo = context.payload.pull_request.head.repo.full_name;
+
+            const body = [
+              `Hi @${author}, thanks for opening a pull request! :tada:`,
+              ``,
+              `It looks like this PR was opened from the \`${defaultBranch}\` branch of your fork (\`${headRepo}\`), which is the same name as this repository's default branch. Working directly on \`${defaultBranch}\` in your fork causes a few problems:`,
+              ``,
+              `- Your fork's \`${defaultBranch}\` branch will permanently diverge from \`esphome/esphome:${defaultBranch}\`, making it hard to keep your fork up to date.`,
+              `- Any additional commits you push to \`${defaultBranch}\` will be added to this PR, so you can't easily work on multiple changes at once.`,
+              `- Pushing maintainer fixes to your branch is awkward, since it means committing directly to your fork's default branch.`,
+              `- It makes local collaboration painful — \`${defaultBranch}\` in a checkout becomes ambiguous between upstream and your fork, and maintainers end up with naming collisions when fetching your branch.`,
+              ``,
+              `Please re-open this as a new PR from a dedicated feature branch. The usual flow looks like:`,
+              ``,
+              `\`\`\`bash`,
+              `# Make sure your fork's ${defaultBranch} is up to date with upstream`,
+              `git remote add upstream https://github.com/${owner}/${repo}.git  # if you haven't already`,
+              `git fetch upstream`,
+              `git checkout ${defaultBranch}`,
+              `git reset --hard upstream/${defaultBranch}`,
+              `git push --force-with-lease origin ${defaultBranch}`,
+              ``,
+              `# Create a new branch for your change and cherry-pick / re-apply your commits there`,
+              `git checkout -b my-feature-branch upstream/${defaultBranch}`,
+              `# ...re-apply your changes, then:`,
+              `git push origin my-feature-branch`,
+              `\`\`\``,
+              ``,
+              `Then open a new pull request from \`my-feature-branch\` into \`${owner}/${repo}:${defaultBranch}\`.`,
+              ``,
+              `Closing this PR for now — sorry for the friction, and thanks again for contributing! :heart:`,
+            ].join('\n');
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number: prNumber,
+              body,
+            });
+
+            await github.rest.pulls.update({
+              owner,
+              repo,
+              pull_number: prNumber,
+              state: 'closed',
+            });
@@ -58,7 +58,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
+        uses: github/codeql-action/init@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
+        uses: github/codeql-action/analyze@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3
        with:
          category: "/language:${{matrix.language}}"
@@ -8,4 +8,4 @@ on:

 jobs:
  lock:
-    uses: esphome/workflows/.github/workflows/lock.yml@3c4e8446aa1029f1c346a482034b3ee1489077ca  # 2026.4.0
+    uses: esphome/workflows/.github/workflows/lock.yml@025a1e6255610c498ed590403b7e510b69e474df  # 2026.4.1
@@ -223,7 +223,7 @@ jobs:
        id: generate-token
        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
-          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
+          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
          owner: esphome
          repositories: home-assistant-addon
@@ -258,7 +258,7 @@ jobs:
        id: generate-token
        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
-          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
+          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
          owner: esphome
          repositories: esphome-schema
@@ -289,7 +289,7 @@ jobs:
        id: generate-token
        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
-          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
+          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
          owner: esphome
          repositories: version-notifier
@@ -146,5 +146,6 @@ sdkconfig.*

 /components
 /managed_components
+/dependencies.lock

 api-docs/
@@ -11,7 +11,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.15.11
+    rev: v0.15.12
    hooks:
      # Run the linter.
      - id: ruff
@@ -56,6 +56,7 @@ esphome/components/audio_adc/* @kbx81
 esphome/components/audio_dac/* @kbx81
 esphome/components/audio_file/* @kahrendt
 esphome/components/audio_file/media_source/* @kahrendt
+esphome/components/audio_http/* @kahrendt
 esphome/components/axs15231/* @clydebarrow
 esphome/components/b_parasite/* @rbaron
 esphome/components/ballu/* @bazuchan
@@ -346,6 +347,7 @@ esphome/components/modbus_controller/select/* @martgras @stegm
 esphome/components/modbus_controller/sensor/* @martgras
 esphome/components/modbus_controller/switch/* @martgras
 esphome/components/modbus_controller/text_sensor/* @martgras
+esphome/components/modbus_server/* @exciton
 esphome/components/mopeka_ble/* @Fabian-Schmidt @spbrogan
 esphome/components/mopeka_pro_check/* @spbrogan
 esphome/components/mopeka_std_check/* @Fabian-Schmidt
@@ -439,6 +441,11 @@ esphome/components/sen0321/* @notjj
 esphome/components/sen21231/* @shreyaskarnik
 esphome/components/sen5x/* @martgras
 esphome/components/sen6x/* @martgras @mebner86 @mikelawrence @tuct
+esphome/components/sendspin/* @kahrendt
+esphome/components/sendspin/media_player/* @kahrendt
+esphome/components/sendspin/media_source/* @kahrendt
+esphome/components/sendspin/sensor/* @kahrendt
+esphome/components/sendspin/text_sensor/* @kahrendt
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
 esphome/components/serial_proxy/* @kbx81
@@ -600,6 +607,6 @@ esphome/components/xxtea/* @clydebarrow
 esphome/components/zephyr/* @tomaszduda23
 esphome/components/zephyr_mcumgr/ota/* @tomaszduda23
 esphome/components/zhlt01/* @cfeenstra1024
-esphome/components/zigbee/* @tomaszduda23
+esphome/components/zigbee/* @luar123 @tomaszduda23
 esphome/components/zio_ultrasonic/* @kahrendt
 esphome/components/zwave_proxy/* @kbx81
@@ -21,7 +21,7 @@ import argcomplete
 # Note: Do not import modules from esphome.components here, as this would
 # cause them to be loaded before external components are processed, resulting
 # in the built-in version being used instead of the external component one.
-from esphome import const, writer, yaml_util
+from esphome import const
 import esphome.codegen as cg
 from esphome.config import iter_component_configs, read_config, strip_default_ids
 from esphome.const import (
@@ -39,6 +39,7 @@ from esphome.const import (
    CONF_MDNS,
    CONF_MQTT,
    CONF_NAME,
+    CONF_NAME_ADD_MAC_SUFFIX,
    CONF_OTA,
    CONF_PASSWORD,
    CONF_PLATFORM,
@@ -72,6 +73,12 @@ from esphome.util import (
    safe_print,
 )

+# Keep expensive imports (zeroconf, writer, yaml_util, etc.) out of this
+# module's top level. Every `esphome` invocation — including fast paths
+# like `esphome version` — pays the cost of what's imported here before
+# any command runs. Import inside the function that needs it instead.
+# `script/check_import_time.py` enforces a budget in CI.
+
 _LOGGER = logging.getLogger(__name__)

 ESPHOME_COMMAND = [sys.executable, "-m", "esphome"]
@@ -204,6 +211,66 @@ def _resolve_with_cache(address: str, purpose: Purpose) -> list[str]:
    return [address]


+def _populate_mdns_cache(hosts_to_addresses: dict[str, list[str]]) -> None:
+    """Store discovered ``host -> [ips]`` entries in ``CORE.address_cache``.
+
+    Ensures ``CORE.address_cache`` exists, then records each mDNS hostname so
+    the downstream resolution path (``resolve_ip_address``) can skip opening a
+    second Zeroconf client.
+    """
+    from esphome.address_cache import AddressCache
+
+    if CORE.address_cache is None:
+        CORE.address_cache = AddressCache()
+    for host, addresses in hosts_to_addresses.items():
+        if addresses:
+            _LOGGER.debug("Caching mDNS result %s -> %s", host, addresses)
+        CORE.address_cache.add_mdns_addresses(host, addresses)
+
+
+def _discover_mac_suffix_devices() -> list[str] | None:
+    """Discover ``<name>-<mac>.local`` devices and cache their IPs.
+
+    Returns:
+        - ``None`` when discovery isn't applicable (``name_add_mac_suffix`` off,
+          mDNS disabled, or ``CORE.address`` is already an IP). Callers should
+          then fall back to whatever default OTA address they normally use.
+        - ``[]`` when discovery ran but found nothing. Callers should NOT fall
+          back to the base name: with ``name_add_mac_suffix`` enabled, the base
+          name by definition doesn't exist on the network.
+        - A non-empty sorted list of ``.local`` hostnames on success.
+
+    Populates ``CORE.address_cache`` so downstream resolution (``espota2`` or
+    ``aioesphomeapi`` via :func:`_resolve_network_devices`) reuses the IPs we
+    already have without opening a second Zeroconf client.
+    """
+    if not (has_name_add_mac_suffix() and has_mdns() and has_non_ip_address()):
+        return None
+    from esphome.zeroconf import discover_mdns_devices
+
+    _LOGGER.info("Discovering devices...")
+    if not (discovered := discover_mdns_devices(CORE.name)):
+        _LOGGER.warning(
+            "No devices matching '%s-<mac>.local' were discovered.", CORE.name
+        )
+        return []
+    _populate_mdns_cache(discovered)
+    return list(discovered)
+
+
+def _ota_hostnames_for_default(purpose: Purpose) -> list[str]:
+    """Return OTA hostname(s) for the ``--device OTA`` / default-resolve path.
+
+    When ``name_add_mac_suffix`` is enabled, returns discovered
+    ``<name>-<mac>.local`` hostnames (possibly empty — in which case the
+    caller should not fall back to the base name). Otherwise falls back to
+    the cache-resolved ``CORE.address``.
+    """
+    if (discovered := _discover_mac_suffix_devices()) is not None:
+        return discovered
+    return _resolve_with_cache(CORE.address, purpose)
+
+
 def choose_upload_log_host(
    default: list[str] | str | None,
    check_default: str | None,
@@ -242,14 +309,14 @@ def choose_upload_log_host(
                        resolved.append("MQTT")

                    if has_api() and has_non_ip_address() and has_resolvable_address():
-                        resolved.extend(_resolve_with_cache(CORE.address, purpose))
+                        resolved.extend(_ota_hostnames_for_default(purpose))

                elif purpose == Purpose.UPLOADING:
                    if has_ota() and has_mqtt_ip_lookup():
                        resolved.append("MQTTIP")

                    if has_ota() and has_non_ip_address() and has_resolvable_address():
-                        resolved.extend(_resolve_with_cache(CORE.address, purpose))
+                        resolved.extend(_ota_hostnames_for_default(purpose))
            else:
                resolved.append(device)
        if not resolved:
@@ -281,22 +348,29 @@ def choose_upload_log_host(
        elif bootsel.permission_error:
            bootsel_permission_error = True

+    def add_ota_options() -> None:
+        """Add OTA options, using mDNS discovery if name_add_mac_suffix is enabled."""
+        if (discovered := _discover_mac_suffix_devices()) is not None:
+            # Discovery was applicable. Use whatever we found — on empty,
+            # intentionally skip the base-name fallback since with
+            # name_add_mac_suffix on, the base name doesn't exist on the net.
+            for host in discovered:
+                options.append((f"Over The Air ({host})", host))
+        elif has_resolvable_address():
+            options.append((f"Over The Air ({CORE.address})", CORE.address))
+        if has_mqtt_ip_lookup():
+            options.append(("Over The Air (MQTT IP lookup)", "MQTTIP"))
+
    if purpose == Purpose.LOGGING:
        if has_mqtt_logging():
            mqtt_config = CORE.config[CONF_MQTT]
            options.append((f"MQTT ({mqtt_config[CONF_BROKER]})", "MQTT"))

        if has_api():
-            if has_resolvable_address():
-                options.append((f"Over The Air ({CORE.address})", CORE.address))
-            if has_mqtt_ip_lookup():
-                options.append(("Over The Air (MQTT IP lookup)", "MQTTIP"))
+            add_ota_options()

    elif purpose == Purpose.UPLOADING and has_ota():
-        if has_resolvable_address():
-            options.append((f"Over The Air ({CORE.address})", CORE.address))
-        if has_mqtt_ip_lookup():
-            options.append(("Over The Air (MQTT IP lookup)", "MQTTIP"))
+        add_ota_options()

    # Show helpful BOOTSEL instructions for RP2040 when no BOOTSEL device is found
    if (
@@ -407,7 +481,17 @@ def has_resolvable_address() -> bool:
    return not CORE.address.endswith(".local")


-def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str):
+def has_name_add_mac_suffix() -> bool:
+    """Check if name_add_mac_suffix is enabled in the config."""
+    if CORE.config is None:
+        return False
+    esphome_config = CORE.config.get(CONF_ESPHOME, {})
+    return esphome_config.get(CONF_NAME_ADD_MAC_SUFFIX, False)
+
+
+def mqtt_get_ip(
+    config: ConfigType, username: str, password: str, client_id: str
+) -> list[str]:
    from esphome import mqtt

    return mqtt.get_esphome_device_ip(config, username, password, client_id)
@@ -420,6 +504,9 @@ def _resolve_network_devices(

    This function filters the devices list to:
    - Replace MQTT/MQTTIP magic strings with actual IP addresses via MQTT lookup
+    - Expand hostnames that are already in ``CORE.address_cache`` to their
+      cached IPs so downstream code (e.g. aioesphomeapi) doesn't open a second
+      Zeroconf client to resolve them
    - Deduplicate addresses while preserving order
    - Only resolve MQTT once even if multiple MQTT strings are present
    - If MQTT resolution fails, log a warning and continue with other devices
@@ -444,13 +531,29 @@ def _resolve_network_devices(
                    mqtt_ips = mqtt_get_ip(
                        config, args.username, args.password, args.client_id
                    )
-                    network_devices.extend(mqtt_ips)
+                    # pylint can't infer mqtt_get_ip's return through its
+                    # lazy ``from esphome import mqtt`` import, so it flags
+                    # the genexpr below.
+                    network_devices.extend(
+                        addr
+                        for addr in mqtt_ips  # pylint: disable=not-an-iterable
+                        if addr not in network_devices
+                    )
                except EsphomeError as err:
                    _LOGGER.warning(
                        "MQTT IP discovery failed (%s), will try other devices if available",
                        err,
                    )
                mqtt_resolved = True
+            continue
+
+        # If the hostname is already in the address cache (e.g. populated by
+        # mDNS discovery), substitute the cached IPs so aioesphomeapi doesn't
+        # open its own Zeroconf to re-resolve it.
+        if CORE.address_cache and (cached := CORE.address_cache.get_addresses(device)):
+            network_devices.extend(
+                addr for addr in cached if addr not in network_devices
+            )
        elif device not in network_devices:
            # Regular network address or IP - add if not already present
            network_devices.append(device)
@@ -564,7 +667,7 @@ def run_miniterm(config: ConfigType, port: str, args) -> int:
    return 0


-def wrap_to_code(name, comp):
+def _wrap_to_code(name, comp, yaml_util):
    coro = coroutine(comp.to_code)

    @functools.wraps(comp.to_code)
@@ -584,6 +687,8 @@ def wrap_to_code(name, comp):


 def write_cpp(config: ConfigType, native_idf: bool = False) -> int:
+    from esphome import writer
+
    if not get_bool_env(ENV_NOGITIGNORE):
        writer.write_gitignore()

@@ -595,17 +700,21 @@ def write_cpp(config: ConfigType, native_idf: bool = False) -> int:


 def generate_cpp_contents(config: ConfigType) -> None:
+    from esphome import yaml_util
+
    _LOGGER.info("Generating C++ source...")

    for name, component, conf in iter_component_configs(CORE.config):
        if component.to_code is not None:
-            coro = wrap_to_code(name, component)
+            coro = _wrap_to_code(name, component, yaml_util)
            CORE.add_job(coro, conf)

    CORE.flush_tasks()


 def write_cpp_file(native_idf: bool = False) -> int:
+    from esphome import writer
+
    code_s = indent(CORE.cpp_main_section)
    writer.write_cpp(code_s)

@@ -1016,15 +1125,16 @@ def upload_program(

    remote_port = int(ota_conf[CONF_PORT])
    password = ota_conf.get(CONF_PASSWORD)
-    if getattr(args, "file", None) is not None:
-        binary = Path(args.file)
-    else:
-        binary = CORE.firmware_bin

    # Resolve MQTT magic strings to actual IP addresses
    network_devices = _resolve_network_devices(devices, config, args)

-    return espota2.run_ota(network_devices, remote_port, password, binary)
+    binary = CORE.firmware_bin
+    ota_type = espota2.OTA_TYPE_UPDATE_APP
+    if getattr(args, "file", None) is not None:
+        binary = Path(args.file)
+
+    return espota2.run_ota(network_devices, remote_port, password, binary, ota_type)


 def show_logs(config: ConfigType, args: ArgsProtocol, devices: list[str]) -> int | None:
@@ -1084,6 +1194,8 @@ def command_wizard(args: ArgsProtocol) -> int | None:


 def command_config(args: ArgsProtocol, config: ConfigType) -> int | None:
+    from esphome import yaml_util
+
    if not CORE.verbose:
        config = strip_default_ids(config)
    output = yaml_util.dump(config, args.show_secrets)
@@ -1225,6 +1337,8 @@ def command_clean_mqtt(args: ArgsProtocol, config: ConfigType) -> int | None:


 def command_clean_all(args: ArgsProtocol) -> int | None:
+    from esphome import writer
+
    try:
        writer.clean_all(args.configuration)
    except OSError as err:
@@ -1240,6 +1354,8 @@ def command_version(args: ArgsProtocol) -> int | None:


 def command_clean(args: ArgsProtocol, config: ConfigType) -> int | None:
+    from esphome import writer
+
    try:
        writer.clean_build()
    except OSError as err:
@@ -1442,6 +1558,8 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:


 def command_rename(args: ArgsProtocol, config: ConfigType) -> int | None:
+    from esphome import yaml_util
+
    new_name = args.name
    for c in new_name:
        if c not in ALLOWED_NAME_CHARS:
@@ -101,6 +101,17 @@ class AddressCache:
        """Check if any cache entries exist."""
        return bool(self.mdns_cache or self.dns_cache)

+    def add_mdns_addresses(self, hostname: str, addresses: list[str]) -> None:
+        """Store resolved mDNS addresses for ``hostname`` in the cache.
+
+        Callers that discover ``.local`` hosts (e.g. via mDNS browse) can use
+        this to avoid a second resolution round-trip during the upload path.
+        No-op when ``addresses`` is empty.
+        """
+        if not addresses:
+            return
+        self.mdns_cache[normalize_hostname(hostname)] = addresses
+
    @classmethod
    def from_cli_args(
        cls, mdns_args: Iterable[str], dns_args: Iterable[str]
@@ -793,8 +793,11 @@ class MemoryAnalyzer:
        """Scan ESPHome source object files to map extern "C" symbols to components.

        When no linker map file is available, this uses ``nm`` to scan ``.o`` files
-        under ``src/esphome/`` and build a symbol-to-component mapping. This catches
-        ``extern "C"`` functions and other symbols that lack C++ namespace prefixes.
+        under ``src/`` (including ``src/main.cpp.o`` and everything beneath
+        ``src/esphome/``) and build a symbol-to-component mapping. This catches
+        ``extern "C"`` functions, the ESPHome-generated ``setup()``/``loop()``
+        entry points in ``main.cpp``, and other symbols that lack C++ namespace
+        prefixes.

        Skips scanning if ``_source_symbol_map`` was already populated by
        ``_parse_map_file()``.
@@ -806,12 +809,12 @@ class MemoryAnalyzer:
        if obj_dir is None:
            return

-        # Find ESPHome source object files
-        esphome_src_dir = obj_dir / "src" / "esphome"
-        if not esphome_src_dir.is_dir():
+        # Scan all ESPHome-owned source object files: src/main.cpp.o and src/esphome/...
+        src_dir = obj_dir / "src"
+        if not src_dir.is_dir():
            return

-        obj_files = sorted(esphome_src_dir.rglob("*.o"))
+        obj_files = sorted(src_dir.rglob("*.o"))
        if not obj_files:
            return

@@ -1064,6 +1067,10 @@ class MemoryAnalyzer:
                if component_name in self.external_components:
                    return f"{_COMPONENT_PREFIX_EXTERNAL}{component_name}"

+        # ESPHome-generated entry point: src/main.cpp.o (contains setup()/loop())
+        if len(parts) >= 2 and parts[-2:] == ("src", "main.cpp.o"):
+            return _COMPONENT_CORE
+
        # ESPHome core: src/esphome/core/... or src/esphome/...
        if "core" in parts and "esphome" in parts:
            return _COMPONENT_CORE
@@ -0,0 +1,56 @@
+"""Helpers for running an async coroutine from sync code via a daemon thread.
+
+``asyncio.run(coro())`` in the main thread blocks until the loop's cleanup
+cycle finishes, which can add hundreds of milliseconds before the caller
+receives the result. Running the loop in a daemon thread lets the caller
+observe the result as soon as the coroutine completes while cleanup finishes
+in the background.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+import threading
+from typing import Generic, TypeVar
+
+_T = TypeVar("_T")
+
+
+class AsyncThreadRunner(threading.Thread, Generic[_T]):
+    """Run an async coroutine in a daemon thread and expose its result.
+
+    The runner catches all exceptions from the coroutine and stores them in
+    ``exception`` so ``event`` is always set — this prevents callers waiting
+    on ``event`` from hanging forever when the coroutine crashes.
+
+    Typical usage::
+
+        runner = AsyncThreadRunner(lambda: my_coro(arg))
+        runner.start()
+        if not runner.event.wait(timeout=5.0):
+            ...  # timed out
+        if runner.exception is not None:
+            raise runner.exception
+        result = runner.result
+    """
+
+    def __init__(self, coro_factory: Callable[[], Awaitable[_T]]) -> None:
+        super().__init__(daemon=True)
+        self._coro_factory = coro_factory
+        self.result: _T | None = None
+        self.exception: BaseException | None = None
+        self.event = threading.Event()
+
+    async def _runner(self) -> None:
+        try:
+            self.result = await self._coro_factory()
+        except Exception as exc:  # pylint: disable=broad-except
+            # Capture all exceptions so ``event`` is always set — otherwise a
+            # crash would hang the waiter forever.
+            self.exception = exc
+        finally:
+            self.event.set()
+
+    def run(self) -> None:
+        asyncio.run(self._runner())
@@ -127,7 +127,7 @@ def validate_potentially_or_condition(value):
    return validate_condition(value)


-DelayAction = cg.esphome_ns.class_("DelayAction", Action, cg.Component)
+DelayAction = cg.esphome_ns.class_("DelayAction", Action)
 LambdaAction = cg.esphome_ns.class_("LambdaAction", Action)
 StatelessLambdaAction = cg.esphome_ns.class_("StatelessLambdaAction", Action)
 IfAction = cg.esphome_ns.class_("IfAction", Action)
@@ -396,7 +396,6 @@ async def delay_action_to_code(
    args: TemplateArgsType,
 ) -> MockObj:
    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_component(var, {})
    template_ = await cg.templatable(config, args, cg.uint32)
    cg.add(var.set_delay(template_))
    return var
@@ -597,7 +596,7 @@ async def component_resume_action_to_code(
    comp = await cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, comp)
    if CONF_UPDATE_INTERVAL in config:
-        template_ = await cg.templatable(config[CONF_UPDATE_INTERVAL], args, int)
+        template_ = await cg.templatable(config[CONF_UPDATE_INTERVAL], args, cg.uint32)
        cg.add(var.set_update_interval(template_))
    return var

@@ -129,7 +129,7 @@ AdalightLightEffect::Frame AdalightLightEffect::parse_frame_(light::AddressableL
  uint8_t *led_data = &frame_[6];

  for (int led = 0; led < accepted_led_count; led++, led_data += 3) {
-    auto white = std::min(std::min(led_data[0], led_data[1]), led_data[2]);
+    auto white = std::min({led_data[0], led_data[1], led_data[2]});

    it[led].set(Color(led_data[0], led_data[1], led_data[2], white));
  }
@@ -13,7 +13,11 @@ from esphome.const import (
    CONF_WEB_SERVER,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
+from esphome.core.entity_helpers import (
+    entity_duplicate_validator,
+    queue_entity_register,
+    setup_entity,
+)
 from esphome.cpp_generator import MockObjClass

 CODEOWNERS = ["@grahambrown11", "@hwstar"]
@@ -181,7 +185,7 @@ async def setup_alarm_control_panel_core_(var, config):
 async def register_alarm_control_panel(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_alarm_control_panel(var))
+    queue_entity_register("alarm_control_panel", config)
    CORE.register_platform_component("alarm_control_panel", var)
    await setup_alarm_control_panel_core_(var, config)

@@ -62,7 +62,12 @@ void Animation::set_frame(int frame) {
 }

 void Animation::update_data_start_() {
-  const uint32_t image_size = this->get_width_stride() * this->height_;
+  uint32_t image_size = this->get_width_stride() * this->height_;
+  // RGB565 with an alpha channel stores the alpha plane immediately after the RGB
+  // plane within each frame, so the per-frame stride includes the alpha bytes.
+  if (this->type_ == image::IMAGE_TYPE_RGB565 && this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
+    image_size += static_cast<uint32_t>(this->width_) * this->height_;
+  }
  this->data_start_ = this->animation_data_start_ + image_size * this->current_frame_;
 }

@@ -1025,6 +1025,13 @@ message CameraImageRequest {
  bool stream = 2;
 }

+// ==================== TEMPERATURE UNIT ====================
+enum TemperatureUnit {
+  TEMPERATURE_UNIT_CELSIUS = 0;
+  TEMPERATURE_UNIT_FAHRENHEIT = 1;
+  TEMPERATURE_UNIT_KELVIN = 2;
+}
+
 // ==================== CLIMATE ====================
 enum ClimateMode {
  CLIMATE_MODE_OFF = 0;
@@ -1110,6 +1117,7 @@ message ListEntitiesClimateResponse {
  float visual_max_humidity = 25;
  uint32 device_id = 26 [(field_ifdef) = "USE_DEVICES"];
  uint32 feature_flags = 27;
+  TemperatureUnit temperature_unit = 28;
 }
 message ClimateStateResponse {
  option (id) = 47;
@@ -1203,6 +1211,7 @@ message ListEntitiesWaterHeaterResponse {
  repeated WaterHeaterMode supported_modes = 11 [(container_pointer_no_template) = "water_heater::WaterHeaterModeMask"];
  // Bitmask of WaterHeaterFeature flags
  uint32 supported_features = 12;
+  TemperatureUnit temperature_unit = 13;
 }

 message WaterHeaterStateResponse {
@@ -1410,6 +1419,8 @@ enum LockState {
  LOCK_STATE_JAMMED = 3;
  LOCK_STATE_LOCKING = 4;
  LOCK_STATE_UNLOCKING = 5;
+  LOCK_STATE_OPENING = 6;
+  LOCK_STATE_OPEN = 7;
 }
 enum LockCommand  {
  LOCK_UNLOCK = 0;
@@ -1628,7 +1639,7 @@ message BluetoothLEAdvertisementResponse {

 message BluetoothLERawAdvertisement {
  option (inline_encode) = true;
-  uint64 address = 1 [(force) = true];
+  uint64 address = 1 [(force) = true, (mac_address) = true];
  sint32 rssi = 2 [(force) = true];
  uint32 address_type = 3 [(max_value) = 4];

@@ -110,4 +110,10 @@ extend google.protobuf.FieldOptions {
    // length varint calculations and direct byte writes, since the length
    // varint is guaranteed to be 1 byte.
    optional uint32 max_data_length = 50018;
+
+    // mac_address: Field is a 48-bit MAC address stored in a uint64.
+    // Emits encode_varint_raw_48bit which has a 7-byte fast path that avoids
+    // the per-byte loop when the upper bits are non-zero (the common case
+    // for real MAC addresses, since OUIs occupy the top 24 bits).
+    optional bool mac_address = 50019 [default=false];
 }
@@ -1439,6 +1439,7 @@ uint8_t *ListEntitiesClimateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 26, this->device_id);
 #endif
  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 27, this->feature_flags);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 28, static_cast<uint32_t>(this->temperature_unit));
  return pos;
 }
 uint32_t ListEntitiesClimateResponse::calculate_size() const {
@@ -1488,6 +1489,7 @@ uint32_t ListEntitiesClimateResponse::calculate_size() const {
  size += ProtoSize::calc_uint32(2, this->device_id);
 #endif
  size += ProtoSize::calc_uint32(2, this->feature_flags);
+  size += this->temperature_unit ? 3 : 0;
  return size;
 }
 uint8_t *ClimateStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1645,6 +1647,7 @@ uint8_t *ListEntitiesWaterHeaterResponse::encode(ProtoWriteBuffer &buffer PROTO_
    ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(it), true);
  }
  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->supported_features);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(this->temperature_unit));
  return pos;
 }
 uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
@@ -1667,6 +1670,7 @@ uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
    size += this->supported_modes->size() * 2;
  }
  size += ProtoSize::calc_uint32(1, this->supported_features);
+  size += this->temperature_unit ? 2 : 0;
  return size;
 }
 uint8_t *WaterHeaterStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -2348,7 +2352,7 @@ BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
    uint8_t *len_pos = pos;
    ProtoEncode::reserve_byte(pos PROTO_ENCODE_DEBUG_ARG);
    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 8);
-    ProtoEncode::encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
+    ProtoEncode::encode_varint_raw_48bit(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 16);
    ProtoEncode::encode_varint_raw_short(pos PROTO_ENCODE_DEBUG_ARG, encode_zigzag32(sub_msg.rssi));
    if (sub_msg.address_type) {
@@ -2369,7 +2373,7 @@ BluetoothLERawAdvertisementsResponse::calculate_size() const {
  for (uint16_t i = 0; i < this->advertisements_len; i++) {
    auto &sub_msg = this->advertisements[i];
    size += 2;
-    size += ProtoSize::calc_uint64_force(1, sub_msg.address);
+    size += ProtoSize::calc_uint64_48bit_force(1, sub_msg.address);
    size += ProtoSize::calc_sint32_force(1, sub_msg.rssi);
    size += sub_msg.address_type ? 2 : 0;
    size += 2 + sub_msg.data_len;
@@ -92,6 +92,11 @@ enum SupportsResponseType : uint32_t {
  SUPPORTS_RESPONSE_STATUS = 100,
 };
 #endif
+enum TemperatureUnit : uint32_t {
+  TEMPERATURE_UNIT_CELSIUS = 0,
+  TEMPERATURE_UNIT_FAHRENHEIT = 1,
+  TEMPERATURE_UNIT_KELVIN = 2,
+};
 #ifdef USE_CLIMATE
 enum ClimateMode : uint32_t {
  CLIMATE_MODE_OFF = 0,
@@ -176,6 +181,8 @@ enum LockState : uint32_t {
  LOCK_STATE_JAMMED = 3,
  LOCK_STATE_LOCKING = 4,
  LOCK_STATE_UNLOCKING = 5,
+  LOCK_STATE_OPENING = 6,
+  LOCK_STATE_OPEN = 7,
 };
 enum LockCommand : uint32_t {
  LOCK_UNLOCK = 0,
@@ -1372,7 +1379,7 @@ class CameraImageRequest final : public ProtoDecodableMessage {
 class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
 public:
  static constexpr uint8_t MESSAGE_TYPE = 46;
-  static constexpr uint8_t ESTIMATED_SIZE = 150;
+  static constexpr uint8_t ESTIMATED_SIZE = 153;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("list_entities_climate_response"); }
 #endif
@@ -1394,6 +1401,7 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
  float visual_min_humidity{0.0f};
  float visual_max_humidity{0.0f};
  uint32_t feature_flags{0};
+  enums::TemperatureUnit temperature_unit{};
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
  uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1471,7 +1479,7 @@ class ClimateCommandRequest final : public CommandProtoMessage {
 class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
 public:
  static constexpr uint8_t MESSAGE_TYPE = 132;
-  static constexpr uint8_t ESTIMATED_SIZE = 63;
+  static constexpr uint8_t ESTIMATED_SIZE = 65;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("list_entities_water_heater_response"); }
 #endif
@@ -1480,6 +1488,7 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
  float target_temperature_step{0.0f};
  const water_heater::WaterHeaterModeMask *supported_modes{};
  uint32_t supported_features{0};
+  enums::TemperatureUnit temperature_unit{};
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
  uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -297,6 +297,18 @@ template<> const char *proto_enum_to_string<enums::SupportsResponseType>(enums::
  }
 }
 #endif
+template<> const char *proto_enum_to_string<enums::TemperatureUnit>(enums::TemperatureUnit value) {
+  switch (value) {
+    case enums::TEMPERATURE_UNIT_CELSIUS:
+      return ESPHOME_PSTR("TEMPERATURE_UNIT_CELSIUS");
+    case enums::TEMPERATURE_UNIT_FAHRENHEIT:
+      return ESPHOME_PSTR("TEMPERATURE_UNIT_FAHRENHEIT");
+    case enums::TEMPERATURE_UNIT_KELVIN:
+      return ESPHOME_PSTR("TEMPERATURE_UNIT_KELVIN");
+    default:
+      return ESPHOME_PSTR("UNKNOWN");
+  }
+}
 #ifdef USE_CLIMATE
 template<> const char *proto_enum_to_string<enums::ClimateMode>(enums::ClimateMode value) {
  switch (value) {
@@ -475,6 +487,10 @@ template<> const char *proto_enum_to_string<enums::LockState>(enums::LockState v
      return ESPHOME_PSTR("LOCK_STATE_LOCKING");
    case enums::LOCK_STATE_UNLOCKING:
      return ESPHOME_PSTR("LOCK_STATE_UNLOCKING");
+    case enums::LOCK_STATE_OPENING:
+      return ESPHOME_PSTR("LOCK_STATE_OPENING");
+    case enums::LOCK_STATE_OPEN:
+      return ESPHOME_PSTR("LOCK_STATE_OPEN");
    default:
      return ESPHOME_PSTR("UNKNOWN");
  }
@@ -1539,6 +1555,7 @@ const char *ListEntitiesClimateResponse::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
+  dump_field(out, ESPHOME_PSTR("temperature_unit"), static_cast<enums::TemperatureUnit>(this->temperature_unit));
  return out.c_str();
 }
 const char *ClimateStateResponse::dump_to(DumpBuffer &out) const {
@@ -1612,6 +1629,7 @@ const char *ListEntitiesWaterHeaterResponse::dump_to(DumpBuffer &out) const {
    dump_field(out, ESPHOME_PSTR("supported_modes"), static_cast<enums::WaterHeaterMode>(it), 4);
  }
  dump_field(out, ESPHOME_PSTR("supported_features"), this->supported_features);
+  dump_field(out, ESPHOME_PSTR("temperature_unit"), static_cast<enums::TemperatureUnit>(this->temperature_unit));
  return out.c_str();
 }
 const char *WaterHeaterStateResponse::dump_to(DumpBuffer &out) const {
@@ -21,6 +21,7 @@ void APIServerConnectionBase::log_receive_message_(const LogString *name) {
 }
 #endif

+#ifdef USE_API
 void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
  // Check authentication/connection requirements
  switch (msg_type) {
@@ -706,5 +707,6 @@ void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const ui
      break;
  }
 }
+#endif  // USE_API

 }  // namespace esphome::api
@@ -30,6 +30,11 @@ APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-c

 APIServer::APIServer() { global_api_server = this; }

+// Custom deleter defined here so `delete` sees the complete APIConnection type.
+// This prevents libc++ from emitting an "incomplete type" error when other
+// translation units only have the forward declaration of APIConnection.
+void APIServer::APIConnectionDeleter::operator()(APIConnection *p) const { delete p; }
+
 void APIServer::socket_failed_(const LogString *msg) {
  ESP_LOGW(TAG, "Socket %s: errno %d", LOG_STR_ARG(msg), errno);
  this->destroy_socket_();
@@ -193,7 +193,13 @@ class APIServer final : public Component,
  // Range-for view over the populated slice [0, api_connection_count_). Read-only with respect
  // to ownership — callers get `const unique_ptr&` so they can invoke non-const methods on the
  // APIConnection but cannot reset/move the slot and break the count invariant.
-  using APIConnectionPtr = std::unique_ptr<APIConnection>;
+  // Custom deleter is defined out-of-line in api_server.cpp so libc++ does not
+  // eagerly instantiate `delete static_cast<APIConnection *>(p)` here, where
+  // only the forward declaration of APIConnection is visible (incomplete type).
+  struct APIConnectionDeleter {
+    void operator()(APIConnection *p) const;
+  };
+  using APIConnectionPtr = std::unique_ptr<APIConnection, APIConnectionDeleter>;
  class ActiveClientsView {
    const APIConnectionPtr *begin_;
    const APIConnectionPtr *end_;
@@ -292,7 +298,7 @@ class APIServer final : public Component,
  uint32_t last_connected_{0};

  // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
-  std::array<std::unique_ptr<APIConnection>, MAX_API_CONNECTIONS> clients_{};
+  std::array<APIConnectionPtr, MAX_API_CONNECTIONS> clients_{};
  // Vectors and strings (12 bytes each on 32-bit)
  // Shared proto write buffer for all connections.
  // Not pre-allocated: all send paths call prepare_first_message_buffer() which
@@ -93,7 +93,24 @@ async def async_run_logs(
                    config, raw_line, backtrace_state=backtrace_state
                )

-    stop = await async_run(cli, on_log, name=name, subscribe_states=subscribe_states)
+    # Safe to fall back to plaintext here only for this diagnostics use
+    # case: the stream is one-way from device to client, and this code
+    # never accepts commands or acts on any message the device sends.
+    # An on-path attacker could still both inject fabricated log lines
+    # and passively read the device's log output (and any state data
+    # delivered when subscribe_states is enabled), so this does lose
+    # confidentiality as well as authentication/integrity. That tradeoff
+    # is acceptable for operator-visible logs, which aioesphomeapi also
+    # warns may come from an unverified device. Never mirror this opt-in
+    # for any connection that sends data to the device or uses Home
+    # Assistant actions.
+    stop = await async_run(
+        cli,
+        on_log,
+        name=name,
+        subscribe_states=subscribe_states,
+        allow_plaintext_fallback=True,
+    )
    try:
        await asyncio.Event().wait()
    finally:
@@ -78,7 +78,8 @@ class ActionResponse {
      : success_(success), error_message_(error_message) {
    if (data == nullptr || data_len == 0)
      return;
-    this->json_document_ = json::parse_json(data, data_len);
+    JsonDocument tmp = json::parse_json(data, data_len);
+    swap(this->json_document_, tmp);
  }
 #endif

@@ -342,6 +342,32 @@ class ProtoEncode {
    }
    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
  }
+  /// Encode a 48-bit MAC address (stored in a uint64) as varint.
+  /// Real MAC addresses occupy the full 48 bits (OUI in upper 24), so the
+  /// fast path -- any non-zero bit in the top 6 of 48 -- emits exactly 7 bytes
+  /// with no per-byte branch. Falls back to the general loop otherwise.
+  /// Caller must guarantee value fits in 48 bits (checked in debug builds).
+  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_48bit(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                   uint64_t value) {
+#ifdef ESPHOME_DEBUG_API
+    assert(value < (1ULL << (MAC_ADDRESS_SIZE * 8)) && "encode_varint_raw_48bit: value exceeds 48 bits");
+#endif
+    // 7-byte varint holds 49 bits (7 * 7), so a 48-bit value needs all 7 bytes
+    // whenever bit 42 or higher is set (i.e. value >= 1 << (48 - 6)).
+    if (value >= (1ULL << (MAC_ADDRESS_SIZE * 8 - 6))) [[likely]] {
+      PROTO_ENCODE_CHECK_BOUNDS(pos, 7);
+      pos[0] = static_cast<uint8_t>(value | 0x80);
+      pos[1] = static_cast<uint8_t>((value >> 7) | 0x80);
+      pos[2] = static_cast<uint8_t>((value >> 14) | 0x80);
+      pos[3] = static_cast<uint8_t>((value >> 21) | 0x80);
+      pos[4] = static_cast<uint8_t>((value >> 28) | 0x80);
+      pos[5] = static_cast<uint8_t>((value >> 35) | 0x80);
+      pos[6] = static_cast<uint8_t>(value >> 42);
+      pos += 7;
+      return;
+    }
+    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
  static inline void ESPHOME_ALWAYS_INLINE encode_field_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
                                                            uint32_t field_id, uint32_t type) {
    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, (field_id << 3) | type);
@@ -398,6 +424,7 @@ class ProtoEncode {
    if (len == 0 && !force)
      return;
    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
+    // NOLINTNEXTLINE(readability-inconsistent-ifelse-braces) -- false positive on [[likely]] attribute
    if (len < VARINT_MAX_1_BYTE) [[likely]] {
      PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
      *pos++ = static_cast<uint8_t>(len);
@@ -817,6 +844,14 @@ class ProtoSize {
  static constexpr inline uint32_t ESPHOME_ALWAYS_INLINE calc_uint64_force(uint32_t field_id_size, uint64_t value) {
    return field_id_size + varint(value);
  }
+  /// 48-bit MAC address variant: matches encode_varint_raw_48bit's fast path.
+  /// When any of the top 6 of 48 bits is set the encoded varint is 7 bytes;
+  /// otherwise fall back to the general size calculation.
+  /// Caller must guarantee value fits in 48 bits (encoder asserts in debug).
+  static constexpr inline uint32_t ESPHOME_ALWAYS_INLINE calc_uint64_48bit_force(uint32_t field_id_size,
+                                                                                 uint64_t value) {
+    return field_id_size + (value >= (1ULL << (MAC_ADDRESS_SIZE * 8 - 6)) ? 7 : varint(value));
+  }
  static constexpr uint32_t calc_length(uint32_t field_id_size, size_t len) {
    return len ? field_id_size + varint(static_cast<uint32_t>(len)) + static_cast<uint32_t>(len) : 0;
  }
@@ -14,11 +14,7 @@ class AQICalculator : public AbstractAQICalculator {
  uint16_t get_aqi(float pm2_5_value, float pm10_0_value) override {
    float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
    float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
-
-    float aqi = std::max(pm2_5_index, pm10_0_index);
-    if (aqi < 0.0f) {
-      aqi = 0.0f;
-    }
+    float aqi = std::max({pm2_5_index, pm10_0_index, 0.0f});
    return static_cast<uint16_t>(std::lround(aqi));
  }

@@ -12,11 +12,7 @@ class CAQICalculator : public AbstractAQICalculator {
  uint16_t get_aqi(float pm2_5_value, float pm10_0_value) override {
    float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
    float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
-
-    float aqi = std::max(pm2_5_index, pm10_0_index);
-    if (aqi < 0.0f) {
-      aqi = 0.0f;
-    }
+    float aqi = std::max({pm2_5_index, pm10_0_index, 0.0f});
    return static_cast<uint16_t>(std::lround(aqi));
  }

@@ -183,19 +183,19 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
        cg.add(var.set_sensing_distance(template_))

    if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
-        template_ = await cg.templatable(selfcheck, args, cg.int32)
+        template_ = await cg.templatable(selfcheck, args, cg.int_)
        cg.add(var.set_poweron_selfcheck_time(template_))

    if protect := config.get(CONF_PROTECT_TIME):
-        template_ = await cg.templatable(protect, args, cg.int32)
+        template_ = await cg.templatable(protect, args, cg.int_)
        cg.add(var.set_protect_time(template_))

    if trig_base := config.get(CONF_TRIGGER_BASE):
-        template_ = await cg.templatable(trig_base, args, cg.int32)
+        template_ = await cg.templatable(trig_base, args, cg.int_)
        cg.add(var.set_trigger_base(template_))

    if trig_keep := config.get(CONF_TRIGGER_KEEP):
-        template_ = await cg.templatable(trig_keep, args, cg.int32)
+        template_ = await cg.templatable(trig_keep, args, cg.int_)
        cg.add(var.set_trigger_keep(template_))

    if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:
@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field

 import esphome.codegen as cg
 from esphome.components.esp32 import (
@@ -7,7 +7,12 @@ from esphome.components.esp32 import (
    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
-from esphome.const import CONF_BITS_PER_SAMPLE, CONF_NUM_CHANNELS, CONF_SAMPLE_RATE
+from esphome.const import (
+    CONF_BITS_PER_SAMPLE,
+    CONF_NUM_CHANNELS,
+    CONF_SAMPLE_RATE,
+    CONF_SIZE,
+)
 from esphome.core import CORE
 import esphome.final_validate as fv

@@ -25,13 +30,46 @@ AUDIO_FILE_TYPE_ENUM = {
    "OPUS": AudioFileType.OPUS,
 }

+MEMORY_PSRAM = "psram"
+MEMORY_INTERNAL = "internal"
+MEMORY_LOCATIONS = [MEMORY_PSRAM, MEMORY_INTERNAL]
+
+
+@dataclass
+class FlacOptions:
+    buffer_memory: str | None = None
+
+
+@dataclass
+class Mp3Options:
+    buffer_memory: str | None = None
+
+
+@dataclass
+class OpusPseudostackOptions:
+    threadsafe: bool | None = None
+    buffer_memory: str | None = None
+    size: int | None = None
+
+
+@dataclass
+class OpusOptions:
+    floating_point: bool | None = None
+    state_memory: str | None = None
+    pseudostack: OpusPseudostackOptions = field(default_factory=OpusPseudostackOptions)
+

@dataclass
 class AudioData:
    flac_support: bool = False
    mp3_support: bool = False
    opus_support: bool = False
+    # WAV defaults to True for backward compatibility; will become opt-in in a future release
+    wav_support: bool = True
    micro_decoder_support: bool = False
+    flac: FlacOptions = field(default_factory=FlacOptions)
+    mp3: Mp3Options = field(default_factory=Mp3Options)
+    opus: OpusOptions = field(default_factory=OpusOptions)


 def _get_data() -> AudioData:
@@ -55,6 +93,11 @@ def request_opus_support() -> None:
    _get_data().opus_support = True


+def request_wav_support() -> None:
+    """Request WAV codec support for audio decoding."""
+    _get_data().wav_support = True
+
+
 def request_micro_decoder_support() -> None:
    """Request micro-decoder library support for audio decoding."""
    _get_data().micro_decoder_support = True
@@ -67,9 +110,78 @@ CONF_MAX_CHANNELS = "max_channels"
 CONF_MIN_SAMPLE_RATE = "min_sample_rate"
 CONF_MAX_SAMPLE_RATE = "max_sample_rate"

+CONF_CODECS = "codecs"
+CONF_WAV = "wav"
+CONF_FLAC = "flac"
+CONF_MP3 = "mp3"
+CONF_OPUS = "opus"
+CONF_BUFFER_MEMORY = "buffer_memory"
+CONF_FLOATING_POINT = "floating_point"
+CONF_STATE_MEMORY = "state_memory"
+CONF_PSEUDOSTACK = "pseudostack"
+CONF_THREADSAFE = "threadsafe"
+
+
+_MEMORY_LOCATION_VALIDATOR = cv.one_of(*MEMORY_LOCATIONS, lower=True)
+
+
+def _maybe_empty_codec(schema):
+    """Wrap a codec dict schema so that a bare key (None value) is treated as an empty dict."""
+
+    def validator(value):
+        if value is None:
+            value = {}
+        return schema(value)
+
+    return validator
+
+
+CODEC_FLAC_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_BUFFER_MEMORY): _MEMORY_LOCATION_VALIDATOR,
+    }
+)
+
+CODEC_MP3_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_BUFFER_MEMORY): _MEMORY_LOCATION_VALIDATOR,
+    }
+)
+
+OPUS_PSEUDOSTACK_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_THREADSAFE): cv.boolean,
+        cv.Optional(CONF_BUFFER_MEMORY): _MEMORY_LOCATION_VALIDATOR,
+        cv.Optional(CONF_SIZE): cv.int_range(60000, 240000),
+    }
+)
+
+CODEC_OPUS_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_FLOATING_POINT): cv.boolean,
+        cv.Optional(CONF_STATE_MEMORY): _MEMORY_LOCATION_VALIDATOR,
+        cv.Optional(CONF_PSEUDOSTACK): _maybe_empty_codec(OPUS_PSEUDOSTACK_SCHEMA),
+    }
+)
+
+CODEC_WAV_SCHEMA = cv.Schema({})
+
+CODECS_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_FLAC): _maybe_empty_codec(CODEC_FLAC_SCHEMA),
+        cv.Optional(CONF_MP3): _maybe_empty_codec(CODEC_MP3_SCHEMA),
+        cv.Optional(CONF_OPUS): _maybe_empty_codec(CODEC_OPUS_SCHEMA),
+        cv.Optional(CONF_WAV): _maybe_empty_codec(CODEC_WAV_SCHEMA),
+    }
+)

 CONFIG_SCHEMA = cv.All(
-    cv.Schema({}),
+    cv.Schema(
+        {
+            cv.Optional(CONF_CODECS): _maybe_empty_codec(CODECS_SCHEMA),
+        }
+    ),
+    cv.only_on_esp32,
 )

 AUDIO_COMPONENT_SCHEMA = cv.Schema(
@@ -208,6 +320,15 @@ def final_validate_audio_schema(
    )


+def _emit_memory_pair(value: str | None, psram_key: str, internal_key: str) -> None:
+    if value == MEMORY_PSRAM:
+        add_idf_sdkconfig_option(psram_key, True)
+        add_idf_sdkconfig_option(internal_key, False)
+    elif value == MEMORY_INTERNAL:
+        add_idf_sdkconfig_option(psram_key, False)
+        add_idf_sdkconfig_option(internal_key, True)
+
+
 async def to_code(config):
    # Re-enable ESP-IDF's HTTP client (excluded by default to save compile time)
    include_builtin_idf_component("esp_http_client")
@@ -219,8 +340,38 @@ async def to_code(config):

    data = _get_data()

+    # Merge user-supplied codec configuration (additive: presence enables the codec)
+    if codecs_config := config.get(CONF_CODECS):
+        if (flac_config := codecs_config.get(CONF_FLAC)) is not None:
+            data.flac_support = True
+            if (buffer_memory := flac_config.get(CONF_BUFFER_MEMORY)) is not None:
+                data.flac.buffer_memory = buffer_memory
+        if (mp3_config := codecs_config.get(CONF_MP3)) is not None:
+            data.mp3_support = True
+            if (buffer_memory := mp3_config.get(CONF_BUFFER_MEMORY)) is not None:
+                data.mp3.buffer_memory = buffer_memory
+        if (opus_config := codecs_config.get(CONF_OPUS)) is not None:
+            data.opus_support = True
+            floating_point = opus_config.get(CONF_FLOATING_POINT)
+            if floating_point is not None:
+                data.opus.floating_point = floating_point
+            if (state_memory := opus_config.get(CONF_STATE_MEMORY)) is not None:
+                data.opus.state_memory = state_memory
+            if (pseudostack_config := opus_config.get(CONF_PSEUDOSTACK)) is not None:
+                threadsafe = pseudostack_config.get(CONF_THREADSAFE)
+                if threadsafe is not None:
+                    data.opus.pseudostack.threadsafe = threadsafe
+                if (
+                    buffer_memory := pseudostack_config.get(CONF_BUFFER_MEMORY)
+                ) is not None:
+                    data.opus.pseudostack.buffer_memory = buffer_memory
+                if (size := pseudostack_config.get(CONF_SIZE)) is not None:
+                    data.opus.pseudostack.size = size
+        if CONF_WAV in codecs_config:
+            data.wav_support = True
+
    if data.micro_decoder_support:
-        add_idf_component(name="esphome/micro-decoder", ref="0.1.1")
+        add_idf_component(name="esphome/micro-decoder", ref="0.2.0")

        # All codecs are enabled by default in micro-decoder, so disable the ones that aren't requested to save flash
        if not data.flac_support:
@@ -229,13 +380,50 @@ async def to_code(config):
            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_MP3", False)
        if not data.opus_support:
            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_OPUS", False)
+        if not data.wav_support:
+            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_WAV", False)

-    # Legacy audio_decoder.cpp support defines and components
+    # Configure each codec library.
+    # Adds a define and IDF component for legacy `audio_decoder.cpp`.
    if data.flac_support:
        cg.add_define("USE_AUDIO_FLAC_SUPPORT")
        add_idf_component(name="esphome/micro-flac", ref="0.1.1")
+        _emit_memory_pair(
+            data.flac.buffer_memory,
+            "CONFIG_MICRO_FLAC_PREFER_PSRAM",
+            "CONFIG_MICRO_FLAC_PREFER_INTERNAL",
+        )
    if data.mp3_support:
        cg.add_define("USE_AUDIO_MP3_SUPPORT")
+        _emit_memory_pair(
+            data.mp3.buffer_memory,
+            "CONFIG_MP3_DECODER_PREFER_PSRAM",
+            "CONFIG_MP3_DECODER_PREFER_INTERNAL",
+        )
    if data.opus_support:
        cg.add_define("USE_AUDIO_OPUS_SUPPORT")
-        add_idf_component(name="esphome/micro-opus", ref="0.3.6")
+        add_idf_component(name="esphome/micro-opus", ref="0.4.0")
+        if data.opus.floating_point is not None:
+            add_idf_sdkconfig_option(
+                "CONFIG_OPUS_FLOATING_POINT", data.opus.floating_point
+            )
+        _emit_memory_pair(
+            data.opus.state_memory,
+            "CONFIG_OPUS_STATE_PREFER_PSRAM",
+            "CONFIG_OPUS_STATE_PREFER_INTERNAL",
+        )
+        if data.opus.pseudostack.threadsafe is True:
+            add_idf_sdkconfig_option("CONFIG_OPUS_THREADSAFE_PSEUDOSTACK", True)
+            add_idf_sdkconfig_option("CONFIG_OPUS_NONTHREADSAFE_PSEUDOSTACK", False)
+        elif data.opus.pseudostack.threadsafe is False:
+            add_idf_sdkconfig_option("CONFIG_OPUS_THREADSAFE_PSEUDOSTACK", False)
+            add_idf_sdkconfig_option("CONFIG_OPUS_NONTHREADSAFE_PSEUDOSTACK", True)
+        _emit_memory_pair(
+            data.opus.pseudostack.buffer_memory,
+            "CONFIG_OPUS_PSEUDOSTACK_PREFER_PSRAM",
+            "CONFIG_OPUS_PSEUDOSTACK_PREFER_INTERNAL",
+        )
+        if data.opus.pseudostack.size is not None:
+            add_idf_sdkconfig_option(
+                "CONFIG_OPUS_PSEUDOSTACK_SIZE", data.opus.pseudostack.size
+            )
@@ -1,4 +1,5 @@
 from dataclasses import dataclass, field
+from functools import partial
 import hashlib
 import logging
 from pathlib import Path
@@ -19,7 +20,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, HexInt
 from esphome.cpp_generator import MockObj
-from esphome.external_files import download_content
+from esphome.external_files import download_web_files_in_config
 from esphome.types import ConfigType

 _LOGGER = logging.getLogger(__name__)
@@ -63,15 +64,6 @@ def _compute_local_file_path(value: ConfigType) -> Path:
    return base_dir / key


-def _download_web_file(value: ConfigType) -> ConfigType:
-    url = value[CONF_URL]
-    path = _compute_local_file_path(value)
-
-    download_content(url, path)
-    _LOGGER.debug("download_web_file: path=%s", path)
-    return value
-
-
 def _file_schema(value: ConfigType | str) -> ConfigType:
    if isinstance(value, str):
        return _validate_file_shorthand(value)
@@ -142,11 +134,10 @@ LOCAL_SCHEMA = cv.Schema(
    }
 )

-WEB_SCHEMA = cv.All(
+WEB_SCHEMA = cv.Schema(
    {
        cv.Required(CONF_URL): cv.url,
-    },
-    _download_web_file,
+    }
 )


@@ -209,6 +200,7 @@ def _validate_supported_local_file(config: list[ConfigType]) -> list[ConfigType]
 CONFIG_SCHEMA = cv.All(
    cv.only_on_esp32,
    cv.ensure_list(MEDIA_FILE_TYPE_SCHEMA),
+    partial(download_web_files_in_config, path_for=_compute_local_file_path),
    _validate_supported_local_file,
 )

@@ -0,0 +1,163 @@
+#include "audio_http_media_source.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/core/log.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <algorithm>
+
+namespace esphome::audio_http {
+
+static const char *const TAG = "audio_http_media_source";
+
+// Decoder task / buffer tuning. Kept here as constants so the header stays free of magic numbers.
+static constexpr size_t DEFAULT_TRANSFER_BUFFER_SIZE = 8 * 1024;  // Staging buffer between HTTP reader and decoder
+static constexpr uint32_t HTTP_TIMEOUT_MS = 5000;                 // HTTP connect/read timeout
+static constexpr uint32_t AUDIO_WRITE_TIMEOUT_MS = 50;            // Max blocking time per on_audio_write() call
+static constexpr uint32_t READER_WRITE_TIMEOUT_MS = 50;           // Max blocking time when writing into the ring buffer
+static constexpr uint8_t READER_TASK_PRIORITY = 2;
+static constexpr uint8_t DECODER_TASK_PRIORITY = 2;
+static constexpr size_t READER_TASK_STACK_SIZE = 4096;
+static constexpr size_t DECODER_TASK_STACK_SIZE = 5120;
+static constexpr uint32_t PAUSE_POLL_DELAY_MS = 20;
+static constexpr const char *const HTTP_URI_PREFIX = "http://";
+static constexpr const char *const HTTPS_URI_PREFIX = "https://";
+
+void AudioHTTPMediaSource::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Audio HTTP Media Source:\n"
+                "  Buffer Size: %zu bytes\n"
+                "  Decoder Task Stack in PSRAM: %s",
+                this->buffer_size_, YESNO(this->decoder_task_stack_in_psram_));
+}
+
+void AudioHTTPMediaSource::setup() {
+  this->disable_loop();
+
+  micro_decoder::DecoderConfig config;
+  config.ring_buffer_size = this->buffer_size_;
+  // Keep the transfer buffer smaller than the ring buffer so the reader can top up the ring
+  // while the decoder is still draining it, instead of oscillating between empty and full.
+  config.transfer_buffer_size = std::min(DEFAULT_TRANSFER_BUFFER_SIZE, this->buffer_size_ / 2);
+  config.http_timeout_ms = HTTP_TIMEOUT_MS;
+  config.audio_write_timeout_ms = AUDIO_WRITE_TIMEOUT_MS;
+  config.reader_write_timeout_ms = READER_WRITE_TIMEOUT_MS;
+  config.reader_priority = READER_TASK_PRIORITY;
+  config.decoder_priority = DECODER_TASK_PRIORITY;
+  config.reader_stack_size = READER_TASK_STACK_SIZE;
+  config.decoder_stack_size = DECODER_TASK_STACK_SIZE;
+  config.decoder_stack_in_psram = this->decoder_task_stack_in_psram_;
+
+  this->decoder_ = std::make_unique<micro_decoder::DecoderSource>(config);
+  if (this->decoder_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to allocate decoder");
+    this->mark_failed();
+    return;
+  }
+  this->decoder_->set_listener(this);  // We inherit from micro_decoder::DecoderListener
+}
+
+void AudioHTTPMediaSource::loop() { this->decoder_->loop(); }
+
+bool AudioHTTPMediaSource::can_handle(const std::string &uri) const {
+  return uri.starts_with(HTTP_URI_PREFIX) || uri.starts_with(HTTPS_URI_PREFIX);
+}
+
+// Called from the orchestrator's main loop, so no synchronization needed with loop()
+bool AudioHTTPMediaSource::play_uri(const std::string &uri) {
+  if (!this->is_ready() || this->is_failed() || this->status_has_error() || !this->has_listener()) {
+    return false;
+  }
+
+  // Check if source is already playing
+  if (this->get_state() != media_source::MediaSourceState::IDLE) {
+    ESP_LOGE(TAG, "Cannot play '%s': source is busy", uri.c_str());
+    return false;
+  }
+
+  // Validate URI starts with "http://" or "https://"
+  if (!uri.starts_with(HTTP_URI_PREFIX) && !uri.starts_with(HTTPS_URI_PREFIX)) {
+    ESP_LOGE(TAG, "Invalid URI: '%s'", uri.c_str());
+    return false;
+  }
+
+  if (this->decoder_->play_url(uri)) {
+    this->pause_.store(false, std::memory_order_relaxed);
+    this->enable_loop();
+    return true;
+  }
+
+  ESP_LOGE(TAG, "Failed to start playback of '%s'", uri.c_str());
+  return false;
+}
+
+// Called from the orchestrator's main loop, so no synchronization needed with loop()
+void AudioHTTPMediaSource::handle_command(media_source::MediaSourceCommand command) {
+  switch (command) {
+    case media_source::MediaSourceCommand::STOP:
+      this->decoder_->stop();
+      break;
+    case media_source::MediaSourceCommand::PAUSE:
+      // Only valid while actively playing; ignoring from IDLE/ERROR/PAUSED prevents the state
+      // machine from getting stuck in PAUSED when no playback is active (which would block the
+      // next play_uri() call via its IDLE-state precondition).
+      if (this->get_state() != media_source::MediaSourceState::PLAYING)
+        break;
+      // PAUSE does not stop the decoder task. Instead, on_audio_write() returns 0 and temporarily
+      // yields, which fills the ring buffer and applies back pressure that effectively pauses both
+      // the decoder and HTTP reader tasks.
+      this->set_state_(media_source::MediaSourceState::PAUSED);
+      this->pause_.store(true, std::memory_order_relaxed);
+      break;
+    case media_source::MediaSourceCommand::PLAY:
+      // Only resume from PAUSED; don't fabricate a PLAYING state from IDLE/ERROR.
+      if (this->get_state() != media_source::MediaSourceState::PAUSED)
+        break;
+      this->set_state_(media_source::MediaSourceState::PLAYING);
+      this->pause_.store(false, std::memory_order_relaxed);
+      break;
+    default:
+      break;
+  }
+}
+
+// Called from the decoder task. Forwards to the orchestrator's listener, which is responsible for
+// being thread-safe with respect to its own audio writer.
+size_t AudioHTTPMediaSource::on_audio_write(const uint8_t *data, size_t length, uint32_t timeout_ms) {
+  if (this->pause_.load(std::memory_order_relaxed)) {
+    vTaskDelay(pdMS_TO_TICKS(PAUSE_POLL_DELAY_MS));
+    return 0;
+  }
+  return this->write_output(data, length, timeout_ms, this->stream_info_);
+}
+
+// Called from the decoder task before the first on_audio_write().
+void AudioHTTPMediaSource::on_stream_info(const micro_decoder::AudioStreamInfo &info) {
+  this->stream_info_ = audio::AudioStreamInfo(info.get_bits_per_sample(), info.get_channels(), info.get_sample_rate());
+}
+
+// microDecoder invokes on_state_change() from inside decoder_->loop(), so this runs on the main
+// loop thread and it's safe to call set_state_() directly.
+void AudioHTTPMediaSource::on_state_change(micro_decoder::DecoderState state) {
+  switch (state) {
+    case micro_decoder::DecoderState::IDLE:
+      this->set_state_(media_source::MediaSourceState::IDLE);
+      this->disable_loop();
+      break;
+    case micro_decoder::DecoderState::PLAYING:
+      this->set_state_(media_source::MediaSourceState::PLAYING);
+      break;
+    case micro_decoder::DecoderState::FAILED:
+      this->set_state_(media_source::MediaSourceState::ERROR);
+      break;
+    default:
+      break;
+  }
+}
+
+}  // namespace esphome::audio_http
+
+#endif  // USE_ESP32
@@ -0,0 +1,59 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/components/audio/audio.h"
+#include "esphome/components/media_source/media_source.h"
+#include "esphome/core/component.h"
+
+#include <micro_decoder/decoder_source.h>
+#include <micro_decoder/types.h>
+
+#include <atomic>
+#include <memory>
+#include <string>
+
+namespace esphome::audio_http {
+
+// Inherits from two unrelated listener-style interfaces:
+//   - media_source::MediaSource: this source reports state and writes audio *to* an orchestrator
+//     (the orchestrator calls set_listener() on us with a MediaSourceListener*).
+//   - micro_decoder::DecoderListener: the underlying decoder calls back *into* us with decoded
+//     audio and state changes (we call decoder_->set_listener(this) in setup()).
+// The two set_listener() methods live on different base classes and serve opposite directions.
+class AudioHTTPMediaSource : public Component, public media_source::MediaSource, public micro_decoder::DecoderListener {
+ public:
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+
+  void set_buffer_size(size_t buffer_size) { this->buffer_size_ = buffer_size; }
+  void set_task_stack_in_psram(bool task_stack_in_psram) { this->decoder_task_stack_in_psram_ = task_stack_in_psram; }
+
+  // MediaSource interface implementation
+  bool play_uri(const std::string &uri) override;
+  void handle_command(media_source::MediaSourceCommand command) override;
+  bool can_handle(const std::string &uri) const override;
+
+  // DecoderListener interface implementation
+  size_t on_audio_write(const uint8_t *data, size_t length, uint32_t timeout_ms) override;
+  void on_stream_info(const micro_decoder::AudioStreamInfo &info) override;
+  void on_state_change(micro_decoder::DecoderState state) override;
+
+ protected:
+  std::unique_ptr<micro_decoder::DecoderSource> decoder_;
+  audio::AudioStreamInfo stream_info_;
+
+  size_t buffer_size_{50000};
+
+  // Written from the main loop in handle_command(), read from the decoder task in
+  // on_audio_write(). Must be atomic to avoid a data race.
+  std::atomic<bool> pause_{false};
+  bool decoder_task_stack_in_psram_{false};
+};
+
+}  // namespace esphome::audio_http
+
+#endif  // USE_ESP32
@@ -0,0 +1,59 @@
+from typing import Any
+
+import esphome.codegen as cg
+from esphome.components import audio, esp32, media_source, psram
+import esphome.config_validation as cv
+from esphome.const import CONF_BUFFER_SIZE, CONF_ID, CONF_TASK_STACK_IN_PSRAM
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@kahrendt"]
+AUTO_LOAD = ["audio"]
+
+audio_http_ns = cg.esphome_ns.namespace("audio_http")
+AudioHTTPMediaSource = audio_http_ns.class_(
+    "AudioHTTPMediaSource", cg.Component, media_source.MediaSource
+)
+
+
+def _request_micro_decoder(config: ConfigType) -> ConfigType:
+    audio.request_micro_decoder_support()
+    return config
+
+
+def _validate_task_stack_in_psram(value: Any) -> bool:
+    # Only require the psram component when actually enabling PSRAM stacks; validating
+    # the boolean first means `false` doesn't trigger the requires_component check.
+    if value := cv.boolean(value):
+        return cv.requires_component(psram.DOMAIN)(value)
+    return value
+
+
+CONFIG_SCHEMA = cv.All(
+    media_source.media_source_schema(
+        AudioHTTPMediaSource,
+    )
+    .extend(
+        {
+            cv.Optional(CONF_BUFFER_SIZE, default=50000): cv.int_range(
+                min=5000, max=1000000
+            ),
+            cv.Optional(CONF_TASK_STACK_IN_PSRAM): _validate_task_stack_in_psram,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.only_on_esp32,
+    _request_micro_decoder,
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await media_source.register_media_source(var, config)
+
+    if config.get(CONF_TASK_STACK_IN_PSRAM):
+        cg.add(var.set_task_stack_in_psram(True))
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
+        )
+    cg.add(var.set_buffer_size(config[CONF_BUFFER_SIZE]))
@@ -62,6 +62,7 @@ CONF_IS_WRGB = "is_wrgb"
 SUPPORTED_PINS = {
    libretiny.const.FAMILY_BK7231N: [16],
    libretiny.const.FAMILY_BK7231T: [16],
+    libretiny.const.FAMILY_BK7238: [16],
    libretiny.const.FAMILY_BK7251: [16],
 }

@@ -154,7 +154,7 @@ void BH1750Sensor::loop() {
        break;
      }

-      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGV(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
      this->status_clear_warning();
      this->publish_state(lx);
      this->state_ = IDLE;
@@ -62,6 +62,7 @@ from esphome.const import (
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
+    queue_entity_register,
    setup_device_class,
    setup_entity,
 )
@@ -142,15 +143,15 @@ BinarySensorCondition = binary_sensor_ns.class_("BinarySensorCondition", Conditi

 # Filters
 Filter = binary_sensor_ns.class_("Filter")
-TimeoutFilter = binary_sensor_ns.class_("TimeoutFilter", Filter, cg.Component)
-DelayedOnOffFilter = binary_sensor_ns.class_("DelayedOnOffFilter", Filter, cg.Component)
-DelayedOnFilter = binary_sensor_ns.class_("DelayedOnFilter", Filter, cg.Component)
-DelayedOffFilter = binary_sensor_ns.class_("DelayedOffFilter", Filter, cg.Component)
+TimeoutFilter = binary_sensor_ns.class_("TimeoutFilter", Filter)
+DelayedOnOffFilter = binary_sensor_ns.class_("DelayedOnOffFilter", Filter)
+DelayedOnFilter = binary_sensor_ns.class_("DelayedOnFilter", Filter)
+DelayedOffFilter = binary_sensor_ns.class_("DelayedOffFilter", Filter)
 InvertFilter = binary_sensor_ns.class_("InvertFilter", Filter)
 AutorepeatFilter = binary_sensor_ns.class_("AutorepeatFilter", Filter, cg.Component)
 LambdaFilter = binary_sensor_ns.class_("LambdaFilter", Filter)
 StatelessLambdaFilter = binary_sensor_ns.class_("StatelessLambdaFilter", Filter)
-SettleFilter = binary_sensor_ns.class_("SettleFilter", Filter, cg.Component)
+SettleFilter = binary_sensor_ns.class_("SettleFilter", Filter)

 _LOGGER = getLogger(__name__)

@@ -174,7 +175,6 @@ async def invert_filter_to_code(config, filter_id):
 )
 async def timeout_filter_to_code(config, filter_id):
    var = cg.new_Pvariable(filter_id)
-    await cg.register_component(var, {})
    template_ = await cg.templatable(config, [], cg.uint32)
    cg.add(var.set_timeout_value(template_))
    return var
@@ -202,7 +202,6 @@ async def timeout_filter_to_code(config, filter_id):
 )
 async def delayed_on_off_filter_to_code(config, filter_id):
    var = cg.new_Pvariable(filter_id)
-    await cg.register_component(var, {})
    if isinstance(config, dict):
        template_ = await cg.templatable(config[CONF_TIME_ON], [], cg.uint32)
        cg.add(var.set_on_delay(template_))
@@ -220,7 +219,6 @@ async def delayed_on_off_filter_to_code(config, filter_id):
 )
 async def delayed_on_filter_to_code(config, filter_id):
    var = cg.new_Pvariable(filter_id)
-    await cg.register_component(var, {})
    template_ = await cg.templatable(config, [], cg.uint32)
    cg.add(var.set_delay(template_))
    return var
@@ -233,7 +231,6 @@ async def delayed_on_filter_to_code(config, filter_id):
 )
 async def delayed_off_filter_to_code(config, filter_id):
    var = cg.new_Pvariable(filter_id)
-    await cg.register_component(var, {})
    template_ = await cg.templatable(config, [], cg.uint32)
    cg.add(var.set_delay(template_))
    return var
@@ -305,7 +302,6 @@ async def lambda_filter_to_code(config, filter_id):
 )
 async def settle_filter_to_code(config, filter_id):
    var = cg.new_Pvariable(filter_id)
-    await cg.register_component(var, {})
    template_ = await cg.templatable(config, [], cg.uint32)
    cg.add(var.set_delay(template_))
    return var
@@ -624,7 +620,7 @@ async def setup_binary_sensor_core_(var, config):
 async def register_binary_sensor(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_binary_sensor(var))
+    queue_entity_register("binary_sensor", config)
    CORE.register_platform_component("binary_sensor", var)
    await setup_binary_sensor_core_(var, config)

@@ -50,29 +50,31 @@ void MultiClickTriggerBase::on_state_(bool state) {
    return;
  }

-  if (*this->at_index_ == this->timing_count_) {
+  // at_index_ has a value here (the !has_value() branch above returns).
+  size_t at_index = *this->at_index_;
+  if (at_index == this->timing_count_) {
    this->trigger_();
    return;
  }

-  MultiClickTriggerEvent evt = this->timing_[*this->at_index_];
+  MultiClickTriggerEvent evt = this->timing_[at_index];

  if (evt.max_length != 4294967294UL) {
-    ESP_LOGV(TAG, "A i=%zu min=%" PRIu32 " max=%" PRIu32, *this->at_index_, evt.min_length, evt.max_length);  // NOLINT
+    ESP_LOGV(TAG, "A i=%zu min=%" PRIu32 " max=%" PRIu32, at_index, evt.min_length, evt.max_length);  // NOLINT
    this->schedule_is_valid_(evt.min_length);
    this->schedule_is_not_valid_(evt.max_length);
-  } else if (*this->at_index_ + 1 != this->timing_count_) {
-    ESP_LOGV(TAG, "B i=%zu min=%" PRIu32, *this->at_index_, evt.min_length);  // NOLINT
+  } else if (at_index + 1 != this->timing_count_) {
+    ESP_LOGV(TAG, "B i=%zu min=%" PRIu32, at_index, evt.min_length);  // NOLINT
    this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
    this->schedule_is_valid_(evt.min_length);
  } else {
-    ESP_LOGV(TAG, "C i=%zu min=%" PRIu32, *this->at_index_, evt.min_length);  // NOLINT
+    ESP_LOGV(TAG, "C i=%zu min=%" PRIu32, at_index, evt.min_length);  // NOLINT
    this->is_valid_ = false;
    this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
    this->set_timeout(MULTICLICK_TRIGGER_ID, evt.min_length, [this]() { this->trigger_(); });
  }

-  *this->at_index_ = *this->at_index_ + 1;
+  this->at_index_ = at_index + 1;
 }
 void MultiClickTriggerBase::schedule_cooldown_() {
  ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
@@ -4,16 +4,14 @@
 #include "filter.h"

 #include "binary_sensor.h"
+#include "esphome/core/application.h"

 namespace esphome::binary_sensor {

 static const char *const TAG = "sensor.filter";

-// Timeout IDs for filter classes.
-// Each filter is its own Component instance, so the scheduler scopes
-// IDs by component pointer — no risk of collisions between instances.
-constexpr uint32_t FILTER_TIMEOUT_ID = 0;
-// AutorepeatFilter needs two distinct IDs (both timeouts on the same component)
+// AutorepeatFilter still inherits Component (it schedules two distinct timer
+// purposes), so it keeps the (Component *, id) scheduler API.
 constexpr uint32_t AUTOREPEAT_TIMING_ID = 0;
 constexpr uint32_t AUTOREPEAT_ON_OFF_ID = 1;

@@ -34,46 +32,40 @@ void Filter::input(bool value) {
 }

 void TimeoutFilter::input(bool value) {
-  this->set_timeout(FILTER_TIMEOUT_ID, this->timeout_delay_.value(), [this]() { this->parent_->invalidate_state(); });
+  App.scheduler.set_timeout(this, this->timeout_delay_.value(), [this]() { this->parent_->invalidate_state(); });
  // we do not de-dup here otherwise changes from invalid to valid state will not be output
  this->output(value);
 }

 optional<bool> DelayedOnOffFilter::new_value(bool value) {
  if (value) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->on_delay_.value(), [this]() { this->output(true); });
+    App.scheduler.set_timeout(this, this->on_delay_.value(), [this]() { this->output(true); });
  } else {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->off_delay_.value(), [this]() { this->output(false); });
+    App.scheduler.set_timeout(this, this->off_delay_.value(), [this]() { this->output(false); });
  }
  return {};
 }

-float DelayedOnOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
-
 optional<bool> DelayedOnFilter::new_value(bool value) {
  if (value) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this]() { this->output(true); });
+    App.scheduler.set_timeout(this, this->delay_.value(), [this]() { this->output(true); });
    return {};
  } else {
-    this->cancel_timeout(FILTER_TIMEOUT_ID);
+    App.scheduler.cancel_timeout(this);
    return false;
  }
 }

-float DelayedOnFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
-
 optional<bool> DelayedOffFilter::new_value(bool value) {
  if (!value) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this]() { this->output(false); });
+    App.scheduler.set_timeout(this, this->delay_.value(), [this]() { this->output(false); });
    return {};
  } else {
-    this->cancel_timeout(FILTER_TIMEOUT_ID);
+    App.scheduler.cancel_timeout(this);
    return true;
  }
 }

-float DelayedOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
-
 optional<bool> InvertFilter::new_value(bool value) { return !value; }

 // AutorepeatFilterBase
@@ -118,20 +110,18 @@ optional<bool> LambdaFilter::new_value(bool value) { return this->f_(value); }

 optional<bool> SettleFilter::new_value(bool value) {
  if (!this->steady_) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this, value]() {
+    App.scheduler.set_timeout(this, this->delay_.value(), [this, value]() {
      this->steady_ = true;
      this->output(value);
    });
    return {};
  } else {
    this->steady_ = false;
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this]() { this->steady_ = true; });
+    App.scheduler.set_timeout(this, this->delay_.value(), [this]() { this->steady_ = true; });
    return value;
  }
 }

-float SettleFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
-
 }  // namespace esphome::binary_sensor

 #endif  // USE_BINARY_SENSOR_FILTER
@@ -29,7 +29,7 @@ class Filter {
  Deduplicator<bool> dedup_;
 };

-class TimeoutFilter : public Filter, public Component {
+class TimeoutFilter : public Filter {
 public:
  optional<bool> new_value(bool value) override { return value; }
  void input(bool value) override;
@@ -39,12 +39,10 @@ class TimeoutFilter : public Filter, public Component {
  TemplatableFn<uint32_t> timeout_delay_{};
 };

-class DelayedOnOffFilter final : public Filter, public Component {
+class DelayedOnOffFilter final : public Filter {
 public:
  optional<bool> new_value(bool value) override;

-  float get_setup_priority() const override;
-
  template<typename T> void set_on_delay(T delay) { this->on_delay_ = delay; }
  template<typename T> void set_off_delay(T delay) { this->off_delay_ = delay; }

@@ -53,24 +51,20 @@ class DelayedOnOffFilter final : public Filter, public Component {
  TemplatableFn<uint32_t> off_delay_{};
 };

-class DelayedOnFilter : public Filter, public Component {
+class DelayedOnFilter : public Filter {
 public:
  optional<bool> new_value(bool value) override;

-  float get_setup_priority() const override;
-
  template<typename T> void set_delay(T delay) { this->delay_ = delay; }

 protected:
  TemplatableFn<uint32_t> delay_{};
 };

-class DelayedOffFilter : public Filter, public Component {
+class DelayedOffFilter : public Filter {
 public:
  optional<bool> new_value(bool value) override;

-  float get_setup_priority() const override;
-
  template<typename T> void set_delay(T delay) { this->delay_ = delay; }

 protected:
@@ -146,12 +140,10 @@ class StatelessLambdaFilter : public Filter {
  optional<bool> (*f_)(bool);
 };

-class SettleFilter : public Filter, public Component {
+class SettleFilter : public Filter {
 public:
  optional<bool> new_value(bool value) override;

-  float get_setup_priority() const override;
-
  template<typename T> void set_delay(T delay) { this->delay_ = delay; }

 protected:
@@ -16,6 +16,7 @@ from esphome.components.libretiny.const import (
    FAMILY_BK7231N,
    FAMILY_BK7231Q,
    FAMILY_BK7231T,
+    FAMILY_BK7238,
    FAMILY_BK7251,
 )

@@ -24,16 +25,32 @@ BK72XX_BOARDS = {
        "name": "WB2L_M1 Wi-Fi Module",
        "family": FAMILY_BK7231N,
    },
+    "xh-wb3s": {
+        "name": "NiceMCU XH-WB3S",
+        "family": FAMILY_BK7238,
+    },
    "cbu": {
        "name": "CBU Wi-Fi Module",
        "family": FAMILY_BK7231N,
    },
+    "t1-u": {
+        "name": "T1-U Wi-Fi Module",
+        "family": FAMILY_BK7238,
+    },
+    "generic-bk7238-tuya": {
+        "name": "Generic - BK7238 (Tuya T1)",
+        "family": FAMILY_BK7238,
+    },
+    "t1-m": {
+        "name": "T1-M Wi-Fi Module",
+        "family": FAMILY_BK7238,
+    },
    "generic-bk7231t-qfn32-tuya": {
-        "name": "Generic - BK7231T (Tuya QFN32)",
+        "name": "Generic - BK7231T (Tuya)",
        "family": FAMILY_BK7231T,
    },
    "generic-bk7231n-qfn32-tuya": {
-        "name": "Generic - BK7231N (Tuya QFN32)",
+        "name": "Generic - BK7231N (Tuya)",
        "family": FAMILY_BK7231N,
    },
    "cb1s": {
@@ -64,6 +81,10 @@ BK72XX_BOARDS = {
        "name": "Generic - BK7252",
        "family": FAMILY_BK7251,
    },
+    "t1-3s": {
+        "name": "T1-3S Wi-Fi Module",
+        "family": FAMILY_BK7238,
+    },
    "wb2l": {
        "name": "WB2L Wi-Fi Module",
        "family": FAMILY_BK7231T,
@@ -80,6 +101,10 @@ BK72XX_BOARDS = {
        "name": "CB2S Wi-Fi Module",
        "family": FAMILY_BK7231N,
    },
+    "generic-bk7238": {
+        "name": "Generic - BK7238",
+        "family": FAMILY_BK7238,
+    },
    "wa2": {
        "name": "WA2 Wi-Fi Module",
        "family": FAMILY_BK7231Q,
@@ -100,6 +125,10 @@ BK72XX_BOARDS = {
        "name": "WB3L Wi-Fi Module",
        "family": FAMILY_BK7231T,
    },
+    "t1-2s": {
+        "name": "T1-2S Wi-Fi Module",
+        "family": FAMILY_BK7238,
+    },
    "wb2s": {
        "name": "WB2S Wi-Fi Module",
        "family": FAMILY_BK7231T,
@@ -158,6 +187,83 @@ BK72XX_BOARD_PINS = {
        "D12": 22,
        "A0": 23,
    },
+    "xh-wb3s": {
+        "SPI0_CS": 15,
+        "SPI0_MISO": 17,
+        "SPI0_MOSI": 16,
+        "SPI0_SCK": 14,
+        "WIRE2_SCL_0": 15,
+        "WIRE2_SCL_1": 24,
+        "WIRE2_SDA_0": 17,
+        "WIRE2_SDA_1": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC3": 20,
+        "ADC4": 28,
+        "ADC5": 1,
+        "ADC6": 10,
+        "CS": 15,
+        "MISO": 17,
+        "MOSI": 16,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P7": 7,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P14": 14,
+        "P15": 15,
+        "P16": 16,
+        "P17": 17,
+        "P20": 20,
+        "P21": 21,
+        "P22": 22,
+        "P23": 23,
+        "P24": 24,
+        "P26": 26,
+        "P28": 28,
+        "PWM0": 6,
+        "PWM1": 7,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCK": 14,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 7,
+        "D1": 23,
+        "D2": 14,
+        "D3": 26,
+        "D4": 24,
+        "D5": 6,
+        "D6": 9,
+        "D7": 0,
+        "D8": 1,
+        "D9": 8,
+        "D10": 10,
+        "D11": 11,
+        "D12": 16,
+        "D13": 20,
+        "D14": 21,
+        "D15": 22,
+        "D16": 15,
+        "D17": 17,
+        "A0": 28,
+        "A1": 26,
+        "A2": 24,
+        "A3": 1,
+        "A4": 10,
+        "A5": 20,
+    },
    "cbu": {
        "SPI0_CS": 15,
        "SPI0_MISO": 17,
@@ -230,6 +336,204 @@ BK72XX_BOARD_PINS = {
        "D18": 21,
        "A0": 23,
    },
+    "t1-u": {
+        "SPI0_CS": 15,
+        "SPI0_MISO": 17,
+        "SPI0_MOSI": 16,
+        "SPI0_SCK": 14,
+        "WIRE2_SCL_0": 15,
+        "WIRE2_SCL_1": 24,
+        "WIRE2_SDA_0": 17,
+        "WIRE2_SDA_1": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC3": 20,
+        "ADC4": 28,
+        "ADC5": 1,
+        "ADC6": 10,
+        "CS": 15,
+        "MISO": 17,
+        "MOSI": 16,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P14": 14,
+        "P15": 15,
+        "P16": 16,
+        "P17": 17,
+        "P20": 20,
+        "P21": 21,
+        "P22": 22,
+        "P23": 23,
+        "P24": 24,
+        "P26": 26,
+        "P28": 28,
+        "PWM0": 6,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCK": 14,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 14,
+        "D1": 16,
+        "D2": 23,
+        "D3": 22,
+        "D4": 20,
+        "D5": 1,
+        "D6": 0,
+        "D7": 24,
+        "D8": 9,
+        "D9": 26,
+        "D10": 6,
+        "D11": 8,
+        "D12": 11,
+        "D13": 10,
+        "D14": 28,
+        "D15": 21,
+        "D16": 17,
+        "D17": 15,
+        "A0": 20,
+        "A1": 1,
+        "A2": 24,
+        "A3": 26,
+        "A4": 10,
+        "A5": 28,
+    },
+    "generic-bk7238-tuya": {
+        "SPI0_CS": 15,
+        "SPI0_MISO": 17,
+        "SPI0_MOSI": 16,
+        "SPI0_SCK": 14,
+        "WIRE2_SCL_0": 15,
+        "WIRE2_SCL_1": 24,
+        "WIRE2_SDA_0": 17,
+        "WIRE2_SDA_1": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC3": 20,
+        "ADC4": 28,
+        "ADC5": 1,
+        "ADC6": 10,
+        "CS": 15,
+        "MISO": 17,
+        "MOSI": 16,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P7": 7,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P14": 14,
+        "P15": 15,
+        "P16": 16,
+        "P17": 17,
+        "P20": 20,
+        "P21": 21,
+        "P22": 22,
+        "P23": 23,
+        "P24": 24,
+        "P26": 26,
+        "P28": 28,
+        "PWM0": 6,
+        "PWM1": 7,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCK": 14,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 0,
+        "D1": 1,
+        "D2": 6,
+        "D3": 7,
+        "D4": 8,
+        "D5": 9,
+        "D6": 10,
+        "D7": 11,
+        "D8": 14,
+        "D9": 15,
+        "D10": 16,
+        "D11": 17,
+        "D12": 20,
+        "D13": 21,
+        "D14": 22,
+        "D15": 23,
+        "D16": 24,
+        "D17": 26,
+        "D18": 28,
+        "A0": 1,
+        "A1": 10,
+        "A2": 20,
+        "A3": 24,
+        "A4": 26,
+        "A5": 28,
+    },
+    "t1-m": {
+        "WIRE2_SCL": 24,
+        "WIRE2_SDA": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC5": 1,
+        "ADC6": 10,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P24": 24,
+        "P26": 26,
+        "PWM0": 6,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCL2": 24,
+        "SDA2": 26,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 26,
+        "D1": 6,
+        "D2": 8,
+        "D3": 1,
+        "D4": 10,
+        "D5": 11,
+        "D6": 9,
+        "D7": 24,
+        "D11": 0,
+        "A0": 26,
+        "A1": 10,
+        "A2": 1,
+        "A3": 24,
+    },
    "generic-bk7231t-qfn32-tuya": {
        "SPI0_CS": 15,
        "SPI0_MISO": 17,
@@ -781,6 +1085,75 @@ BK72XX_BOARD_PINS = {
        "A6": 12,
        "A7": 13,
    },
+    "t1-3s": {
+        "SPI0_CS": 15,
+        "SPI0_MISO": 17,
+        "SPI0_MOSI": 16,
+        "SPI0_SCK": 14,
+        "WIRE2_SCL_0": 15,
+        "WIRE2_SCL_1": 24,
+        "WIRE2_SDA_0": 17,
+        "WIRE2_SDA_1": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC3": 20,
+        "ADC5": 1,
+        "ADC6": 10,
+        "CS": 15,
+        "MISO": 17,
+        "MOSI": 16,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P14": 14,
+        "P15": 15,
+        "P16": 16,
+        "P17": 17,
+        "P20": 20,
+        "P22": 22,
+        "P23": 23,
+        "P24": 24,
+        "P26": 26,
+        "PWM0": 6,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCK": 14,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 20,
+        "D1": 22,
+        "D2": 6,
+        "D3": 8,
+        "D4": 9,
+        "D5": 23,
+        "D6": 0,
+        "D7": 1,
+        "D8": 24,
+        "D9": 26,
+        "D10": 10,
+        "D11": 11,
+        "D12": 17,
+        "D13": 16,
+        "D14": 15,
+        "D15": 14,
+        "A0": 20,
+        "A1": 1,
+        "A2": 24,
+        "A3": 26,
+        "A4": 10,
+    },
    "wb2l": {
        "WIRE1_SCL": 20,
        "WIRE1_SDA": 21,
@@ -965,6 +1338,84 @@ BK72XX_BOARD_PINS = {
        "D10": 21,
        "A0": 23,
    },
+    "generic-bk7238": {
+        "SPI0_CS": 15,
+        "SPI0_MISO": 17,
+        "SPI0_MOSI": 16,
+        "SPI0_SCK": 14,
+        "WIRE2_SCL_0": 15,
+        "WIRE2_SCL_1": 24,
+        "WIRE2_SDA_0": 17,
+        "WIRE2_SDA_1": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC3": 20,
+        "ADC4": 28,
+        "ADC5": 1,
+        "ADC6": 10,
+        "CS": 15,
+        "MISO": 17,
+        "MOSI": 16,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P7": 7,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P14": 14,
+        "P15": 15,
+        "P16": 16,
+        "P17": 17,
+        "P20": 20,
+        "P21": 21,
+        "P22": 22,
+        "P23": 23,
+        "P24": 24,
+        "P26": 26,
+        "P28": 28,
+        "PWM0": 6,
+        "PWM1": 7,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCK": 14,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 0,
+        "D1": 1,
+        "D2": 6,
+        "D3": 7,
+        "D4": 8,
+        "D5": 9,
+        "D6": 10,
+        "D7": 11,
+        "D8": 14,
+        "D9": 15,
+        "D10": 16,
+        "D11": 17,
+        "D12": 20,
+        "D13": 21,
+        "D14": 22,
+        "D15": 23,
+        "D16": 24,
+        "D17": 26,
+        "D18": 28,
+        "A0": 1,
+        "A1": 10,
+        "A2": 20,
+        "A3": 24,
+        "A4": 26,
+        "A5": 28,
+    },
    "wa2": {
        "WIRE1_SCL": 20,
        "WIRE1_SDA": 21,
@@ -1235,6 +1686,51 @@ BK72XX_BOARD_PINS = {
        "D15": 1,
        "A0": 23,
    },
+    "t1-2s": {
+        "WIRE2_SCL": 24,
+        "WIRE2_SDA": 26,
+        "SERIAL1_RX": 10,
+        "SERIAL1_TX": 11,
+        "SERIAL2_RX": 1,
+        "SERIAL2_TX": 0,
+        "ADC1": 26,
+        "ADC2": 24,
+        "ADC5": 1,
+        "ADC6": 10,
+        "P0": 0,
+        "P1": 1,
+        "P6": 6,
+        "P8": 8,
+        "P9": 9,
+        "P10": 10,
+        "P11": 11,
+        "P24": 24,
+        "P26": 26,
+        "PWM0": 6,
+        "PWM2": 8,
+        "PWM3": 9,
+        "PWM4": 24,
+        "PWM5": 26,
+        "RX1": 10,
+        "RX2": 1,
+        "SCL2": 24,
+        "SDA2": 26,
+        "TX1": 11,
+        "TX2": 0,
+        "D0": 26,
+        "D1": 6,
+        "D2": 8,
+        "D3": 1,
+        "D4": 10,
+        "D5": 11,
+        "D6": 9,
+        "D7": 24,
+        "D11": 0,
+        "A0": 26,
+        "A1": 10,
+        "A2": 1,
+        "A3": 24,
+    },
    "wb2s": {
        "WIRE1_SCL": 20,
        "WIRE1_SDA": 21,
@@ -30,19 +30,6 @@ void BluetoothProxy::setup() {
  this->configured_scan_active_ = this->parent_->get_scan_active();

  this->parent_->add_scanner_state_listener(this);
-
-  this->set_interval(100, [this]() {
-    if (api::global_api_server->is_connected() && this->api_connection_ != nullptr) {
-      this->flush_pending_advertisements_();
-      return;
-    }
-    for (uint8_t i = 0; i < this->connection_count_; i++) {
-      auto *connection = this->connections_[i];
-      if (connection->get_address() != 0 && !connection->disconnect_pending()) {
-        connection->disconnect();
-      }
-    }
-  });
 }

 void BluetoothProxy::on_scanner_state(esp32_ble_tracker::ScannerState state) {
@@ -133,6 +120,25 @@ void BluetoothProxy::dump_config() {
                YESNO(this->active_), this->connection_count_);
 }

+void BluetoothProxy::loop() {
+  // Run advertisement flush / connection cleanup every 100ms
+  uint32_t now = App.get_loop_component_start_time();
+  if (now - this->last_advertisement_flush_time_ < 100)
+    return;
+  this->last_advertisement_flush_time_ = now;
+
+  if (api::global_api_server->is_connected() && this->api_connection_ != nullptr) {
+    this->flush_pending_advertisements_();
+    return;
+  }
+  for (uint8_t i = 0; i < this->connection_count_; i++) {
+    auto *connection = this->connections_[i];
+    if (connection->get_address() != 0 && !connection->disconnect_pending()) {
+      connection->disconnect();
+    }
+  }
+}
+
 esp32_ble_tracker::AdvertisementParserType BluetoothProxy::get_advertisement_parser_type() {
  return esp32_ble_tracker::AdvertisementParserType::RAW_ADVERTISEMENTS;
 }
@@ -201,7 +207,6 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
        connection->set_connection_type(espbt::ConnectionType::V3_WITHOUT_CACHE);
        this->log_connection_info_(connection, "v3 without cache");
      }
-      uint64_to_bd_addr(msg.address, connection->remote_bda_);
      connection->set_remote_addr_type(static_cast<esp_ble_addr_type_t>(msg.address_type));
      connection->set_state(espbt::ClientState::DISCOVERED);
      this->send_connections_free();
@@ -65,6 +65,7 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener,
  bool parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) override;
  void dump_config() override;
  void setup() override;
+  void loop() override;
  esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;

  void register_connection(BluetoothConnection *connection) {
@@ -176,6 +177,9 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener,
  // BLE advertisement batching
  api::BluetoothLERawAdvertisementsResponse response_;

+  // Group 3: 4-byte types
+  uint32_t last_advertisement_flush_time_{0};
+
  // Pre-allocated response message - always ready to send
  api::BluetoothConnectionsFreeResponse connections_free_response_;

@@ -78,43 +78,43 @@ void BME680Component::setup() {
  }

  // Read calibration
-  uint8_t cal1[25];
-  if (!this->read_bytes(BME680_REGISTER_COEFF1, cal1, 25)) {
+  uint8_t coeff1[25];
+  if (!this->read_bytes(BME680_REGISTER_COEFF1, coeff1, 25)) {
    this->mark_failed();
    return;
  }
-  uint8_t cal2[16];
-  if (!this->read_bytes(BME680_REGISTER_COEFF2, cal2, 16)) {
+  uint8_t coeff2[16];
+  if (!this->read_bytes(BME680_REGISTER_COEFF2, coeff2, 16)) {
    this->mark_failed();
    return;
  }

-  this->calibration_.t1 = cal2[9] << 8 | cal2[8];
-  this->calibration_.t2 = cal1[2] << 8 | cal1[1];
-  this->calibration_.t3 = cal1[3];
+  this->calibration_.t1 = coeff2[9] << 8 | coeff2[8];
+  this->calibration_.t2 = coeff1[2] << 8 | coeff1[1];
+  this->calibration_.t3 = coeff1[3];

-  this->calibration_.h1 = cal2[2] << 4 | (cal2[1] & 0x0F);
-  this->calibration_.h2 = cal2[0] << 4 | cal2[1] >> 4;
-  this->calibration_.h3 = cal2[3];
-  this->calibration_.h4 = cal2[4];
-  this->calibration_.h5 = cal2[5];
-  this->calibration_.h6 = cal2[6];
-  this->calibration_.h7 = cal2[7];
+  this->calibration_.h1 = coeff2[2] << 4 | (coeff2[1] & 0x0F);
+  this->calibration_.h2 = coeff2[0] << 4 | coeff2[1] >> 4;
+  this->calibration_.h3 = coeff2[3];
+  this->calibration_.h4 = coeff2[4];
+  this->calibration_.h5 = coeff2[5];
+  this->calibration_.h6 = coeff2[6];
+  this->calibration_.h7 = coeff2[7];

-  this->calibration_.p1 = cal1[6] << 8 | cal1[5];
-  this->calibration_.p2 = cal1[8] << 8 | cal1[7];
-  this->calibration_.p3 = cal1[9];
-  this->calibration_.p4 = cal1[12] << 8 | cal1[11];
-  this->calibration_.p5 = cal1[14] << 8 | cal1[13];
-  this->calibration_.p6 = cal1[16];
-  this->calibration_.p7 = cal1[15];
-  this->calibration_.p8 = cal1[20] << 8 | cal1[19];
-  this->calibration_.p9 = cal1[22] << 8 | cal1[21];
-  this->calibration_.p10 = cal1[23];
+  this->calibration_.p1 = coeff1[6] << 8 | coeff1[5];
+  this->calibration_.p2 = coeff1[8] << 8 | coeff1[7];
+  this->calibration_.p3 = coeff1[9];
+  this->calibration_.p4 = coeff1[12] << 8 | coeff1[11];
+  this->calibration_.p5 = coeff1[14] << 8 | coeff1[13];
+  this->calibration_.p6 = coeff1[16];
+  this->calibration_.p7 = coeff1[15];
+  this->calibration_.p8 = coeff1[20] << 8 | coeff1[19];
+  this->calibration_.p9 = coeff1[22] << 8 | coeff1[21];
+  this->calibration_.p10 = coeff1[23];

-  this->calibration_.gh1 = cal2[14];
-  this->calibration_.gh2 = cal2[12] << 8 | cal2[13];
-  this->calibration_.gh3 = cal2[15];
+  this->calibration_.gh1 = coeff2[14];
+  this->calibration_.gh2 = coeff2[12] << 8 | coeff2[13];
+  this->calibration_.gh3 = coeff2[15];

  uint8_t temp_var = 0;
  if (!this->read_byte(0x02, &temp_var)) {
@@ -19,6 +19,7 @@ from esphome.const import (
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
+    queue_entity_register,
    setup_device_class,
    setup_entity,
 )
@@ -101,7 +102,7 @@ async def setup_button_core_(var, config):
 async def register_button(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_button(var))
+    queue_entity_register("button", config)
    CORE.register_platform_component("button", var)
    await setup_button_core_(var, config)

@@ -48,9 +48,13 @@ from esphome.const import (
    CONF_VISUAL,
    CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
-from esphome.cpp_generator import MockObjClass
+from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
+from esphome.core.entity_helpers import (
+    entity_duplicate_validator,
+    queue_entity_register,
+    setup_entity,
+)
+from esphome.cpp_generator import LambdaExpression, MockObjClass

 IS_PLATFORM_COMPONENT = True

@@ -442,7 +446,7 @@ async def setup_climate_core_(var, config):
 async def register_climate(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_climate(var))
+    queue_entity_register("climate", config)
    CORE.register_platform_component("climate", var)
    await setup_climate_core_(var, config)

@@ -483,38 +487,57 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
 )
 async def climate_control_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    if (mode := config.get(CONF_MODE)) is not None:
-        template_ = await cg.templatable(mode, args, ClimateMode)
-        cg.add(var.set_mode(template_))
-    if (target_temp := config.get(CONF_TARGET_TEMPERATURE)) is not None:
-        template_ = await cg.templatable(target_temp, args, cg.float_)
-        cg.add(var.set_target_temperature(template_))
-    if (target_temp_low := config.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
-        template_ = await cg.templatable(target_temp_low, args, cg.float_)
-        cg.add(var.set_target_temperature_low(template_))
-    if (target_temp_high := config.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
-        template_ = await cg.templatable(target_temp_high, args, cg.float_)
-        cg.add(var.set_target_temperature_high(template_))
-    if (target_humidity := config.get(CONF_TARGET_HUMIDITY)) is not None:
-        template_ = await cg.templatable(target_humidity, args, cg.float_)
-        cg.add(var.set_target_humidity(template_))
-    if (fan_mode := config.get(CONF_FAN_MODE)) is not None:
-        template_ = await cg.templatable(fan_mode, args, ClimateFanMode)
-        cg.add(var.set_fan_mode(template_))
-    if (custom_fan_mode := config.get(CONF_CUSTOM_FAN_MODE)) is not None:
-        template_ = await cg.templatable(custom_fan_mode, args, cg.std_string)
-        cg.add(var.set_custom_fan_mode(template_))
-    if (preset := config.get(CONF_PRESET)) is not None:
-        template_ = await cg.templatable(preset, args, ClimatePreset)
-        cg.add(var.set_preset(template_))
-    if (custom_preset := config.get(CONF_CUSTOM_PRESET)) is not None:
-        template_ = await cg.templatable(custom_preset, args, cg.std_string)
-        cg.add(var.set_custom_preset(template_))
-    if (swing_mode := config.get(CONF_SWING_MODE)) is not None:
-        template_ = await cg.templatable(swing_mode, args, ClimateSwingMode)
-        cg.add(var.set_swing_mode(template_))
-    return var
+
+    # All configured fields are folded into a single stateless lambda whose
+    # constants live in flash; the action stores only a function pointer.
+    # For custom_fan_mode/custom_preset the static-string path emits the
+    # (const char *, size_t) overload of set_fan_mode/set_preset to avoid
+    # constructing a std::string and calling runtime strlen.
+    FIELDS = (
+        (CONF_MODE, "set_mode", ClimateMode),
+        (CONF_TARGET_TEMPERATURE, "set_target_temperature", cg.float_),
+        (CONF_TARGET_TEMPERATURE_LOW, "set_target_temperature_low", cg.float_),
+        (CONF_TARGET_TEMPERATURE_HIGH, "set_target_temperature_high", cg.float_),
+        (CONF_TARGET_HUMIDITY, "set_target_humidity", cg.float_),
+        (CONF_FAN_MODE, "set_fan_mode", ClimateFanMode),
+        (CONF_CUSTOM_FAN_MODE, "set_fan_mode", cg.std_string),
+        (CONF_PRESET, "set_preset", ClimatePreset),
+        (CONF_CUSTOM_PRESET, "set_preset", cg.std_string),
+        (CONF_SWING_MODE, "set_swing_mode", ClimateSwingMode),
+    )
+
+    fwd_args = ", ".join(name for _, name in args)
+    body_lines: list[str] = []
+
+    for conf_key, setter, type_ in FIELDS:
+        if (value := config.get(conf_key)) is None:
+            continue
+        if isinstance(value, Lambda):
+            inner = await cg.process_lambda(value, args, return_type=type_)
+            body_lines.append(f"call.{setter}(({inner})({fwd_args}));")
+        elif type_ is cg.std_string:
+            # Static custom strings: emit a flash literal and pass the
+            # UTF-8 byte length to skip the runtime strlen inside
+            # set_fan_mode/set_preset.
+            literal = cg.safe_exp(value)
+            body_lines.append(
+                f"call.{setter}({literal}, {len(value.encode('utf-8'))});"
+            )
+        else:
+            body_lines.append(f"call.{setter}({cg.safe_exp(value)});")
+
+    # Match ControlAction::ApplyFn signature: const Ts &... for trigger args.
+    apply_args = [
+        (ClimateCall.operator("ref"), "call"),
+        *((t.operator("const").operator("ref"), n) for t, n in args),
+    ]
+    apply_lambda = LambdaExpression(
+        ["\n".join(body_lines)],
+        apply_args,
+        capture="",
+        return_type=cg.void,
+    )
+    return cg.new_Pvariable(action_id, template_arg, paren, apply_lambda)


@coroutine_with_priority(CoroPriority.CORE)
@@ -5,42 +5,25 @@

 namespace esphome::climate {

+// All configured fields are baked into a single stateless lambda whose
+// constants live in flash. The action only stores one function pointer
+// plus one parent pointer, regardless of how many fields the user set.
+// Trigger args are forwarded to the apply function so user lambdas
+// (e.g. `target_temperature: !lambda "return x;"`) keep working.
 template<typename... Ts> class ControlAction : public Action<Ts...> {
 public:
-  explicit ControlAction(Climate *climate) : climate_(climate) {}
-
-  TEMPLATABLE_VALUE(ClimateMode, mode)
-  TEMPLATABLE_VALUE(float, target_temperature)
-  TEMPLATABLE_VALUE(float, target_temperature_low)
-  TEMPLATABLE_VALUE(float, target_temperature_high)
-  TEMPLATABLE_VALUE(float, target_humidity)
-  TEMPLATABLE_VALUE(bool, away)
-  TEMPLATABLE_VALUE(ClimateFanMode, fan_mode)
-  TEMPLATABLE_VALUE(std::string, custom_fan_mode)
-  TEMPLATABLE_VALUE(ClimatePreset, preset)
-  TEMPLATABLE_VALUE(std::string, custom_preset)
-  TEMPLATABLE_VALUE(ClimateSwingMode, swing_mode)
+  using ApplyFn = void (*)(ClimateCall &, const Ts &...);
+  ControlAction(Climate *climate, ApplyFn apply) : climate_(climate), apply_(apply) {}

  void play(const Ts &...x) override {
    auto call = this->climate_->make_call();
-    call.set_mode(this->mode_.optional_value(x...));
-    call.set_target_temperature(this->target_temperature_.optional_value(x...));
-    call.set_target_temperature_low(this->target_temperature_low_.optional_value(x...));
-    call.set_target_temperature_high(this->target_temperature_high_.optional_value(x...));
-    call.set_target_humidity(this->target_humidity_.optional_value(x...));
-    if (away_.has_value()) {
-      call.set_preset(away_.value(x...) ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME);
-    }
-    call.set_fan_mode(this->fan_mode_.optional_value(x...));
-    call.set_fan_mode(this->custom_fan_mode_.optional_value(x...));
-    call.set_preset(this->preset_.optional_value(x...));
-    call.set_preset(this->custom_preset_.optional_value(x...));
-    call.set_swing_mode(this->swing_mode_.optional_value(x...));
+    this->apply_(call, x...);
    call.perform();
  }

 protected:
  Climate *climate_;
+  ApplyFn apply_;
 };

 class ControlTrigger : public Trigger<ClimateCall &> {
@@ -374,7 +374,8 @@ void Climate::save_state_(const ClimateTraits &traits) {
 #define TEMP_IGNORE_MEMACCESS
 #endif
  ClimateDeviceRestoreState state{};
-  // initialize as zero to prevent random data on stack triggering erase
+  // initialize as zero (including padding) to prevent random data on stack triggering erase
+  // NOLINTNEXTLINE(bugprone-raw-memory-call-on-non-trivial-type) -- intentional bytewise zero for RTC save
  memset(&state, 0, sizeof(ClimateDeviceRestoreState));
 #ifdef TEMP_IGNORE_MEMACCESS
 #pragma GCC diagnostic pop
@@ -39,6 +39,7 @@ from esphome.const import (
 from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
+    queue_entity_register,
    setup_device_class,
    setup_entity,
 )
@@ -232,7 +233,7 @@ async def setup_cover_core_(var, config):
 async def register_cover(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_cover(var))
+    queue_entity_register("cover", config)
    CORE.register_platform_component("cover", var)
    await setup_cover_core_(var, config)

@@ -22,7 +22,11 @@ from esphome.const import (
    CONF_YEAR,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
+from esphome.core.entity_helpers import (
+    entity_duplicate_validator,
+    queue_entity_register,
+    setup_entity,
+)
 from esphome.cpp_generator import MockObjClass

 CODEOWNERS = ["@rfdarter", "@jesserockz"]
@@ -160,7 +164,7 @@ async def register_datetime(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
    entity_type = config[CONF_TYPE].lower()
-    cg.add(getattr(cg.App, f"register_{entity_type}")(var))
+    queue_entity_register(entity_type, config)
    CORE.register_platform_component(entity_type, var)
    await setup_datetime_core_(var, config)

@@ -17,11 +17,13 @@ constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR = 0xFFC;
 constexpr std::uintptr_t MBR_BOOTLOADER_ADDR = 0xFF8;

 static inline uint32_t read_mem_u32(uintptr_t addr) {
-  return *reinterpret_cast<volatile uint32_t *>(addr);  // NOLINT(performance-no-int-to-ptr)
+  // NOLINTNEXTLINE(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
+  return *reinterpret_cast<volatile uint32_t *>(addr);
 }

 static inline uint8_t read_mem_u8(uintptr_t addr) {
-  return *reinterpret_cast<volatile uint8_t *>(addr);  // NOLINT(performance-no-int-to-ptr)
+  // NOLINTNEXTLINE(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
+  return *reinterpret_cast<volatile uint8_t *>(addr);
 }

 // defines from https://github.com/adafruit/Adafruit_nRF52_Bootloader which prints those information
@@ -98,6 +100,7 @@ void DebugComponent::log_partition_info_() {
 #define NRF_PERIPH_ENABLED(periph, reg) \
  YESNO(((reg)->ENABLE & periph##_ENABLE_ENABLE_Msk) == (periph##_ENABLE_ENABLE_Enabled << periph##_ENABLE_ENABLE_Pos))

+// NOLINTBEGIN(clang-analyzer-core.FixedAddressDereference) -- nRF peripheral registers are MMIO at fixed addresses
 static void log_peripherals_info() {
  // most peripherals are enabled only when in use so ESP_LOGV is enough
  ESP_LOGV(TAG, "Peripherals status:");
@@ -131,6 +134,7 @@ static void log_peripherals_info() {
           YESNO((NRF_CRYPTOCELL->ENABLE & CRYPTOCELL_ENABLE_ENABLE_Msk) ==
                 (CRYPTOCELL_ENABLE_ENABLE_Enabled << CRYPTOCELL_ENABLE_ENABLE_Pos)));
 }
+// NOLINTEND(clang-analyzer-core.FixedAddressDereference)
 #undef NRF_PERIPH_ENABLED
 #endif

@@ -159,8 +163,9 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  char *buf = buffer.data();

  // Main supply status
-  const char *supply_status =
-      (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
+  // NOLINTNEXTLINE(clang-analyzer-core.FixedAddressDereference) -- NRF_POWER is MMIO at a fixed address
+  auto regstatus = nrf_power_mainregstatus_get(NRF_POWER);
+  const char *supply_status = (regstatus == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
  ESP_LOGD(TAG, "Main supply status: %s", supply_status);
  pos = buf_append_str(buf, size, pos, "|Main supply status: ");
  pos = buf_append_str(buf, size, pos, supply_status);
@@ -14,6 +14,7 @@ from esphome.components.esp32 import (
    VARIANT_ESP32S3,
    get_esp32_variant,
 )
+from esphome.components.zephyr import zephyr_add_prj_conf
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -33,6 +34,7 @@ from esphome.const import (
    PLATFORM_BK72XX,
    PLATFORM_ESP32,
    PLATFORM_ESP8266,
+    PLATFORM_NRF52,
    PlatformFramework,
 )
 from esphome.core import CORE
@@ -191,11 +193,14 @@ def _validate_ex1_wakeup_mode(value):


 def _validate_sleep_duration(value: core.TimePeriod) -> core.TimePeriod:
-    if not CORE.is_bk72xx:
-        return value
-    max_duration = core.TimePeriod(hours=36)
-    if value > max_duration:
-        raise cv.Invalid("sleep duration cannot be more than 36 hours on BK72XX")
+    if CORE.is_bk72xx:
+        max_duration = core.TimePeriod(hours=36)
+        if value > max_duration:
+            raise cv.Invalid("sleep duration cannot be more than 36 hours on BK72XX")
+    elif CORE.using_zephyr:
+        max_duration = core.TimePeriod(days=49)
+        if value > max_duration:
+            raise cv.Invalid("sleep duration cannot be more than 49 days on Zephyr")
    return value


@@ -304,7 +309,7 @@ CONFIG_SCHEMA = cv.All(
            ),
        }
    ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_BK72XX]),
+    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_BK72XX, PLATFORM_NRF52]),
    validate_config,
 )

@@ -369,6 +374,8 @@ async def to_code(config):

    if CONF_TOUCH_WAKEUP in config:
        cg.add(var.set_touch_wakeup(config[CONF_TOUCH_WAKEUP]))
+    if CORE.using_zephyr and "zigbee" not in CORE.loaded_integrations:
+        zephyr_add_prj_conf("POWEROFF", True)

    cg.add_define("USE_DEEP_SLEEP")

@@ -413,7 +420,7 @@ async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, paren)
    if CONF_SLEEP_DURATION in config:
-        template_ = await cg.templatable(config[CONF_SLEEP_DURATION], args, cg.int32)
+        template_ = await cg.templatable(config[CONF_SLEEP_DURATION], args, cg.uint32)
        cg.add(var.set_sleep_duration(template_))

    if CONF_UNTIL in config:
@@ -59,6 +59,8 @@ void DeepSleepComponent::deep_sleep_() {
  lt_deep_sleep_enter();
 }

+bool DeepSleepComponent::should_teardown_() { return true; }
+
 }  // namespace esphome::deep_sleep

 #endif  // USE_BK72XX
@@ -13,7 +13,11 @@ bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const

 void DeepSleepComponent::setup() {
  global_has_deep_sleep = true;
+  this->schedule_sleep_();
+}

+void DeepSleepComponent::schedule_sleep_() {
+  this->next_enter_deep_sleep_ = false;
  const optional<uint32_t> run_duration = get_run_duration_();
  if (run_duration.has_value()) {
    ESP_LOGI(TAG, "Scheduling in %" PRIu32 " ms", *run_duration);
@@ -58,13 +62,17 @@ void DeepSleepComponent::begin_sleep(bool manual) {
  if (this->sleep_duration_.has_value()) {
    ESP_LOGI(TAG, "Sleeping for %" PRId64 "us", *this->sleep_duration_);
  }
-  App.run_safe_shutdown_hooks();
-  // It's critical to teardown components cleanly for deep sleep to ensure
-  // Home Assistant sees a clean disconnect instead of marking the device unavailable
-  App.teardown_components(TEARDOWN_TIMEOUT_DEEP_SLEEP_MS);
-  App.run_powerdown_hooks();
+
+  if (this->should_teardown_()) {
+    App.run_safe_shutdown_hooks();
+    // It's critical to teardown components cleanly for deep sleep to ensure
+    // Home Assistant sees a clean disconnect instead of marking the device unavailable
+    App.teardown_components(TEARDOWN_TIMEOUT_DEEP_SLEEP_MS);
+    App.run_powerdown_hooks();
+  }

  this->deep_sleep_();
+  this->schedule_sleep_();
 }

 float DeepSleepComponent::get_setup_priority() const { return setup_priority::LATE; }
@@ -4,7 +4,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-
 #ifdef USE_ESP32
 #include <esp_sleep.h>
 #endif
@@ -129,6 +128,8 @@ class DeepSleepComponent : public Component {
  void dump_config_platform_();
  bool prepare_to_sleep_();
  void deep_sleep_();
+  void schedule_sleep_();
+  bool should_teardown_();

 #ifdef USE_BK72XX
  bool pin_prevents_sleep_(WakeUpPinItem &pinItem) const;
@@ -165,6 +165,8 @@ void DeepSleepComponent::deep_sleep_() {
  esp_deep_sleep_start();
 }

+bool DeepSleepComponent::should_teardown_() { return true; }
+
 }  // namespace deep_sleep
 }  // namespace esphome
 #endif  // USE_ESP32
@@ -18,6 +18,8 @@ void DeepSleepComponent::deep_sleep_() {
  ESP.deepSleep(this->sleep_duration_.value_or(0));  // NOLINT(readability-static-accessed-through-instance)
 }

+bool DeepSleepComponent::should_teardown_() { return true; }
+
 }  // namespace deep_sleep
 }  // namespace esphome
 #endif
@@ -0,0 +1,56 @@
+#include "deep_sleep_component.h"
+#ifdef USE_ZEPHYR
+#include "esphome/core/log.h"
+#include "esphome/core/wake.h"
+#include <zephyr/sys/poweroff.h>
+
+namespace esphome::deep_sleep {
+
+static const char *const TAG = "deep_sleep";
+
+optional<uint32_t> DeepSleepComponent::get_run_duration_() const { return this->run_duration_; }
+
+void DeepSleepComponent::dump_config_platform_() {}
+
+bool DeepSleepComponent::prepare_to_sleep_() { return true; }
+
+void DeepSleepComponent::deep_sleep_() {
+  if (this->sleep_duration_.has_value()) {
+    esphome::internal::wakeable_delay(static_cast<uint32_t>(*this->sleep_duration_ / 1000));
+  } else {
+#ifndef USE_ZIGBEE
+    // the device can be woken up through one of the following signals:
+    // - The DETECT signal, optionally generated by the GPIO peripheral.
+    // - The ANADETECT signal, optionally generated by the LPCOMP module.
+    // - The SENSE signal, optionally generated by the NFC module to wake-on-field.
+    // - Detecting a valid USB voltage on the VBUS pin (VBUS,DETECT).
+    // - A reset.
+    //
+    // The system is reset when it wakes up from System OFF mode.
+    sys_poweroff();
+#else
+    esphome::internal::wakeable_delay(UINT32_MAX);
+#endif
+  }
+  const bool woke = esphome::wake_request_take();
+  if (woke) {
+    ESP_LOGD(TAG, "Woken up by another thread");
+  } else {
+    ESP_LOGD(TAG, "Timeout expired (normal sleep)");
+  }
+}
+
+bool DeepSleepComponent::should_teardown_() {
+  if (this->sleep_duration_.has_value()) {
+    return false;
+  }
+#ifdef USE_ZIGBEE
+  return false;
+#else
+  return true;
+#endif
+}
+
+}  // namespace esphome::deep_sleep
+
+#endif
@@ -29,7 +29,7 @@ class DemoAlarmControlPanel : public AlarmControlPanel, public Component {
 protected:
  void control(const AlarmControlPanelCall &call) override {
    auto state = call.get_state().value_or(ACP_STATE_DISARMED);
-    auto code = call.get_code();
+    const auto &code = call.get_code();
    switch (state) {
      case ACP_STATE_ARMED_AWAY:
        if (this->get_requires_code_to_arm()) {
@@ -104,8 +104,9 @@ int8_t CircularCommandQueue::enqueue(std::unique_ptr<Command> cmd) {
  if (this->is_full()) {
    ESP_LOGE(TAG, "Command queue is full");
    return -1;
-  } else if (this->is_empty())
+  } else if (this->is_empty()) {
    front_++;
+  }
  rear_ = (rear_ + 1) % COMMAND_QUEUE_SIZE;
  commands_[rear_] = std::move(cmd);  // Transfer ownership using std::move
  return 1;
@@ -56,8 +56,7 @@ bool E131AddressableLightEffect::process_(int universe, const E131Packet &packet
  // limit amount of lights per universe and received
  // packet.count is the number of DMX bytes including start code; divide by channels to get the number of lights
  int lights_in_packet = (packet.count > 0) ? (packet.count - 1) / channels_ : 0;
-  int output_end =
-      std::min(it->size(), std::min(output_offset + get_lights_per_universe(), output_offset + lights_in_packet));
+  int output_end = std::min({it->size(), output_offset + get_lights_per_universe(), output_offset + lights_in_packet});
  auto *input_data = packet.values + 1;

  auto effect_name = get_name();
@@ -5,6 +5,15 @@
 // Implementation based on:
 //   https://github.com/sciosense/ENS160_driver

+// For best performance, the sensor shall be operated in normal indoor air in the range -5 to 60°C
+// (typical: 25°C); relative humidity: 20 to 80%RH (typical: 50%RH), non-condensing with no aggressive
+// or poisonous gases present. Prolonged exposure to environments outside these conditions can affect
+// performance and lifetime of the sensor.
+// The sensor is designed for indoor use and is not waterproof or dustproof. It should be protected from
+// water, condensation, dust, and aggressive gases. Note that the status will only be stored in non-volatile
+// memory after an initial 24 h of continuous operation. If unpowered before the conclusion of that period,
+// the ENS160 will resume "Initial Start-up" mode after re-powering.
+
 #include "ens160_base.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
@@ -14,7 +23,9 @@ namespace ens160_base {

 static const char *const TAG = "ens160";

-static const uint8_t ENS160_BOOTING = 10;
+// Datasheet specifies 10ms, but some users report that 10ms is not sufficient for the
+// sensor to boot and be ready for commands. 11ms seems to be a safe value.
+static const uint8_t ENS160_BOOTING = 11;

 static const uint16_t ENS160_PART_ID = 0x0160;

@@ -91,6 +102,8 @@ void ENS160Component::setup() {
    this->mark_failed();
    return;
  }
+  delay(ENS160_BOOTING);
+
  // clear command
  if (!this->write_byte(ENS160_REG_COMMAND, ENS160_COMMAND_NOP)) {
    this->error_code_ = WRITE_FAILED;
@@ -102,6 +115,7 @@ void ENS160Component::setup() {
    this->mark_failed();
    return;
  }
+  delay(ENS160_BOOTING);

  // read firmware version
  if (!this->write_byte(ENS160_REG_COMMAND, ENS160_COMMAND_GET_APPVER)) {
@@ -109,6 +123,8 @@ void ENS160Component::setup() {
    this->mark_failed();
    return;
  }
+  delay(ENS160_BOOTING);
+
  uint8_t version_data[3];
  if (!this->read_bytes(ENS160_REG_GPR_READ_4, version_data, 3)) {
    this->error_code_ = READ_FAILED;
@@ -223,7 +239,6 @@ void ENS160Component::update() {
  if (this->aqi_ != nullptr) {
    // remove reserved bits, just in case they are used in future
    data_aqi = ENS160_DATA_AQI & data_aqi;
-
    this->aqi_->publish_state(data_aqi);
  }

@@ -729,6 +729,9 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
    "dev": cv.Version(5, 5, 4),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
+    cv.Version(
+        6, 0, 1
+    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
    cv.Version(
        6, 0, 0
    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
@@ -1724,6 +1727,11 @@ async def to_code(config):
        CORE.relative_internal_path(".espressif")
    )

+    # Both ESP-IDF and ESP32 Arduino builds generate IDF app metadata. Keep
+    # volatile build path/time data out of the binary so equivalent projects can
+    # produce reproducible outputs and downstream tooling can reuse artifacts.
+    add_idf_sdkconfig_option("CONFIG_APP_REPRODUCIBLE_BUILD", True)
+
    if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
        cg.add_build_flag("-DUSE_ESP_IDF")
        cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
@@ -1745,7 +1753,17 @@ async def to_code(config):

        # Wrap FILE*-based printf functions to eliminate newlib's _vfprintf_r
        # (~11 KB). See printf_stubs.cpp for implementation.
-        if conf[CONF_ADVANCED][CONF_ENABLE_FULL_PRINTF]:
+        #
+        # The wrap is only beneficial against newlib. Picolibc's tinystdio
+        # implements vsnprintf by building a string-output FILE and calling
+        # vfprintf, so vfprintf is unconditionally linked in by any caller
+        # of snprintf/vsnprintf — effectively every build — and the wrap
+        # saves nothing while costing ~170 B of shim. IDF 5.x defaults to
+        # newlib on every variant; IDF 6.0+ switches to picolibc on every
+        # variant.
+        if conf[CONF_ADVANCED][CONF_ENABLE_FULL_PRINTF] or idf_version() >= cv.Version(
+            6, 0, 0
+        ):
            cg.add_define("USE_FULL_PRINTF")
        else:
            for symbol in ("vprintf", "printf", "fprintf", "vfprintf"):
@@ -1,17 +1,8 @@
 #ifdef USE_ESP32

-#include "esphome/core/defines.h"
-#include "crash_handler.h"
 #include "esphome/core/application.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
+#include "esphome/core/defines.h"
 #include "preferences.h"
-#include <esp_clk_tree.h>
-#include <esp_cpu.h>
-#include <esp_idf_version.h>
-#include <esp_ota_ops.h>
-#include <esp_task_wdt.h>
-#include <esp_timer.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>

@@ -22,63 +13,7 @@ extern "C" __attribute__((weak)) void initArduino() {}

 namespace esphome {

-void HOT yield() { vPortYield(); }
-// Use xTaskGetTickCount() when tick rate is 1 kHz (ESPHome's default via sdkconfig),
-// falling back to esp_timer for non-standard rates. IRAM_ATTR is required because
-// Wiegand and ZyAura call millis() from IRAM_ATTR ISR handlers on ESP32.
-// xTaskGetTickCountFromISR() is used in ISR context to satisfy the FreeRTOS API contract.
-uint32_t IRAM_ATTR HOT millis() {
-#if CONFIG_FREERTOS_HZ == 1000
-  if (xPortInIsrContext()) [[unlikely]] {
-    return xTaskGetTickCountFromISR();
-  }
-  return xTaskGetTickCount();
-#else
-  return micros_to_millis(static_cast<uint64_t>(esp_timer_get_time()));
-#endif
-}
-// millis_64() stays on esp_timer — a different clock from xTaskGetTickCount(). This is
-// safe because the two are never cross-compared: millis() values are only used for
-// millis()-vs-millis() deltas (feed_wdt, warn_blocking, component start time), while
-// millis_64() is used by the Scheduler and uptime sensors. On ESP32 (USE_NATIVE_64BIT_TIME),
-// Scheduler::millis_64_from_(now) discards the 32-bit now and calls millis_64() directly,
-// so the Scheduler is internally consistent on the esp_timer clock.
-uint64_t HOT millis_64() { return micros_to_millis<uint64_t>(static_cast<uint64_t>(esp_timer_get_time())); }
-void HOT delay(uint32_t ms) { vTaskDelay(ms / portTICK_PERIOD_MS); }
-uint32_t IRAM_ATTR HOT micros() { return (uint32_t) esp_timer_get_time(); }
-void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
-void arch_restart() {
-  esp_restart();
-  // restart() doesn't always end execution
-  while (true) {  // NOLINT(clang-diagnostic-unreachable-code)
-    yield();
-  }
-}
-
-void arch_init() {
-#ifdef USE_ESP32_CRASH_HANDLER
-  // Read crash data from previous boot before anything else
-  esp32::crash_handler_read_and_clear();
-#endif
-
-  // Enable the task watchdog only on the loop task (from which we're currently running)
-  esp_task_wdt_add(nullptr);
-
-  // Handle OTA rollback: mark partition valid immediately unless USE_OTA_ROLLBACK is enabled,
-  // in which case safe_mode will mark it valid after confirming successful boot.
-#ifndef USE_OTA_ROLLBACK
-  esp_ota_mark_app_valid_cancel_rollback();
-#endif
-}
-void HOT arch_feed_wdt() { esp_task_wdt_reset(); }
-
-uint32_t arch_get_cpu_cycle_count() { return esp_cpu_get_cycle_count(); }
-uint32_t arch_get_cpu_freq_hz() {
-  uint32_t freq = 0;
-  esp_clk_tree_src_get_freq_hz(SOC_MOD_CLK_CPU, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq);
-  return freq;
-}
-
+// HAL functions live in hal.cpp. This file keeps only the loop task setup.
 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
@@ -0,0 +1,71 @@
+#ifdef USE_ESP32
+
+// defines.h must come before crash_handler.h so USE_ESP32_CRASH_HANDLER is set
+// before crash_handler.h's #ifdef-guarded namespace block is parsed.
+#include "esphome/core/defines.h"
+#include "crash_handler.h"
+#include "esphome/core/hal.h"
+
+#include <esp_clk_tree.h>
+#include <esp_ota_ops.h>
+#include <esp_system.h>
+#include <esp_task_wdt.h>
+#include <esp_timer.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+// Empty esp32 namespace block to satisfy ci-custom's lint_namespace check.
+// HAL functions live in namespace esphome (root) — they are not part of the
+// esp32 component's API.
+namespace esphome::esp32 {}  // namespace esphome::esp32
+
+namespace esphome {
+
+// Use xTaskGetTickCount() when tick rate is 1 kHz (ESPHome's default via sdkconfig),
+// falling back to esp_timer for non-standard rates. IRAM_ATTR is required because
+// Wiegand and ZyAura call millis() from IRAM_ATTR ISR handlers on ESP32.
+// xTaskGetTickCountFromISR() is used in ISR context to satisfy the FreeRTOS API contract.
+uint32_t IRAM_ATTR HOT millis() {
+#if CONFIG_FREERTOS_HZ == 1000
+  if (xPortInIsrContext()) [[unlikely]] {
+    return xTaskGetTickCountFromISR();
+  }
+  return xTaskGetTickCount();
+#else
+  return micros_to_millis(static_cast<uint64_t>(esp_timer_get_time()));
+#endif
+}
+
+void arch_restart() {
+  esp_restart();
+  // restart() doesn't always end execution
+  while (true) {  // NOLINT(clang-diagnostic-unreachable-code)
+    yield();
+  }
+}
+
+void arch_init() {
+#ifdef USE_ESP32_CRASH_HANDLER
+  // Read crash data from previous boot before anything else
+  esp32::crash_handler_read_and_clear();
+#endif
+
+  // Enable the task watchdog only on the loop task (from which we're currently running)
+  esp_task_wdt_add(nullptr);
+
+  // Handle OTA rollback: mark partition valid immediately unless USE_OTA_ROLLBACK is enabled,
+  // in which case safe_mode will mark it valid after confirming successful boot.
+#ifndef USE_OTA_ROLLBACK
+  esp_ota_mark_app_valid_cancel_rollback();
+#endif
+}
+
+uint32_t arch_get_cpu_freq_hz() {
+  uint32_t freq = 0;
+  esp_clk_tree_src_get_freq_hz(SOC_MOD_CLK_CPU, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq);
+  return freq;
+}
+
+}  // namespace esphome
+
+#endif  // USE_ESP32
@@ -0,0 +1,52 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <cstdint>
+#include <esp_attr.h>
+#include <esp_cpu.h>
+#include <esp_task_wdt.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include "esphome/core/time_conversion.h"
+
+#ifndef PROGMEM
+#define PROGMEM
+#endif
+
+namespace esphome::esp32 {}
+
+namespace esphome {
+
+// Forward decl from helpers.h (esphome/core/helpers.h) — kept here so this
+// header does not need to pull the rest of helpers.h.
+// NOLINTNEXTLINE(readability-redundant-declaration)
+void delay_microseconds_safe(uint32_t us);
+
+/// Returns true when executing inside an interrupt handler.
+__attribute__((always_inline)) inline bool in_isr_context() { return xPortInIsrContext() != 0; }
+
+// Forward decl from <esp_timer.h>.
+// NOLINTNEXTLINE(readability-redundant-declaration)
+extern "C" int64_t esp_timer_get_time(void);
+
+__attribute__((always_inline)) inline void yield() { vPortYield(); }
+__attribute__((always_inline)) inline void delay(uint32_t ms) { vTaskDelay(ms / portTICK_PERIOD_MS); }
+__attribute__((always_inline)) inline uint32_t micros() { return static_cast<uint32_t>(esp_timer_get_time()); }
+uint32_t millis();
+__attribute__((always_inline)) inline uint64_t millis_64() {
+  return micros_to_millis<uint64_t>(static_cast<uint64_t>(esp_timer_get_time()));
+}
+
+// NOLINTNEXTLINE(readability-identifier-naming)
+__attribute__((always_inline)) inline void delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
+__attribute__((always_inline)) inline void arch_feed_wdt() { esp_task_wdt_reset(); }
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_cycle_count() { return esp_cpu_get_cycle_count(); }
+
+void arch_init();
+uint32_t arch_get_cpu_freq_hz();
+
+}  // namespace esphome
+
+#endif  // USE_ESP32
@@ -18,6 +18,12 @@ struct NVSData {

 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

+// open() runs from app_main() before the logger is initialized, so any failure
+// must be deferred until after global_logger is set. This is emitted from the
+// first make_preference() call, which runs from the generated setup() after
+// log->pre_setup() has run at EARLY_INIT priority.
+static esp_err_t s_open_err = ESP_OK;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 bool ESP32PreferenceBackend::save(const uint8_t *data, size_t len) {
  // try find in pending saves and update that
  for (auto &obj : s_pending_save) {
@@ -70,12 +76,14 @@ bool ESP32PreferenceBackend::load(uint8_t *data, size_t len) {
 }

 void ESP32Preferences::open() {
+  // Runs from app_main() before the logger is initialized; any logging here
+  // must be deferred. See s_open_err and make_preference() below.
  nvs_flash_init();
  esp_err_t err = nvs_open("esphome", NVS_READWRITE, &this->nvs_handle);
  if (err == 0)
    return;

-  ESP_LOGW(TAG, "nvs_open failed: %s - erasing NVS", esp_err_to_name(err));
+  s_open_err = err;
  nvs_flash_deinit();
  nvs_flash_erase();
  nvs_flash_init();
@@ -87,6 +95,14 @@ void ESP32Preferences::open() {
 }

 ESPPreferenceObject ESP32Preferences::make_preference(size_t length, uint32_t type) {
+  if (s_open_err != ESP_OK) {
+    if (this->nvs_handle == 0) {
+      ESP_LOGW(TAG, "nvs_open failed: %s - NVS unavailable", esp_err_to_name(s_open_err));
+    } else {
+      ESP_LOGW(TAG, "nvs_open failed: %s - erased NVS", esp_err_to_name(s_open_err));
+    }
+    s_open_err = ESP_OK;
+  }
  auto *pref = new ESP32PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
  pref->nvs_handle = this->nvs_handle;
  pref->key = type;
@@ -1,32 +1,38 @@
 /*
- * Linker wrap stubs for FILE*-based printf functions.
+ * Linker wrap stubs for FILE*-based printf functions (newlib only).
 *
 * ESP-IDF SDK components (gpio driver, ringbuf, log_write) reference
- * fprintf(), printf(), vprintf(), and vfprintf() which pull in the full
- * printf implementation (~11 KB on newlib's _vfprintf_r, ~2.8 KB on
- * picolibc's vfprintf). This is a separate implementation from the one
- * used by snprintf/vsnprintf that handles FILE* stream I/O with buffering
- * and locking.
+ * fprintf(), printf(), vprintf(), and vfprintf(), which on newlib pull
+ * in _vfprintf_r (~11 KB) — a separate implementation from the one used
+ * by snprintf/vsnprintf that handles FILE* stream I/O with buffering.
 *
 * ESPHome replaces the ESP-IDF log handler via esp_log_set_vprintf_(),
 * so the SDK's vprintf() path is dead code at runtime. The fprintf()
 * and printf() calls in SDK components are only in debug/assert paths
 * (gpio_dump_io_configuration, ringbuf diagnostics) that are either
 * GC'd or never called. Crash backtraces and panic output are
- * unaffected — they use esp_rom_printf() which is a ROM function
- * and does not go through libc.
+ * unaffected; they use esp_rom_printf() which is a ROM function and
+ * does not go through libc.
 *
- * These stubs redirect through vsnprintf() (which uses _svfprintf_r
- * already in the binary) and fwrite(), allowing the linker to
- * dead-code eliminate _vfprintf_r.
+ * This wrap is newlib-only. On picolibc, vsnprintf is implemented as
+ * vfprintf into a string-output FILE, so vfprintf is unconditionally
+ * linked in by any caller of snprintf/vsnprintf and the wrap can never
+ * elide it — it just adds shim cost. Codegen forces USE_FULL_PRINTF
+ * on picolibc builds (IDF 6.0+ on all variants) so this file compiles
+ * to nothing there; the #error below catches a desynchronised gate.
 *
- * Saves ~11 KB of flash.
+ * Saves ~11 KB of flash on newlib.
 *
- * To disable these wraps, set enable_full_printf: true in the esp32
- * advanced config section.
+ * To disable this wrap on newlib, set enable_full_printf: true in the
+ * esp32 advanced config section.
 */

 #if defined(USE_ESP_IDF) && !defined(USE_FULL_PRINTF)
+
+#ifdef __PICOLIBC__
+#error "printf wrap is net-negative on picolibc; codegen should set USE_FULL_PRINTF"
+#endif
+
 #include <cstdarg>
 #include <cstdio>

@@ -34,6 +40,9 @@

 namespace esphome::esp32 {}

+// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+extern "C" {
+
 static constexpr size_t PRINTF_BUFFER_SIZE = 512;

 // These stubs are essentially dead code at runtime — ESPHome replaces the
@@ -55,14 +64,16 @@ static int write_printf_buffer(FILE *stream, char *buf, int len) {
  return len;
 }

-// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-extern "C" {
-
 int __wrap_vprintf(const char *fmt, va_list ap) {
  char buf[PRINTF_BUFFER_SIZE];
  return write_printf_buffer(stdout, buf, vsnprintf(buf, sizeof(buf), fmt, ap));
 }

+int __wrap_vfprintf(FILE *stream, const char *fmt, va_list ap) {
+  char buf[PRINTF_BUFFER_SIZE];
+  return write_printf_buffer(stream, buf, vsnprintf(buf, sizeof(buf), fmt, ap));
+}
+
 int __wrap_printf(const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
@@ -71,11 +82,6 @@ int __wrap_printf(const char *fmt, ...) {
  return len;
 }

-int __wrap_vfprintf(FILE *stream, const char *fmt, va_list ap) {
-  char buf[PRINTF_BUFFER_SIZE];
-  return write_printf_buffer(stream, buf, vsnprintf(buf, sizeof(buf), fmt, ap));
-}
-
 int __wrap_fprintf(FILE *stream, const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
@@ -104,7 +104,7 @@ ESPBTUUID ESPBTUUID::as_128bit() const {
  } else {
    uuid32 = this->uuid_.uuid.uuid16;
  }
-  for (uint8_t i = 0; i < this->uuid_.len; i++) {
+  for (uint16_t i = 0; i < this->uuid_.len; i++) {
    data[12 + i] = ((uuid32 >> i * 8) & 0xFF);
  }
  return ESPBTUUID::from_raw(data);
@@ -166,8 +166,9 @@ void ESP32BLETracker::loop() {
  ClientStateCounts counts = this->count_client_states_();
  if (counts != this->client_state_counts_) {
    this->client_state_counts_ = counts;
-    ESP_LOGD(TAG, "connecting: %d, discovered: %d, disconnecting: %d", this->client_state_counts_.connecting,
-             this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
+    ESP_LOGD(TAG, "connecting: %d, discovered: %d, disconnecting: %d, active: %d",
+             this->client_state_counts_.connecting, this->client_state_counts_.discovered,
+             this->client_state_counts_.disconnecting, this->client_state_counts_.active);
  }

  // Scanner failure: reached when set_scanner_state_(FAILED) or scan_set_param_failed_ set
@@ -190,10 +191,18 @@ void ESP32BLETracker::loop() {
  */

  // Start scan: reached when scanner_state_ becomes IDLE (via set_scanner_state_()) and
-  // all clients are idle (their state changes increment version when they finish)
+  // no clients are in the transient CONNECTING / DISCOVERED / DISCONNECTING states
+  // (their state changes increment version when they finish). CONNECTED / ESTABLISHED
+  // clients do NOT block this branch — the coex revert below has its own active-count gate.
  if (this->scanner_state_ == ScannerState::IDLE && !counts.connecting && !counts.disconnecting && !counts.discovered) {
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
-    this->update_coex_preference_(false);
+    // Only revert to BALANCE when no connections are active. Established connections
+    // continue to need PREFER_BT so peer GATT responses can reach us while WiFi traffic
+    // (advertisement upload, log streaming) competes for the shared radio. Reverting too
+    // early causes Bluedroid to time out at ~20s and synthesize status=133.
+    if (!counts.active) {
+      this->update_coex_preference_(false);
+    }
 #endif
    if (this->scan_continuous_) {
      this->start_scan_(false);  // first = false
@@ -701,9 +710,10 @@ void ESP32BLETracker::dump_config() {
                this->scan_active_ ? "ACTIVE" : "PASSIVE", YESNO(this->scan_continuous_));
  ESP_LOGCONFIG(TAG,
                "  Scanner State: %s\n"
-                "  Connecting: %d, discovered: %d, disconnecting: %d",
+                "  Connecting: %d, discovered: %d, disconnecting: %d, active: %d",
                this->scanner_state_to_string_(this->scanner_state_), this->client_state_counts_.connecting,
-                this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
+                this->client_state_counts_.discovered, this->client_state_counts_.disconnecting,
+                this->client_state_counts_.active);
  if (this->scan_start_fail_count_) {
    ESP_LOGCONFIG(TAG, "  Scan Start Fail Count: %d", this->scan_start_fail_count_);
  }
@@ -160,9 +160,13 @@ struct ClientStateCounts {
  uint8_t connecting = 0;
  uint8_t discovered = 0;
  uint8_t disconnecting = 0;
+  // CONNECTED + ESTABLISHED clients. Tracked so coex stays at PREFER_BT
+  // while active connections may still need to send/receive GATT traffic.
+  uint8_t active = 0;

  bool operator==(const ClientStateCounts &other) const {
-    return connecting == other.connecting && discovered == other.discovered && disconnecting == other.disconnecting;
+    return connecting == other.connecting && discovered == other.discovered && disconnecting == other.disconnecting &&
+           active == other.active;
  }

  bool operator!=(const ClientStateCounts &other) const { return !(*this == other); }
@@ -381,6 +385,10 @@ class ESP32BLETracker : public Component,
        case ClientState::CONNECTING:
          counts.connecting++;
          break;
+        case ClientState::CONNECTED:
+        case ClientState::ESTABLISHED:
+          counts.active++;
+          break;
        default:
          break;
      }
@@ -246,9 +246,10 @@ async def to_code(config):
    idf_ver = esp32.idf_version()
    os.environ["ESP_IDF_VERSION"] = f"{idf_ver.major}.{idf_ver.minor}"
    if idf_ver >= cv.Version(5, 5, 0):
-        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.4.0")
-        esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.4")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.1")
+        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.5.1")
+        esp32.add_idf_component(name="espressif/wifi_remote_over_eppp", ref="0.3.2")
+        esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.5")
+        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.6")
    else:
        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.13.0")
        esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")
@@ -216,6 +216,7 @@ void ESP32TouchComponent::setup() {
  // Do initial oneshot scans to populate baseline values
  for (uint32_t i = 0; i < ONESHOT_SCAN_COUNT; i++) {
    err = touch_sensor_trigger_oneshot_scanning(this->sens_handle_, ONESHOT_SCAN_TIMEOUT_MS);
+    App.feed_wdt();  // 3 scans with 2s timeout might exceed WDT, so feed it here to be safe
    if (err != ESP_OK) {
      ESP_LOGW(TAG, "Oneshot scan %" PRIu32 " failed: %s", i, esp_err_to_name(err));
    }
@@ -314,6 +314,11 @@ async def to_code(config):
        for symbol in ("vprintf", "printf", "fprintf"):
            cg.add_build_flag(f"-Wl,--wrap={symbol}")

+    # Wrap Arduino's millis() so all callers (including Arduino libraries and ISR
+    # handlers) use our fast accumulator instead of the expensive 4x 64-bit multiply
+    # implementation in the Arduino ESP8266 core.
+    cg.add_build_flag("-Wl,--wrap=millis")
+
    cg.add_platformio_option("board_build.flash_mode", config[CONF_BOARD_FLASH_MODE])

    ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
@@ -3,45 +3,12 @@
 #include "core.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/time_64.h"
-#include "esphome/core/helpers.h"
-#include "preferences.h"
 #include <Arduino.h>
-#include <core_esp8266_features.h>
-
-extern "C" {
-#include <user_interface.h>
-}

 namespace esphome {

-void HOT yield() { ::yield(); }
-uint32_t IRAM_ATTR HOT millis() { return ::millis(); }
-uint64_t millis_64() { return Millis64Impl::compute(::millis()); }
-void HOT delay(uint32_t ms) { ::delay(ms); }
-uint32_t IRAM_ATTR HOT micros() { return ::micros(); }
-void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
-void arch_restart() {
-  system_restart();
-  // restart() doesn't always end execution
-  while (true) {  // NOLINT(clang-diagnostic-unreachable-code)
-    yield();
-  }
-}
-void arch_init() {}
-void HOT arch_feed_wdt() { system_soft_wdt_feed(); }
-
-uint8_t progmem_read_byte(const uint8_t *addr) {
-  return pgm_read_byte(addr);  // NOLINT
-}
-const char *progmem_read_ptr(const char *const *addr) {
-  return reinterpret_cast<const char *>(pgm_read_ptr(addr));  // NOLINT
-}
-uint16_t progmem_read_uint16(const uint16_t *addr) {
-  return pgm_read_word(addr);  // NOLINT
-}
-uint32_t IRAM_ATTR HOT arch_get_cpu_cycle_count() { return esp_get_cycle_count(); }
-uint32_t arch_get_cpu_freq_hz() { return F_CPU; }
+// HAL functions live in hal.cpp. This file keeps only the ESP8266-specific
+// firmware bootstrap (Tasmota OTA magic bytes, optional GPIO pre-init).

 void force_link_symbols() {
  // Tasmota uses magic bytes in the binary to check if an OTA firmware is compatible
@@ -140,6 +140,7 @@ void IRAM_ATTR ISRInternalGPIOPin::digital_write(bool value) {

 void IRAM_ATTR ISRInternalGPIOPin::clear_interrupt() {
  auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
+  // NOLINTNEXTLINE(clang-analyzer-core.FixedAddressDereference) -- GPIO_REG_WRITE is MMIO at a fixed address
  GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1UL << arg->pin);
 }

@@ -0,0 +1,111 @@
+#ifdef USE_ESP8266
+
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+
+#include <Arduino.h>
+#include <core_esp8266_features.h>
+
+extern "C" {
+#include <user_interface.h>
+}
+
+// Empty esp8266 namespace block to satisfy ci-custom's lint_namespace check.
+// HAL functions live in namespace esphome (root) — they are not part of the
+// esp8266 component's API.
+namespace esphome::esp8266 {}  // namespace esphome::esp8266
+
+namespace esphome {
+
+// yield(), micros(), millis_64(), delayMicroseconds(), arch_feed_wdt(),
+// progmem_read_*() are inlined in components/esp8266/hal.h.
+//
+// Fast accumulator replacement for Arduino's millis() (~3.3 μs via 4× 64-bit
+// multiplies on the LX106). Tracks a running ms counter from 32-bit
+// system_get_time() deltas using pure 32-bit ops. Installed as __wrap_millis
+// (via -Wl,--wrap=millis) so Arduino libs and IRAM_ATTR ISR handlers (e.g.
+// Wiegand, ZyAura) also get the fast version. xt_rsil(15) guards the static
+// state against ISR re-entry; the critical section is bounded (≤10 while-loop
+// iterations, ~100 ns on the common path, or a constant-time /1000 ~2.5 μs on
+// the rare path — well under WiFi's ~10 μs ISR latency budget). NMIs (level
+// >15) are not masked, but the ESP8266 SDK's NMI handlers don't call millis().
+//
+// system_get_time() wraps every ~71.6 min; unsigned (now_us - last_us) handles
+// one wrap. The main loop calls millis() at 60+ Hz, so delta stays tiny — a
+// >71 min block would trip the watchdog long before it could matter here.
+static constexpr uint32_t MILLIS_RARE_PATH_THRESHOLD_US = 10000;
+static constexpr uint32_t US_PER_MS = 1000;
+
+uint32_t IRAM_ATTR HOT millis() {
+  // Struct packs the three statics so the compiler loads one base address
+  // instead of three separate literal pool entries (saves ~8 bytes IRAM).
+  static struct {
+    uint32_t cache;
+    uint32_t remainder;
+    uint32_t last_us;
+  } state = {0, 0, 0};
+  uint32_t ps = xt_rsil(15);
+  uint32_t now_us = system_get_time();
+  uint32_t delta = now_us - state.last_us;
+  state.last_us = now_us;
+  state.remainder += delta;
+  if (state.remainder >= MILLIS_RARE_PATH_THRESHOLD_US) {
+    // Rare path: large gap (WiFi scan, boot, long block). Constant-time
+    // conversion keeps the critical section bounded.
+    uint32_t ms = state.remainder / US_PER_MS;
+    state.cache += ms;
+    // Reuse ms instead of `remainder %= US_PER_MS` — `%` would compile to a
+    // second __umodsi3 call on the LX106 (no hardware divide).
+    state.remainder -= ms * US_PER_MS;
+  } else {
+    // Common path: small gap. At most ~10 iterations since remainder was
+    // < threshold (10 ms) on entry and delta adds at most one more threshold
+    // before exiting this branch.
+    while (state.remainder >= US_PER_MS) {
+      state.cache++;
+      state.remainder -= US_PER_MS;
+    }
+  }
+  uint32_t result = state.cache;
+  xt_wsr_ps(ps);
+  return result;
+}
+
+// Poll-based delay that avoids ::delay() — Arduino's __delay has an intra-object
+// call to the original millis() that --wrap can't intercept, so calling ::delay()
+// would keep the slow Arduino millis body alive in IRAM. optimistic_yield still
+// enters esp_schedule()/esp_suspend_within_cont() via yield(), so SDK tasks and
+// WiFi run correctly. Theoretically less power-efficient than Arduino's
+// os_timer-based delay() for long waits, but nearly all ESPHome delays are short
+// (sensor/I²C/SPI settling in the 1–100 ms range) where the difference is
+// negligible.
+void HOT delay(uint32_t ms) {
+  if (ms == 0) {
+    optimistic_yield(1000);
+    return;
+  }
+  uint32_t start = millis();
+  while (millis() - start < ms) {
+    optimistic_yield(1000);
+  }
+}
+
+void arch_restart() {
+  system_restart();
+  // restart() doesn't always end execution
+  while (true) {  // NOLINT(clang-diagnostic-unreachable-code)
+    yield();
+  }
+}
+
+}  // namespace esphome
+
+// Linker wrap: redirect all ::millis() calls (Arduino libs, ISRs) to our accumulator.
+// Requires -Wl,--wrap=millis in build flags (added by __init__.py).
+// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+extern "C" uint32_t IRAM_ATTR __wrap_millis() { return esphome::millis(); }
+// Note: Arduino's init() registers a 60-second overflow timer for micros64().
+// We leave it running — wrapping init() as a no-op would break micros64()'s
+// overflow tracking, and the timer's cost is negligible (~3 μs per 60 s).
+
+#endif  // USE_ESP8266
@@ -0,0 +1,73 @@
+#pragma once
+
+#ifdef USE_ESP8266
+
+#include <c_types.h>
+#include <core_esp8266_features.h>
+#include <cstdint>
+#include <pgmspace.h>
+
+#include "esphome/core/time_64.h"
+
+#ifndef PROGMEM
+#define PROGMEM ICACHE_RODATA_ATTR
+#endif
+
+// Forward decls from Arduino's <Arduino.h> for the inline wrappers below.
+// NOLINTBEGIN(google-runtime-int,readability-identifier-naming,readability-redundant-declaration)
+extern "C" void yield(void);
+extern "C" void delay(unsigned long ms);
+extern "C" unsigned long micros(void);
+extern "C" unsigned long millis(void);
+// NOLINTEND(google-runtime-int,readability-identifier-naming,readability-redundant-declaration)
+
+// Forward decl from <user_interface.h> for arch_feed_wdt() inline below.
+// NOLINTNEXTLINE(readability-redundant-declaration)
+extern "C" void system_soft_wdt_feed(void);
+
+namespace esphome::esp8266 {}
+
+namespace esphome {
+
+// Forward decl from helpers.h so this header stays cheap.
+// NOLINTNEXTLINE(readability-redundant-declaration)
+void delay_microseconds_safe(uint32_t us);
+
+/// Returns true when executing inside an interrupt handler.
+/// ESP8266 has no reliable single-register ISR detection: PS.INTLEVEL is
+/// non-zero both in a real ISR and when user code masks interrupts.  The
+/// ESP8266 wake path is context-agnostic (wake_loop_impl uses esp_schedule
+/// which is ISR-safe) so this helper is unused on this platform.
+__attribute__((always_inline)) inline bool in_isr_context() { return false; }
+
+__attribute__((always_inline)) inline void yield() { ::yield(); }
+__attribute__((always_inline)) inline uint32_t micros() { return static_cast<uint32_t>(::micros()); }
+void delay(uint32_t ms);
+uint32_t millis();
+__attribute__((always_inline)) inline uint64_t millis_64() { return Millis64Impl::compute(millis()); }
+
+// ESP8266: pgm_read_* does aligned 32-bit flash reads on Harvard architecture.
+// Inline-forward to the platform macros so the wrappers themselves don't
+// occupy IRAM/flash on every call site.
+__attribute__((always_inline)) inline uint8_t progmem_read_byte(const uint8_t *addr) {
+  return pgm_read_byte(addr);  // NOLINT
+}
+__attribute__((always_inline)) inline const char *progmem_read_ptr(const char *const *addr) {
+  return reinterpret_cast<const char *>(pgm_read_ptr(addr));  // NOLINT
+}
+__attribute__((always_inline)) inline uint16_t progmem_read_uint16(const uint16_t *addr) {
+  return pgm_read_word(addr);  // NOLINT
+}
+
+// NOLINTNEXTLINE(readability-identifier-naming)
+__attribute__((always_inline)) inline void delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
+__attribute__((always_inline)) inline void arch_feed_wdt() { system_soft_wdt_feed(); }
+__attribute__((always_inline)) inline void arch_init() {}
+// esp_get_cycle_count() declared in <core_esp8266_features.h>; F_CPU is a
+// compiler-driven macro from the ESP8266 Arduino board defs (-DF_CPU=...).
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_cycle_count() { return esp_get_cycle_count(); }
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_freq_hz() { return F_CPU; }
+
+}  // namespace esphome
+
+#endif  // USE_ESP8266
@@ -51,7 +51,7 @@ static inline bool esp_rtc_user_mem_read(uint32_t index, uint32_t *dest) {
  if (index >= ESP_RTC_USER_MEM_SIZE_WORDS) {
    return false;
  }
-  *dest = ESP_RTC_USER_MEM[index];  // NOLINT(performance-no-int-to-ptr)
+  *dest = ESP_RTC_USER_MEM[index];  // NOLINT(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
  return true;
 }

@@ -64,7 +64,7 @@ static inline bool esp_rtc_user_mem_write(uint32_t index, uint32_t value) {
  }

  auto *ptr = &ESP_RTC_USER_MEM[index];  // NOLINT(performance-no-int-to-ptr)
-  *ptr = value;
+  *ptr = value;                          // NOLINT(clang-analyzer-core.FixedAddressDereference)
  return true;
 }

@@ -114,8 +114,10 @@ void ESPHomeOTAComponent::loop() {
  this->handle_handshake_();
 }

-static const uint8_t FEATURE_SUPPORTS_COMPRESSION = 0x01;
-static const uint8_t FEATURE_SUPPORTS_SHA256_AUTH = 0x02;
+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_COMPRESSION = 0x01;
+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02;
+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04;
+static constexpr uint8_t SERVER_FEATURE_SUPPORTS_COMPRESSION = 0x01;

 void ESPHomeOTAComponent::handle_handshake_() {
  /// Handle the OTA handshake and authentication.
@@ -201,16 +203,30 @@ void ESPHomeOTAComponent::handle_handshake_() {
      this->ota_features_ = this->handshake_buf_[0];
      ESP_LOGV(TAG, "Features: 0x%02X", this->ota_features_);
      this->transition_ota_state_(OTAState::FEATURE_ACK);
-      this->handshake_buf_[0] =
-          ((this->ota_features_ & FEATURE_SUPPORTS_COMPRESSION) != 0 && this->backend_->supports_compression())
-              ? ota::OTA_RESPONSE_SUPPORTS_COMPRESSION
-              : ota::OTA_RESPONSE_HEADER_OK;
+
+      const bool supports_compression =
+          (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_COMPRESSION) != 0 && this->backend_->supports_compression();
+
+      // Compose the feature-ack response. When the client negotiates the extended protocol we emit
+      // a 2-byte response (marker + server feature flags); otherwise we emit the single-byte
+      // legacy response.
+      this->extended_proto_ = (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL) != 0;
+      if (this->extended_proto_) {
+        static_assert(HANDSHAKE_BUF_SIZE >= 2, "handshake_buf_ must hold the 2-byte extended-protocol feature ack");
+        this->handshake_buf_[0] = ota::OTA_RESPONSE_FEATURE_FLAGS;
+        this->handshake_buf_[1] = (supports_compression ? SERVER_FEATURE_SUPPORTS_COMPRESSION : 0);
+      } else {
+        this->handshake_buf_[0] =
+            supports_compression ? ota::OTA_RESPONSE_SUPPORTS_COMPRESSION : ota::OTA_RESPONSE_HEADER_OK;
+      }
      [[fallthrough]];
    }

    case OTAState::FEATURE_ACK: {
-      // Acknowledge header - 1 byte
-      if (!this->try_write_(1, LOG_STR("ack feature"))) {
+      static constexpr size_t STANDARD_PROTO_ACK_SIZE = 1;
+      static constexpr size_t EXTENDED_PROTO_ACK_SIZE = 2;
+      const size_t ack_size = this->extended_proto_ ? EXTENDED_PROTO_ACK_SIZE : STANDARD_PROTO_ACK_SIZE;
+      if (!this->try_write_(ack_size, LOG_STR("ack feature"))) {
        return;
      }
 #ifdef USE_OTA_PASSWORD
@@ -292,9 +308,11 @@ void ESPHomeOTAComponent::handle_data_() {
  bool update_started = false;
  size_t total = 0;
  uint32_t last_progress = 0;
+  uint32_t last_data_ms = 0;
  uint8_t buf[OTA_BUFFER_SIZE];
  char *sbuf = reinterpret_cast<char *>(buf);
  size_t ota_size;
+  ota::OTAType ota_type = ota::OTA_TYPE_UPDATE_APP;
 #if USE_OTA_VERSION == 2
  size_t size_acknowledged = 0;
 #endif
@@ -310,6 +328,16 @@ void ESPHomeOTAComponent::handle_data_() {
  // Acknowledge auth OK - 1 byte
  this->write_byte_(ota::OTA_RESPONSE_AUTH_OK);

+  if (this->extended_proto_) {
+    // Read ota type, 1 byte
+    if (!this->readall_(buf, 1)) {
+      this->log_read_error_(LOG_STR("OTA type"));
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+    }
+    ota_type = static_cast<ota::OTAType>(buf[0]);
+  }
+  ESP_LOGV(TAG, "OTA type is 0x%02x", ota_type);
+
  // Read size, 4 bytes MSB first
  if (!this->readall_(buf, 4)) {
    this->log_read_error_(LOG_STR("size"));
@@ -319,6 +347,11 @@ void ESPHomeOTAComponent::handle_data_() {
             (static_cast<size_t>(buf[2]) << 8) | buf[3];
  ESP_LOGV(TAG, "Size is %u bytes", ota_size);

+  if (ota_type != ota::OTA_TYPE_UPDATE_APP) {
+    error_code = ota::OTA_RESPONSE_ERROR_UNSUPPORTED_OTA_TYPE;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+  }
+
  // Now that we've passed authentication and are actually
  // starting the update, set the warning status and notify
  // listeners. This ensures that port scanners do not
@@ -350,8 +383,18 @@ void ESPHomeOTAComponent::handle_data_() {
  // Acknowledge MD5 OK - 1 byte
  this->write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK);

+  // Track when we last received data so a silently-vanished peer (no FIN/RST
+  // delivered, e.g. uploader killed mid-transfer or NAT/router dropped state)
+  // can't wedge the device indefinitely. Without this, the loop only exits
+  // on actual data, EOF, or a non-EWOULDBLOCK error from read(), and lwIP
+  // TCP keepalive isn't enabled here.
+  last_data_ms = millis();
  while (total < ota_size) {
-    // TODO: timeout check
+    if (millis() - last_data_ms > OTA_SOCKET_TIMEOUT_DATA) {
+      ESP_LOGW(TAG, "No data received for %u ms", (unsigned) OTA_SOCKET_TIMEOUT_DATA);
+      error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+    }
    size_t remaining = ota_size - total;
    size_t requested = remaining < OTA_BUFFER_SIZE ? remaining : OTA_BUFFER_SIZE;
    ssize_t read = this->client_->read(buf, requested);
@@ -369,6 +412,7 @@ void ESPHomeOTAComponent::handle_data_() {
      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
    }

+    last_data_ms = millis();
    error_code = this->backend_->write(buf, read);
    if (error_code != ota::OTA_RESPONSE_OK) {
      ESP_LOGW(TAG, "Flash write err %d", error_code);
@@ -604,7 +648,7 @@ void ESPHomeOTAComponent::yield_and_feed_watchdog_() {
 void ESPHomeOTAComponent::log_auth_warning_(const LogString *msg) { ESP_LOGW(TAG, "Auth: %s", LOG_STR_ARG(msg)); }

 bool ESPHomeOTAComponent::select_auth_type_() {
-  bool client_supports_sha256 = (this->ota_features_ & FEATURE_SUPPORTS_SHA256_AUTH) != 0;
+  bool client_supports_sha256 = (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_SHA256_AUTH) != 0;

  // Require SHA256
  if (!client_supports_sha256) {
@@ -97,8 +97,9 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  ota::OTABackendPtr backend_;

  uint32_t client_connect_time_{0};
+  static constexpr size_t HANDSHAKE_BUF_SIZE = 5;
  uint16_t port_;
-  uint8_t handshake_buf_[5];
+  uint8_t handshake_buf_[HANDSHAKE_BUF_SIZE];
  OTAState ota_state_{OTAState::IDLE};
  uint8_t handshake_buf_pos_{0};
  uint8_t ota_features_{0};
@@ -106,6 +107,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  uint8_t auth_buf_pos_{0};
  uint8_t auth_type_{0};  // Store auth type to know which hasher to use
 #endif                    // USE_OTA_PASSWORD
+  bool extended_proto_{false};
 };

 }  // namespace esphome
@@ -26,9 +26,9 @@ espnow_ns = cg.esphome_ns.namespace("espnow")
 ESPNowComponent = espnow_ns.class_("ESPNowComponent", cg.Component)

 # Handler interfaces that other components can use to register callbacks
-ESPNowReceivedPacketHandler = espnow_ns.class_("ESPNowReceivedPacketHandler")
+ESPNowReceivePacketHandler = espnow_ns.class_("ESPNowReceivePacketHandler")
 ESPNowUnknownPeerHandler = espnow_ns.class_("ESPNowUnknownPeerHandler")
-ESPNowBroadcastedHandler = espnow_ns.class_("ESPNowBroadcastedHandler")
+ESPNowBroadcastHandler = espnow_ns.class_("ESPNowBroadcastHandler")

 ESPNowRecvInfo = espnow_ns.class_("ESPNowRecvInfo")
 ESPNowRecvInfoConstRef = ESPNowRecvInfo.operator("const").operator("ref")
@@ -48,10 +48,10 @@ OnUnknownPeerTrigger = espnow_ns.class_(
    "OnUnknownPeerTrigger", ESPNowHandlerTrigger, ESPNowUnknownPeerHandler
 )
 OnReceiveTrigger = espnow_ns.class_(
-    "OnReceiveTrigger", ESPNowHandlerTrigger, ESPNowReceivedPacketHandler
+    "OnReceiveTrigger", ESPNowHandlerTrigger, ESPNowReceivePacketHandler
 )
-OnBroadcastedTrigger = espnow_ns.class_(
-    "OnBroadcastedTrigger", ESPNowHandlerTrigger, ESPNowBroadcastedHandler
+OnBroadcastTrigger = espnow_ns.class_(
+    "OnBroadcastTrigger", ESPNowHandlerTrigger, ESPNowBroadcastHandler
 )


@@ -94,7 +94,7 @@ CONFIG_SCHEMA = cv.All(
            ),
            cv.Optional(CONF_ON_BROADCAST): automation.validate_automation(
                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnBroadcastedTrigger),
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnBroadcastTrigger),
                    cv.Optional(CONF_ADDRESS): cv.mac_address,
                }
            ),
@@ -140,11 +140,11 @@ async def to_code(config):

    for on_receive in config.get(CONF_ON_RECEIVE, []):
        trigger = await _trigger_to_code(on_receive)
-        cg.add(var.register_received_handler(trigger))
+        cg.add(var.register_receive_handler(trigger))

    for on_receive in config.get(CONF_ON_BROADCAST, []):
        trigger = await _trigger_to_code(on_receive)
-        cg.add(var.register_broadcasted_handler(trigger))
+        cg.add(var.register_broadcast_handler(trigger))


 # ========================================== A C T I O N S ================================================
@@ -67,6 +67,7 @@ template<typename... Ts> class SendAction : public Action<Ts...>, public Parente
    }
  }

+ protected:
  void play(const Ts &...x) override { /* ignore - see play_complex */
  }

@@ -75,7 +76,6 @@ template<typename... Ts> class SendAction : public Action<Ts...>, public Parente
    this->error_.stop();
  }

- protected:
  ActionList<Ts...> sent_;
  ActionList<Ts...> error_;

@@ -89,7 +89,7 @@ template<typename... Ts> class SendAction : public Action<Ts...>, public Parente
 template<typename... Ts> class AddPeerAction : public Action<Ts...>, public Parented<ESPNowComponent> {
  TEMPLATABLE_VALUE(peer_address_t, address);

- public:
+ protected:
  void play(const Ts &...x) override {
    peer_address_t address = this->address_.value(x...);
    this->parent_->add_peer(address.data());
@@ -99,7 +99,7 @@ template<typename... Ts> class AddPeerAction : public Action<Ts...>, public Pare
 template<typename... Ts> class DeletePeerAction : public Action<Ts...>, public Parented<ESPNowComponent> {
  TEMPLATABLE_VALUE(peer_address_t, address);

- public:
+ protected:
  void play(const Ts &...x) override {
    peer_address_t address = this->address_.value(x...);
    this->parent_->del_peer(address.data());
@@ -107,8 +107,9 @@ template<typename... Ts> class DeletePeerAction : public Action<Ts...>, public P
 };

 template<typename... Ts> class SetChannelAction : public Action<Ts...>, public Parented<ESPNowComponent> {
- public:
  TEMPLATABLE_VALUE(uint8_t, channel)
+
+ protected:
  void play(const Ts &...x) override {
    if (this->parent_->is_wifi_enabled()) {
      return;
@@ -125,9 +126,9 @@ class OnReceiveTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *,
    memcpy(this->address_, address.data(), ESP_NOW_ETH_ALEN);
  }

-  explicit OnReceiveTrigger() : has_address_(false) {}
+  explicit OnReceiveTrigger() {}

-  bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
+  bool on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
    bool match = !this->has_address_ || (memcmp(this->address_, info.src_addr, ESP_NOW_ETH_ALEN) == 0);
    if (!match)
      return false;
@@ -138,7 +139,7 @@ class OnReceiveTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *,

 protected:
  bool has_address_{false};
-  uint8_t address_[ESP_NOW_ETH_ALEN];
+  uint8_t address_[ESP_NOW_ETH_ALEN]{};
 };
 class OnUnknownPeerTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
                             public ESPNowUnknownPeerHandler {
@@ -148,15 +149,15 @@ class OnUnknownPeerTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_
    return false;  // Return false to continue processing other internal handlers
  }
 };
-class OnBroadcastedTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
-                             public ESPNowBroadcastedHandler {
+class OnBroadcastTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
+                           public ESPNowBroadcastHandler {
 public:
-  explicit OnBroadcastedTrigger(std::array<uint8_t, ESP_NOW_ETH_ALEN> address) : has_address_(true) {
+  explicit OnBroadcastTrigger(std::array<uint8_t, ESP_NOW_ETH_ALEN> address) : has_address_(true) {
    memcpy(this->address_, address.data(), ESP_NOW_ETH_ALEN);
  }
-  explicit OnBroadcastedTrigger() : has_address_(false) {}
+  explicit OnBroadcastTrigger() {}

-  bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
+  bool on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
    bool match = !this->has_address_ || (memcmp(this->address_, info.src_addr, ESP_NOW_ETH_ALEN) == 0);
    if (!match)
      return false;
@@ -167,7 +168,7 @@ class OnBroadcastedTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_

 protected:
  bool has_address_{false};
-  uint8_t address_[ESP_NOW_ETH_ALEN];
+  uint8_t address_[ESP_NOW_ETH_ALEN]{};
 };

 }  // namespace esphome::espnow
@@ -299,13 +299,13 @@ void ESPNowComponent::loop() {
                   format_hex_pretty_to(hex_buf, packet->packet_.receive.data, packet->packet_.receive.size));
 #endif
          if (memcmp(info.des_addr, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
-            for (auto *handler : this->broadcasted_handlers_) {
-              if (handler->on_broadcasted(info, packet->packet_.receive.data, packet->packet_.receive.size))
+            for (auto *handler : this->broadcast_handlers_) {
+              if (handler->on_broadcast(info, packet->packet_.receive.data, packet->packet_.receive.size))
                break;  // If a handler returns true, stop processing further handlers
            }
          } else {
-            for (auto *handler : this->received_handlers_) {
-              if (handler->on_received(info, packet->packet_.receive.data, packet->packet_.receive.size))
+            for (auto *handler : this->receive_handlers_) {
+              if (handler->on_receive(info, packet->packet_.receive.data, packet->packet_.receive.size))
                break;  // If a handler returns true, stop processing further handlers
            }
          }
@@ -31,8 +31,8 @@ using peer_address_t = std::array<uint8_t, ESP_NOW_ETH_ALEN>;
 enum class ESPNowTriggers : uint8_t {
  TRIGGER_NONE = 0,
  ON_NEW_PEER = 1,
-  ON_RECEIVED = 2,
-  ON_BROADCASTED = 3,
+  ON_RECEIVE = 2,
+  ON_BROADCAST = 3,
  ON_SUCCEED = 10,
  ON_FAILED = 11,
 };
@@ -74,18 +74,18 @@ class ESPNowReceivedPacketHandler {
  /// @param data Pointer to the received data payload
  /// @param size Size of the received data in bytes
  /// @return true if the packet was handled, false otherwise
-  virtual bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+  virtual bool on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
 };
-/// Handler interface for receiving broadcasted ESPNow packets
+/// Handler interface for receiving ESPNow broadcast packets
 /// Components should inherit from this class to handle incoming ESPNow data
-class ESPNowBroadcastedHandler {
+class ESPNowBroadcastHandler {
 public:
-  /// Called when a broadcasted ESPNow packet is received
+  /// Called when an ESPNow broadcast packet is received
  /// @param info Information about the received packet (sender MAC, etc.)
  /// @param data Pointer to the received data payload
  /// @param size Size of the received data in bytes
  /// @return true if the packet was handled, false otherwise
-  virtual bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+  virtual bool on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
 };

 class ESPNowComponent : public Component {
@@ -136,13 +136,11 @@ class ESPNowComponent : public Component {
  esp_err_t send(const uint8_t *peer_address, const uint8_t *payload, size_t size,
                 const send_callback_t &callback = nullptr);

-  void register_received_handler(ESPNowReceivedPacketHandler *handler) { this->received_handlers_.push_back(handler); }
+  void register_receive_handler(ESPNowReceivedPacketHandler *handler) { this->receive_handlers_.push_back(handler); }
  void register_unknown_peer_handler(ESPNowUnknownPeerHandler *handler) {
    this->unknown_peer_handlers_.push_back(handler);
  }
-  void register_broadcasted_handler(ESPNowBroadcastedHandler *handler) {
-    this->broadcasted_handlers_.push_back(handler);
-  }
+  void register_broadcast_handler(ESPNowBroadcastHandler *handler) { this->broadcast_handlers_.push_back(handler); }

 protected:
  friend void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size);
@@ -156,8 +154,8 @@ class ESPNowComponent : public Component {
  void send_();

  std::vector<ESPNowUnknownPeerHandler *> unknown_peer_handlers_;
-  std::vector<ESPNowReceivedPacketHandler *> received_handlers_;
-  std::vector<ESPNowBroadcastedHandler *> broadcasted_handlers_;
+  std::vector<ESPNowReceivedPacketHandler *> receive_handlers_;
+  std::vector<ESPNowBroadcastHandler *> broadcast_handlers_;

  std::vector<ESPNowPeer> peers_{};

@@ -26,10 +26,10 @@ void ESPNowTransport::setup() {
           this->peer_address_[5]);

  // Register received handler
-  this->parent_->register_received_handler(this);
+  this->parent_->register_receive_handler(this);

-  // Register broadcasted handler
-  this->parent_->register_broadcasted_handler(this);
+  // Register broadcast handler
+  this->parent_->register_broadcast_handler(this);
 }

 void ESPNowTransport::send_packet(const std::vector<uint8_t> &buf) const {
@@ -56,7 +56,7 @@ void ESPNowTransport::send_packet(const std::vector<uint8_t> &buf) const {
  });
 }

-bool ESPNowTransport::on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) {
+bool ESPNowTransport::on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) {
  ESP_LOGV(TAG, "Received packet of size %u from %02X:%02X:%02X:%02X:%02X:%02X", size, info.src_addr[0],
           info.src_addr[1], info.src_addr[2], info.src_addr[3], info.src_addr[4], info.src_addr[5]);

@@ -71,7 +71,7 @@ bool ESPNowTransport::on_received(const ESPNowRecvInfo &info, const uint8_t *dat
  return false;  // Allow other handlers to run
 }

-bool ESPNowTransport::on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) {
+bool ESPNowTransport::on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) {
  ESP_LOGV(TAG, "Received broadcast packet of size %u from %02X:%02X:%02X:%02X:%02X:%02X", size, info.src_addr[0],
           info.src_addr[1], info.src_addr[2], info.src_addr[3], info.src_addr[4], info.src_addr[5]);

@@ -15,7 +15,7 @@ namespace espnow {
 class ESPNowTransport : public packet_transport::PacketTransport,
                        public Parented<ESPNowComponent>,
                        public ESPNowReceivedPacketHandler,
-                        public ESPNowBroadcastedHandler {
+                        public ESPNowBroadcastHandler {
 public:
  void setup() override;
  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
@@ -25,8 +25,8 @@ class ESPNowTransport : public packet_transport::PacketTransport,
  }

  // ESPNow handler interface
-  bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override;
-  bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override;
+  bool on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override;
+  bool on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override;

 protected:
  void send_packet(const std::vector<uint8_t> &buf) const override;
@@ -19,6 +19,7 @@ from esphome.const import (
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
+    queue_entity_register,
    setup_device_class,
    setup_entity,
 )
@@ -108,7 +109,7 @@ async def setup_event_core_(var, config, *, event_types: list[str]):
 async def register_event(var, config, *, event_types: list[str]):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_event(var))
+    queue_entity_register("event", config)
    CORE.register_platform_component("event", var)
    await setup_event_core_(var, config, event_types=event_types)

@@ -1,5 +1,6 @@
 import logging
 from pathlib import Path
+from typing import Any

 from esphome import git, loader
 import esphome.config_validation as cv
@@ -17,7 +18,7 @@ from esphome.const import (
    TYPE_GIT,
    TYPE_LOCAL,
 )
-from esphome.core import CORE
+from esphome.core import CORE, TimePeriodSeconds

 _LOGGER = logging.getLogger(__name__)

@@ -35,17 +36,15 @@ CONFIG_SCHEMA = cv.ensure_list(
 )


-async def to_code(config):
+async def to_code(config: dict[str, Any]) -> None:
    pass


-def _process_git_config(config: dict, refresh, skip_update: bool = False) -> str:
-    # When skip_update is True, use NEVER_REFRESH to prevent updates
-    actual_refresh = git.NEVER_REFRESH if skip_update else refresh
+def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> Path:
    repo_dir, _ = git.clone_or_update(
        url=config[CONF_URL],
        ref=config.get(CONF_REF),
-        refresh=actual_refresh,
+        refresh=refresh,
        domain=DOMAIN,
        username=config.get(CONF_USERNAME),
        password=config.get(CONF_PASSWORD),
@@ -72,12 +71,12 @@ def _process_git_config(config: dict, refresh, skip_update: bool = False) -> str
    return components_dir


-def _process_single_config(config: dict, skip_update: bool = False):
+def _process_single_config(config: dict[str, Any]) -> None:
    conf = config[CONF_SOURCE]
    if conf[CONF_TYPE] == TYPE_GIT:
        with cv.prepend_path([CONF_SOURCE]):
            components_dir = _process_git_config(
-                config[CONF_SOURCE], config[CONF_REFRESH], skip_update
+                config[CONF_SOURCE], config[CONF_REFRESH]
            )
    elif conf[CONF_TYPE] == TYPE_LOCAL:
        components_dir = Path(CORE.relative_config_path(conf[CONF_PATH]))
@@ -107,7 +106,7 @@ def _process_single_config(config: dict, skip_update: bool = False):
    loader.install_meta_finder(components_dir, allowed_components=allowed_components)


-def do_external_components_pass(config: dict, skip_update: bool = False) -> None:
+def do_external_components_pass(config: dict[str, Any]) -> None:
    conf = config.get(DOMAIN)
    if conf is None:
        return
@@ -115,4 +114,4 @@ def do_external_components_pass(config: dict, skip_update: bool = False) -> None
        conf = CONFIG_SCHEMA(conf)
        for i, c in enumerate(conf):
            with cv.prepend_path(i):
-                _process_single_config(c, skip_update)
+                _process_single_config(c)
@@ -35,7 +35,7 @@ void EZOSensor::update() {
    }

    if (!found) {
-      std::unique_ptr<EzoCommand> ezo_command(new EzoCommand);
+      auto ezo_command = make_unique<EzoCommand>();
      ezo_command->command = "R";
      ezo_command->command_type = EzoCommandType::EZO_READ;
      ezo_command->delay_ms = 900;
@@ -162,7 +162,7 @@ void EZOSensor::loop() {
 }

 void EZOSensor::add_command_(const char *command, EzoCommandType command_type, uint16_t delay_ms) {
-  std::unique_ptr<EzoCommand> ezo_command(new EzoCommand);
+  auto ezo_command = make_unique<EzoCommand>();
  ezo_command->command = command;
  ezo_command->command_type = command_type;
  ezo_command->delay_ms = delay_ms;
@@ -31,13 +31,19 @@ from esphome.const import (
    CONF_TRIGGER_ID,
    CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
+from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
+from esphome.core.entity_helpers import (
+    entity_duplicate_validator,
+    queue_entity_register,
+    setup_entity,
+)
+from esphome.cpp_generator import LambdaExpression

 IS_PLATFORM_COMPONENT = True

 fan_ns = cg.esphome_ns.namespace("fan")
 Fan = fan_ns.class_("Fan", cg.EntityBase)
+FanCall = fan_ns.class_("FanCall")

 FanDirection = fan_ns.enum("FanDirection", is_class=True)
 FAN_DIRECTION_ENUM = {
@@ -292,7 +298,7 @@ async def setup_fan_core_(var, config):
 async def register_fan(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(cg.App.register_fan(var))
+    queue_entity_register("fan", config)
    CORE.register_platform_component("fan", var)
    await setup_fan_core_(var, config)

@@ -343,17 +349,38 @@ async def fan_turn_off_to_code(config, action_id, template_arg, args):
 )
 async def fan_turn_on_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    if (oscillating := config.get(CONF_OSCILLATING)) is not None:
-        template_ = await cg.templatable(oscillating, args, cg.bool_)
-        cg.add(var.set_oscillating(template_))
-    if (speed := config.get(CONF_SPEED)) is not None:
-        template_ = await cg.templatable(speed, args, cg.int_)
-        cg.add(var.set_speed(template_))
-    if (direction := config.get(CONF_DIRECTION)) is not None:
-        template_ = await cg.templatable(direction, args, FanDirection)
-        cg.add(var.set_direction(template_))
-    return var
+
+    # All configured fields are folded into a single stateless lambda whose
+    # constants live in flash; the action stores only a function pointer.
+    FIELDS = (
+        (CONF_OSCILLATING, "set_oscillating", cg.bool_),
+        (CONF_SPEED, "set_speed", cg.int_),
+        (CONF_DIRECTION, "set_direction", FanDirection),
+    )
+
+    fwd_args = ", ".join(name for _, name in args)
+    body_lines: list[str] = []
+    for conf_key, setter, type_ in FIELDS:
+        if (value := config.get(conf_key)) is None:
+            continue
+        if isinstance(value, Lambda):
+            inner = await cg.process_lambda(value, args, return_type=type_)
+            body_lines.append(f"call.{setter}(({inner})({fwd_args}));")
+        else:
+            body_lines.append(f"call.{setter}({cg.safe_exp(value)});")
+
+    # Match TurnOnAction::ApplyFn signature: const Ts &... for trigger args.
+    apply_args = [
+        (FanCall.operator("ref"), "call"),
+        *((t.operator("const").operator("ref"), n) for t, n in args),
+    ]
+    apply_lambda = LambdaExpression(
+        ["\n".join(body_lines)],
+        apply_args,
+        capture="",
+        return_type=cg.void,
+    )
+    return cg.new_Pvariable(action_id, template_arg, paren, apply_lambda)


@automation.register_action(
@@ -7,29 +7,24 @@
 namespace esphome {
 namespace fan {

+// All configured fields are baked into a single stateless lambda whose
+// constants live in flash. The action only stores one function pointer
+// plus one parent pointer, regardless of how many fields the user set.
+// Trigger args are forwarded to the apply function so user lambdas
+// (e.g. `speed: !lambda "return x;"`) keep working.
 template<typename... Ts> class TurnOnAction : public Action<Ts...> {
 public:
-  explicit TurnOnAction(Fan *state) : state_(state) {}
-
-  TEMPLATABLE_VALUE(bool, oscillating)
-  TEMPLATABLE_VALUE(int, speed)
-  TEMPLATABLE_VALUE(FanDirection, direction)
+  using ApplyFn = void (*)(FanCall &, const Ts &...);
+  TurnOnAction(Fan *state, ApplyFn apply) : state_(state), apply_(apply) {}

  void play(const Ts &...x) override {
    auto call = this->state_->turn_on();
-    if (this->oscillating_.has_value()) {
-      call.set_oscillating(this->oscillating_.value(x...));
-    }
-    if (this->speed_.has_value()) {
-      call.set_speed(this->speed_.value(x...));
-    }
-    if (this->direction_.has_value()) {
-      call.set_direction(this->direction_.value(x...));
-    }
+    this->apply_(call, x...);
    call.perform();
  }

  Fan *state_;
+  ApplyFn apply_;
 };

 template<typename... Ts> class TurnOffAction : public Action<Ts...> {
@@ -3,11 +3,12 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"

-namespace esphome {
-namespace feedback {
+namespace esphome::feedback {

 static const char *const TAG = "feedback.cover";

+static constexpr uint32_t DIRECTION_CHANGE_TIMEOUT_ID = 1;
+
 using namespace esphome::cover;

 void FeedbackCover::setup() {
@@ -37,7 +38,7 @@ void FeedbackCover::setup() {
  }
 #endif

-  this->last_recompute_time_ = this->start_dir_time_ = millis();
+  this->last_recompute_time_ = this->start_dir_time_ = App.get_loop_component_start_time();
 }

 CoverTraits FeedbackCover::get_traits() {
@@ -135,7 +136,7 @@ void FeedbackCover::set_close_endstop(binary_sensor::BinarySensor *close_endstop
 #endif

 void FeedbackCover::endstop_reached_(bool open_endstop) {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();

  this->position = open_endstop ? COVER_OPEN : COVER_CLOSED;

@@ -174,7 +175,7 @@ void FeedbackCover::set_current_operation_(cover::CoverOperation operation, bool
  if (!is_triggered || (this->open_feedback_ == nullptr || this->close_feedback_ == nullptr))
 #endif
  {
-    auto now = millis();
+    const uint32_t now = App.get_loop_component_start_time();
    this->current_operation = operation;
    this->start_dir_time_ = this->last_recompute_time_ = now;
    this->publish_state();
@@ -306,7 +307,7 @@ void FeedbackCover::control(const CoverCall &call) {

 void FeedbackCover::stop_prev_trigger_() {
  if (this->direction_change_waittime_.has_value()) {
-    this->cancel_timeout("direction_change");
+    this->cancel_timeout(DIRECTION_CHANGE_TIMEOUT_ID);
  }
  if (this->prev_command_trigger_ != nullptr) {
    this->prev_command_trigger_->stop_action();
@@ -374,12 +375,10 @@ void FeedbackCover::start_direction_(CoverOperation dir) {
  // check if we have a wait time
  if (this->direction_change_waittime_.has_value() && dir != COVER_OPERATION_IDLE &&
      this->current_operation != COVER_OPERATION_IDLE && dir != this->current_operation) {
+    const uint32_t waittime = *this->direction_change_waittime_;
    ESP_LOGD(TAG, "'%s' - Reversing direction.", this->name_.c_str());
    this->start_direction_(COVER_OPERATION_IDLE);
-
-    this->set_timeout("direction_change", *this->direction_change_waittime_,
-                      [this, dir]() { this->start_direction_(dir); });
-
+    this->set_timeout(DIRECTION_CHANGE_TIMEOUT_ID, waittime, [this, dir]() { this->start_direction_(dir); });
  } else {
    this->set_current_operation_(dir, true);
    this->prev_command_trigger_ = trig;
@@ -395,7 +394,7 @@ void FeedbackCover::recompute_position_() {
  if (this->current_operation == COVER_OPERATION_IDLE)
    return;

-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
  float dir;
  float action_dur;
  float min_pos;
@@ -451,5 +450,4 @@ void FeedbackCover::recompute_position_() {
  this->last_recompute_time_ = now;
 }

-}  // namespace feedback
-}  // namespace esphome
+}  // namespace esphome::feedback
@@ -8,8 +8,7 @@
 #endif
 #include "esphome/components/cover/cover.h"

-namespace esphome {
-namespace feedback {
+namespace esphome::feedback {

 class FeedbackCover : public cover::Cover, public Component {
 public:
@@ -85,5 +84,4 @@ class FeedbackCover : public cover::Cover, public Component {
  uint32_t update_interval_{1000};
 };

-}  // namespace feedback
-}  // namespace esphome
+}  // namespace esphome::feedback
--- a/Show More
+++ b/Show More