[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.

.clang-tidy

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

.clang-tidy.hash

@@ -1 +1 @@
-1b1ce6324c50c4595703c7df0a8a479b4fe84b71ff1a8793cce1a16f17a33324
+0c7f309d70eca8e3efd510092ddb23c530f3934c49371717efa124b788d761f8

.github/workflows/auto-label-pr.yml

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

.github/workflows/ci.yml

@@ -136,6 +136,53 @@ jobs:
           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:
@@ -199,12 +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 }}
@@ -243,12 +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
@@ -267,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
@@ -299,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
@@ -1066,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

.github/workflows/codeql.yml

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

.github/workflows/lock.yml

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

.github/workflows/release.yml

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

esphome/__main__.py

@@ -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 (
@@ -72,7 +72,12 @@ from esphome.util import (
     run_external_process,
     safe_print,
 )
-from esphome.zeroconf import discover_mdns_devices
+
+# 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__)
 
@@ -241,6 +246,8 @@ def _discover_mac_suffix_devices() -> list[str] | None:
     """
     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(
@@ -660,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)
@@ -680,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()
 
@@ -691,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)
 
@@ -1112,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:
@@ -1180,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)
@@ -1321,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:
@@ -1336,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:
@@ -1538,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:

esphome/analyze_memory/__init__.py

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

esphome/automation.py

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

esphome/components/adalight/adalight_light_effect.cpp

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

esphome/components/api/homeassistant_service.h

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

esphome/components/api/proto.h

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

esphome/components/aqi/aqi_calculator.h

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

esphome/components/aqi/caqi_calculator.h

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

esphome/components/audio/__init__.py

@@ -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,6 +340,36 @@ 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.2.0")
 
@@ -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
+            )

esphome/components/audio_file/__init__.py

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

esphome/components/beken_spi_led_strip/light.py

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

esphome/components/binary_sensor/__init__.py

@@ -143,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__)
 
@@ -175,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
@@ -203,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_))
@@ -221,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
@@ -234,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
@@ -306,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

esphome/components/binary_sensor/filter.cpp

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

esphome/components/binary_sensor/filter.h

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

esphome/components/climate/__init__.py

@@ -48,13 +48,13 @@ from esphome.const import (
     CONF_VISUAL,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+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 MockObjClass
+from esphome.cpp_generator import LambdaExpression, MockObjClass
 
 IS_PLATFORM_COMPONENT = True
 
@@ -487,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)

esphome/components/climate/automation.h

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

esphome/components/climate/climate.cpp

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

esphome/components/debug/debug_zephyr.cpp

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

esphome/components/e131/e131_addressable_light_effect.cpp

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

esphome/components/ens160_base/ens160_base.cpp

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

esphome/components/esp32/__init__.py

@@ -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",
@@ -1750,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"):

esphome/components/esp32/core.cpp

@@ -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,54 +13,7 @@ extern "C" __attribute__((weak)) void initArduino() {}
 
 namespace esphome {
 
-// yield(), delay(), micros(), millis_64() inlined in hal.h.
-// 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 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

esphome/components/esp32/hal.cpp

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

esphome/components/esp32/hal.h

@@ -4,6 +4,8 @@
 
 #include <cstdint>
 #include <esp_attr.h>
+#include <esp_cpu.h>
+#include <esp_task_wdt.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
@@ -13,8 +15,15 @@
 #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; }
 
@@ -30,6 +39,14 @@ __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

esphome/components/esp32/printf_stubs.cpp

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

esphome/components/esp32_hosted/__init__.py

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

esphome/components/esp8266/core.cpp

@@ -3,109 +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 {
 
-// yield(), micros(), millis_64() inlined in 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 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
@@ -142,12 +45,4 @@ extern "C" void resetPins() {  // NOLINT
 
 }  // 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

esphome/components/esp8266/gpio.cpp

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

esphome/components/esp8266/hal.cpp

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

esphome/components/esp8266/hal.h

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

esphome/components/esp8266/preferences.cpp

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

esphome/components/esphome/ota/ota_esphome.cpp

@@ -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
@@ -296,6 +312,7 @@ void ESPHomeOTAComponent::handle_data_() {
   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
@@ -311,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"));
@@ -320,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
@@ -616,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) {

esphome/components/esphome/ota/ota_esphome.h

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

esphome/components/espnow/__init__.py

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

esphome/components/espnow/automation.h

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

esphome/components/espnow/espnow_component.cpp

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

esphome/components/espnow/espnow_component.h

@@ -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_{};
 

esphome/components/espnow/packet_transport/espnow_transport.cpp

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

esphome/components/espnow/packet_transport/espnow_transport.h

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

esphome/components/fan/__init__.py

@@ -31,17 +31,19 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+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 = {
@@ -347,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(

esphome/components/fan/automation.h

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

esphome/components/feedback/feedback_cover.cpp

@@ -375,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_TIMEOUT_ID, *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;

esphome/components/haier/hon_climate.cpp

@@ -85,7 +85,7 @@ void HonClimate::set_horizontal_airflow(hon_protocol::HorizontalSwingMode direct
   this->force_send_control_ = true;
 }
 
-std::string HonClimate::get_cleaning_status_text() const {
+const char *HonClimate::get_cleaning_status_text() const {
   switch (this->cleaning_status_) {
     case CleaningState::SELF_CLEAN:
       return "Self clean";
@@ -134,29 +134,22 @@ haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(haie
     }
     // All OK
     hon_protocol::DeviceVersionAnswer *answr = (hon_protocol::DeviceVersionAnswer *) data;
-    char tmp[9];
-    tmp[8] = 0;
-    strncpy(tmp, answr->protocol_version, 8);
-    this->hvac_hardware_info_ = HardwareInfo();
-    this->hvac_hardware_info_.value().protocol_version_ = std::string(tmp);
-    strncpy(tmp, answr->software_version, 8);
-    this->hvac_hardware_info_.value().software_version_ = std::string(tmp);
-    strncpy(tmp, answr->hardware_version, 8);
-    this->hvac_hardware_info_.value().hardware_version_ = std::string(tmp);
-    strncpy(tmp, answr->device_name, 8);
-    this->hvac_hardware_info_.value().device_name_ = std::string(tmp);
+    HardwareInfo info{};  // zero-init guarantees null-termination
+    strncpy(info.protocol_version_, answr->protocol_version, HARDWARE_INFO_STR_SIZE - 1);
+    strncpy(info.software_version_, answr->software_version, HARDWARE_INFO_STR_SIZE - 1);
+    strncpy(info.hardware_version_, answr->hardware_version, HARDWARE_INFO_STR_SIZE - 1);
+    strncpy(info.device_name_, answr->device_name, HARDWARE_INFO_STR_SIZE - 1);
+    info.functions_[0] = (answr->functions[1] & 0x01) != 0;  // interactive mode support
+    info.functions_[1] = (answr->functions[1] & 0x02) != 0;  // controller-device mode support
+    info.functions_[2] = (answr->functions[1] & 0x04) != 0;  // crc support
+    info.functions_[3] = (answr->functions[1] & 0x08) != 0;  // multiple AC support
+    info.functions_[4] = (answr->functions[1] & 0x20) != 0;  // roles support
+    this->use_crc_ = info.functions_[2];
 #ifdef USE_TEXT_SENSOR
-    this->update_sub_text_sensor_(SubTextSensorType::APPLIANCE_NAME, this->hvac_hardware_info_.value().device_name_);
-    this->update_sub_text_sensor_(SubTextSensorType::PROTOCOL_VERSION,
-                                  this->hvac_hardware_info_.value().protocol_version_);
+    this->update_sub_text_sensor_(SubTextSensorType::APPLIANCE_NAME, info.device_name_);
+    this->update_sub_text_sensor_(SubTextSensorType::PROTOCOL_VERSION, info.protocol_version_);
 #endif
-    this->hvac_hardware_info_.value().functions_[0] = (answr->functions[1] & 0x01) != 0;  // interactive mode support
-    this->hvac_hardware_info_.value().functions_[1] =
-        (answr->functions[1] & 0x02) != 0;  // controller-device mode support
-    this->hvac_hardware_info_.value().functions_[2] = (answr->functions[1] & 0x04) != 0;  // crc support
-    this->hvac_hardware_info_.value().functions_[3] = (answr->functions[1] & 0x08) != 0;  // multiple AC support
-    this->hvac_hardware_info_.value().functions_[4] = (answr->functions[1] & 0x20) != 0;  // roles support
-    this->use_crc_ = this->hvac_hardware_info_.value().functions_[2];
+    this->hvac_hardware_info_ = info;
     this->set_phase(ProtocolPhases::SENDING_INIT_2);
     return result;
   } else {
@@ -347,10 +340,9 @@ void HonClimate::dump_config() {
                   "  Device software version: %s\n"
                   "  Device hardware version: %s\n"
                   "  Device name: %s",
-                  this->hvac_hardware_info_.value().protocol_version_.c_str(),
-                  this->hvac_hardware_info_.value().software_version_.c_str(),
-                  this->hvac_hardware_info_.value().hardware_version_.c_str(),
-                  this->hvac_hardware_info_.value().device_name_.c_str());
+                  this->hvac_hardware_info_.value().protocol_version_,
+                  this->hvac_hardware_info_.value().software_version_,
+                  this->hvac_hardware_info_.value().hardware_version_, this->hvac_hardware_info_.value().device_name_);
     ESP_LOGCONFIG(TAG, "  Device features:%s%s%s%s%s",
                   (this->hvac_hardware_info_.value().functions_[0] ? " interactive" : ""),
                   (this->hvac_hardware_info_.value().functions_[1] ? " controller-device" : ""),
@@ -460,7 +452,7 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
       if (this->action_request_.has_value()) {
         if (this->action_request_.value().message.has_value()) {
           this->send_message_(this->action_request_.value().message.value(), this->use_crc_);
-          this->action_request_.value().message.reset();
+          this->action_request_.value().message.reset();  // NOLINT(bugprone-unchecked-optional-access)
         } else {
           // Message already sent, reseting request and return to idle
           this->action_request_.reset();
@@ -796,7 +788,7 @@ void HonClimate::set_sub_text_sensor(SubTextSensorType type, text_sensor::TextSe
   }
 }
 
-void HonClimate::update_sub_text_sensor_(SubTextSensorType type, const std::string &value) {
+void HonClimate::update_sub_text_sensor_(SubTextSensorType type, const char *value) {
   size_t index = (size_t) type;
   if (this->sub_text_sensors_[index] != nullptr)
     this->sub_text_sensors_[index]->publish_state(value);

esphome/components/haier/hon_climate.h

@@ -90,7 +90,7 @@ class HonClimate : public HaierClimateBase {
   void set_sub_text_sensor(SubTextSensorType type, text_sensor::TextSensor *sens);
 
  protected:
-  void update_sub_text_sensor_(SubTextSensorType type, const std::string &value);
+  void update_sub_text_sensor_(SubTextSensorType type, const char *value);
   text_sensor::TextSensor *sub_text_sensors_[(size_t) SubTextSensorType::SUB_TEXT_SENSOR_TYPE_COUNT]{nullptr};
 #endif
 #ifdef USE_SWITCH
@@ -116,7 +116,7 @@ class HonClimate : public HaierClimateBase {
   void set_vertical_airflow(hon_protocol::VerticalSwingMode direction);
   esphome::optional<hon_protocol::HorizontalSwingMode> get_horizontal_airflow() const;
   void set_horizontal_airflow(hon_protocol::HorizontalSwingMode direction);
-  std::string get_cleaning_status_text() const;
+  const char *get_cleaning_status_text() const;
   CleaningState get_cleaning_status() const;
   void start_self_cleaning();
   void start_steri_cleaning();
@@ -166,11 +166,12 @@ class HonClimate : public HaierClimateBase {
   void fill_control_messages_queue_();
   void clear_control_messages_queue_();
 
+  static constexpr size_t HARDWARE_INFO_STR_SIZE = 9;
   struct HardwareInfo {
-    std::string protocol_version_;
-    std::string software_version_;
-    std::string hardware_version_;
-    std::string device_name_;
+    char protocol_version_[HARDWARE_INFO_STR_SIZE];
+    char software_version_[HARDWARE_INFO_STR_SIZE];
+    char hardware_version_[HARDWARE_INFO_STR_SIZE];
+    char device_name_[HARDWARE_INFO_STR_SIZE];
     bool functions_[5];
   };
 

esphome/components/haier/smartair2_climate.cpp

@@ -191,7 +191,7 @@ void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now)
       if (this->action_request_.has_value()) {
         if (this->action_request_.value().message.has_value()) {
           this->send_message_(this->action_request_.value().message.value(), this->use_crc_);
-          this->action_request_.value().message.reset();
+          this->action_request_.value().message.reset();  // NOLINT(bugprone-unchecked-optional-access)
         } else {
           // Message already sent, reseting request and return to idle
           this->action_request_.reset();

esphome/components/host/core.cpp

@@ -1,74 +1,16 @@
 #ifdef USE_HOST
 
 #include "esphome/core/application.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "preferences.h"
 
 #include <csignal>
-#include <sched.h>
-#include <time.h>
-#include <cstdlib>
 
 namespace {
 volatile sig_atomic_t s_signal_received = 0;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 void signal_handler(int signal) { s_signal_received = signal; }
 }  // namespace
 
-namespace esphome {
-
-void HOT yield() { ::sched_yield(); }
-uint32_t IRAM_ATTR HOT millis() {
-  struct timespec spec;
-  clock_gettime(CLOCK_MONOTONIC, &spec);
-  return static_cast<uint32_t>(spec.tv_sec * 1000ULL + spec.tv_nsec / 1000000);
-}
-uint64_t millis_64() {
-  struct timespec spec;
-  clock_gettime(CLOCK_MONOTONIC, &spec);
-  return static_cast<uint64_t>(spec.tv_sec) * 1000ULL + static_cast<uint64_t>(spec.tv_nsec) / 1000000ULL;
-}
-void HOT delay(uint32_t ms) {
-  struct timespec ts;
-  ts.tv_sec = ms / 1000;
-  ts.tv_nsec = (ms % 1000) * 1000000;
-  int res;
-  do {
-    res = nanosleep(&ts, &ts);
-  } while (res != 0 && errno == EINTR);
-}
-uint32_t IRAM_ATTR HOT micros() {
-  struct timespec spec;
-  clock_gettime(CLOCK_MONOTONIC, &spec);
-  return static_cast<uint32_t>(spec.tv_sec * 1000000ULL + spec.tv_nsec / 1000);
-}
-void IRAM_ATTR HOT delayMicroseconds(uint32_t us) {
-  struct timespec ts;
-  ts.tv_sec = us / 1000000U;
-  ts.tv_nsec = (us % 1000000U) * 1000U;
-  int res;
-  do {
-    res = nanosleep(&ts, &ts);
-  } while (res != 0 && errno == EINTR);
-}
-void arch_restart() { exit(0); }
-void arch_init() {
-  // pass
-}
-void HOT arch_feed_wdt() {
-  // pass
-}
-
-uint32_t arch_get_cpu_cycle_count() {
-  struct timespec spec;
-  clock_gettime(CLOCK_MONOTONIC, &spec);
-  time_t seconds = spec.tv_sec;
-  uint32_t us = spec.tv_nsec;
-  return ((uint32_t) seconds) * 1000000000U + us;
-}
-uint32_t arch_get_cpu_freq_hz() { return 1000000000U; }
-
-}  // namespace esphome
+// HAL functions live in hal.cpp.
 
 void setup();
 void loop();

esphome/components/host/hal.cpp

@@ -0,0 +1,65 @@
+#ifdef USE_HOST
+
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+
+#include <time.h>
+#include <cerrno>
+#include <cstdlib>
+
+// Empty host namespace block to satisfy ci-custom's lint_namespace check.
+// HAL functions live in namespace esphome (root) — they are not part of the
+// host component's API.
+namespace esphome::host {}  // namespace esphome::host
+
+namespace esphome {
+
+// yield(), arch_init(), arch_feed_wdt(), arch_get_cpu_freq_hz() inlined in
+// components/host/hal.h.
+
+uint32_t IRAM_ATTR HOT millis() {
+  struct timespec spec;
+  clock_gettime(CLOCK_MONOTONIC, &spec);
+  return static_cast<uint32_t>(spec.tv_sec * 1000ULL + spec.tv_nsec / 1000000);
+}
+uint64_t millis_64() {
+  struct timespec spec;
+  clock_gettime(CLOCK_MONOTONIC, &spec);
+  return static_cast<uint64_t>(spec.tv_sec) * 1000ULL + static_cast<uint64_t>(spec.tv_nsec) / 1000000ULL;
+}
+void HOT delay(uint32_t ms) {
+  struct timespec ts;
+  ts.tv_sec = ms / 1000;
+  ts.tv_nsec = (ms % 1000) * 1000000;
+  int res;
+  do {
+    res = nanosleep(&ts, &ts);
+  } while (res != 0 && errno == EINTR);
+}
+uint32_t IRAM_ATTR HOT micros() {
+  struct timespec spec;
+  clock_gettime(CLOCK_MONOTONIC, &spec);
+  return static_cast<uint32_t>(spec.tv_sec * 1000000ULL + spec.tv_nsec / 1000);
+}
+void IRAM_ATTR HOT delayMicroseconds(uint32_t us) {
+  struct timespec ts;
+  ts.tv_sec = us / 1000000U;
+  ts.tv_nsec = (us % 1000000U) * 1000U;
+  int res;
+  do {
+    res = nanosleep(&ts, &ts);
+  } while (res != 0 && errno == EINTR);
+}
+void arch_restart() { exit(0); }
+
+uint32_t arch_get_cpu_cycle_count() {
+  struct timespec spec;
+  clock_gettime(CLOCK_MONOTONIC, &spec);
+  time_t seconds = spec.tv_sec;
+  uint32_t ns = static_cast<uint32_t>(spec.tv_nsec);
+  return static_cast<uint32_t>(seconds) * 1000000000U + ns;
+}
+
+}  // namespace esphome
+
+#endif  // USE_HOST

esphome/components/host/hal.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#ifdef USE_HOST
+
+#include <cstdint>
+#include <sched.h>
+
+#define IRAM_ATTR
+#define PROGMEM
+
+namespace esphome::host {}
+
+namespace esphome {
+
+/// Returns true when executing inside an interrupt handler.
+/// Host has no ISR concept.
+__attribute__((always_inline)) inline bool in_isr_context() { return false; }
+
+__attribute__((always_inline)) inline void yield() { ::sched_yield(); }
+
+void delay(uint32_t ms);
+uint32_t micros();
+uint32_t millis();
+uint64_t millis_64();
+void delayMicroseconds(uint32_t us);  // NOLINT(readability-identifier-naming)
+uint32_t arch_get_cpu_cycle_count();
+
+__attribute__((always_inline)) inline void arch_init() {}
+__attribute__((always_inline)) inline void arch_feed_wdt() {}
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_freq_hz() { return 1000000000U; }
+
+}  // namespace esphome
+
+#endif  // USE_HOST

esphome/components/http_request/http_request_arduino.cpp

@@ -243,7 +243,7 @@ int HttpContainerArduino::read(uint8_t *buf, size_t max_len) {
   // Non-chunked path
   int available_data = stream_ptr->available();
   size_t remaining = (this->content_length > 0) ? (this->content_length - this->bytes_read_) : max_len;
-  int bufsize = std::min(max_len, std::min(remaining, (size_t) available_data));
+  int bufsize = std::min({max_len, remaining, (size_t) available_data});
 
   if (bufsize == 0) {
     this->duration_ms += (millis() - start);

esphome/components/kamstrup_kmp/kamstrup_kmp.cpp

@@ -139,12 +139,12 @@ void KamstrupKMPComponent::clear_uart_rx_buffer_() {
 
 void KamstrupKMPComponent::read_command_(uint16_t command) {
   uint8_t buffer[20] = {0};
-  int buffer_len = 0;
+  size_t buffer_len = 0;
   int data;
   int timeout = 250;  // ms
 
   // Read the data from the UART
-  while (timeout > 0 && buffer_len < static_cast<int>(sizeof(buffer))) {
+  while (timeout > 0 && buffer_len < sizeof(buffer)) {
     if (this->available()) {
       data = this->read();
       if (data > -1) {
@@ -183,7 +183,7 @@ void KamstrupKMPComponent::read_command_(uint16_t command) {
   // Decode
   uint8_t msg[20] = {0};
   int msg_len = 0;
-  for (int i = 1; i < buffer_len - 1; i++) {
+  for (size_t i = 1; i < buffer_len - 1; i++) {
     if (buffer[i] == 0x1B) {
       msg[msg_len++] = buffer[i + 1] ^ 0xFF;
       i++;

esphome/components/libretiny/__init__.py

@@ -37,6 +37,7 @@ from .const import (
     CONF_UART_PORT,
     FAMILIES,
     FAMILY_BK7231N,
+    FAMILY_BK7238,
     FAMILY_COMPONENT,
     FAMILY_FRIENDLY,
     FAMILY_RTL8710B,
@@ -56,19 +57,22 @@ CODEOWNERS = ["@kuba2k2"]
 AUTO_LOAD = ["preferences"]
 IS_TARGET_PLATFORM = True
 
-# BK7231N SDK options to disable unused features.
+# BLE 5.x BK SDK options to disable unused features.
 # Disabling BLE saves ~21KB RAM and ~200KB Flash because BLE init code is
 # called unconditionally by the SDK. ESPHome doesn't use BLE on LibreTiny.
 #
-# This only works on BK7231N (BLE 5.x). Other BK72XX chips using BLE 4.2
-# (BK7231T, BK7231Q, BK7251; BK7252 boards use the BK7251 family) have a bug
-# where the BLE library still links and references undefined symbols when
-# CFG_SUPPORT_BLE=0.
+# This only works on BLE 5.x BK chips (BK7231N, BK7238). Other BK72XX chips
+# using BLE 4.2 (BK7231T, BK7231Q, BK7251; BK7252 boards use the BK7251 family)
+# have a bug where the BLE library still links and references undefined symbols
+# when CFG_SUPPORT_BLE=0.
+#
+# On BK7238 the SDK also hangs at WiFi STA enable when BLE init runs, so
+# disabling it is required for reliable boot, not just an optimization.
 #
 # Other options like CFG_TX_EVM_TEST, CFG_RX_SENSITIVITY_TEST, CFG_SUPPORT_BKREG,
 # CFG_SUPPORT_OTA_HTTP, and CFG_USE_SPI_SLAVE were evaluated but provide no  # NOLINT
 # measurable benefit - the linker already strips unreferenced code via -gc-sections.
-_BK7231N_SYS_CONFIG_OPTIONS = [
+_BLE5_BK_SYS_CONFIG_OPTIONS = [
     "CFG_SUPPORT_BLE=0",
 ]
 
@@ -549,9 +553,9 @@ async def component_to_code(config):
         cg.add_platformio_option("custom_fw_version", __version__)
 
     # Apply chip-specific SDK options to save RAM/Flash
-    if config[CONF_FAMILY] == FAMILY_BK7231N:
+    if config[CONF_FAMILY] in (FAMILY_BK7231N, FAMILY_BK7238):
         cg.add_platformio_option(
-            "custom_options.sys_config#h", _BK7231N_SYS_CONFIG_OPTIONS
+            "custom_options.sys_config#h", _BLE5_BK_SYS_CONFIG_OPTIONS
         )
 
     # Tune lwIP for ESPHome's actual needs.

esphome/components/libretiny/core.cpp

@@ -1,55 +1,6 @@
 #ifdef USE_LIBRETINY
 
-#include "core.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
-#include "preferences.h"
-
-#include <FreeRTOS.h>
-#include <task.h>
-
-void setup();
-void loop();
-
-namespace esphome {
-
-// yield(), delay(), micros(), millis(), millis_64() inlined in hal.h.
-void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { ::delayMicroseconds(us); }
-
-void arch_init() {
-  libretiny::setup_preferences();
-  lt_wdt_enable(10000L);
-#ifdef USE_BK72XX
-  // BK72xx SDK creates the main Arduino task at priority 3, which is lower than
-  // all WiFi (4-5), LwIP (4), and TCP/IP (7) tasks. This causes ~100ms loop
-  // stalls whenever WiFi background processing runs, because the main task
-  // cannot resume until every higher-priority task finishes.
-  //
-  // By contrast, RTL87xx creates the main task at osPriorityRealtime (highest).
-  //
-  // Raise to priority 6: above WiFi/LwIP tasks (4-5) so they don't preempt the
-  // main loop, but below the TCP/IP thread (7) so packet processing keeps priority.
-  // This is safe because ESPHome yields voluntarily via wakeable_delay() and
-  // the Arduino mainTask yield() after each loop() iteration.
-  static constexpr UBaseType_t MAIN_TASK_PRIORITY = 6;
-  static_assert(MAIN_TASK_PRIORITY < configMAX_PRIORITIES, "MAIN_TASK_PRIORITY must be less than configMAX_PRIORITIES");
-  vTaskPrioritySet(nullptr, MAIN_TASK_PRIORITY);
-#endif
-#if LT_GPIO_RECOVER
-  lt_gpio_recover();
-#endif
-}
-
-void arch_restart() {
-  lt_reboot();
-  while (1) {
-  }
-}
-void HOT arch_feed_wdt() { lt_wdt_feed(); }
-uint32_t arch_get_cpu_cycle_count() { return lt_cpu_get_cycle_count(); }
-uint32_t arch_get_cpu_freq_hz() { return lt_cpu_get_freq(); }
-
-}  // namespace esphome
+// HAL functions live in hal.cpp. core.cpp is intentionally empty for
+// libretiny — there is no extra component bootstrap to keep here.
 
 #endif  // USE_LIBRETINY

esphome/components/libretiny/hal.cpp

@@ -0,0 +1,53 @@
+#ifdef USE_LIBRETINY
+
+#include "core.h"
+#include "esphome/core/hal.h"
+#include "preferences.h"
+
+#include <FreeRTOS.h>
+#include <task.h>
+
+// Empty libretiny namespace block to satisfy ci-custom's lint_namespace check.
+// HAL functions live in namespace esphome (root) — they are not part of the
+// libretiny component's API.
+namespace esphome::libretiny {}  // namespace esphome::libretiny
+
+namespace esphome {
+
+// yield(), delay(), micros(), millis(), millis_64(), delayMicroseconds(),
+// arch_feed_wdt(), arch_get_cpu_cycle_count(), arch_get_cpu_freq_hz()
+// inlined in components/libretiny/hal.h.
+
+void arch_init() {
+  libretiny::setup_preferences();
+  lt_wdt_enable(10000L);
+#ifdef USE_BK72XX
+  // BK72xx SDK creates the main Arduino task at priority 3, which is lower than
+  // all WiFi (4-5), LwIP (4), and TCP/IP (7) tasks. This causes ~100ms loop
+  // stalls whenever WiFi background processing runs, because the main task
+  // cannot resume until every higher-priority task finishes.
+  //
+  // By contrast, RTL87xx creates the main task at osPriorityRealtime (highest).
+  //
+  // Raise to priority 6: above WiFi/LwIP tasks (4-5) so they don't preempt the
+  // main loop, but below the TCP/IP thread (7) so packet processing keeps priority.
+  // This is safe because ESPHome yields voluntarily via wakeable_delay() and
+  // the Arduino mainTask yield() after each loop() iteration.
+  static constexpr UBaseType_t MAIN_TASK_PRIORITY = 6;
+  static_assert(MAIN_TASK_PRIORITY < configMAX_PRIORITIES, "MAIN_TASK_PRIORITY must be less than configMAX_PRIORITIES");
+  vTaskPrioritySet(nullptr, MAIN_TASK_PRIORITY);
+#endif
+#if LT_GPIO_RECOVER
+  lt_gpio_recover();
+#endif
+}
+
+void arch_restart() {
+  lt_reboot();
+  while (1) {
+  }
+}
+
+}  // namespace esphome
+
+#endif  // USE_LIBRETINY

esphome/components/libretiny/hal.h

@@ -51,8 +51,18 @@ extern "C" void yield(void);
 extern "C" void delay(unsigned long ms);
 extern "C" unsigned long micros(void);
 extern "C" unsigned long millis(void);
+extern "C" void delayMicroseconds(unsigned int us);
 // NOLINTEND(google-runtime-int,readability-identifier-naming,readability-redundant-declaration)
 
+// Forward decls from libretiny's <lt_api.h> family for the inline arch_*
+// wrappers below. Pulling the full header would drag in the rest of the
+// LibreTiny C API.
+extern "C" void lt_wdt_feed(void);
+extern "C" uint32_t lt_cpu_get_cycle_count(void);
+extern "C" uint32_t lt_cpu_get_freq(void);
+
+namespace esphome::libretiny {}
+
 namespace esphome {
 
 /// Returns true when executing inside an interrupt handler.
@@ -88,6 +98,14 @@ __attribute__((always_inline)) inline uint32_t millis() { return static_cast<uin
 #endif
 __attribute__((always_inline)) inline uint64_t millis_64() { return Millis64Impl::compute(millis()); }
 
+// NOLINTNEXTLINE(readability-identifier-naming)
+__attribute__((always_inline)) inline void delayMicroseconds(uint32_t us) { ::delayMicroseconds(us); }
+__attribute__((hot, always_inline)) inline void arch_feed_wdt() { lt_wdt_feed(); }
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_cycle_count() { return lt_cpu_get_cycle_count(); }
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_freq_hz() { return lt_cpu_get_freq(); }
+
+void arch_init();
+
 }  // namespace esphome
 
 #endif  // USE_LIBRETINY

esphome/components/light/automation.h

@@ -8,84 +8,59 @@ namespace esphome::light {
 
 enum class LimitMode { CLAMP, DO_NOTHING };
 
-template<typename... Ts> class ToggleAction : public Action<Ts...> {
+template<bool HasTransitionLength, typename... Ts> class ToggleAction : public Action<Ts...> {
  public:
   explicit ToggleAction(LightState *state) : state_(state) {}
 
-  TEMPLATABLE_VALUE(uint32_t, transition_length)
+  template<typename V> void set_transition_length(V value) requires(HasTransitionLength) {
+    this->transition_length_ = value;
+  }
 
   void play(const Ts &...x) override {
     auto call = this->state_->toggle();
-    call.set_transition_length(this->transition_length_.optional_value(x...));
+    if constexpr (HasTransitionLength) {
+      call.set_transition_length(this->transition_length_.optional_value(x...));
+    }
     call.perform();
   }
 
  protected:
   LightState *state_;
+  struct NoTransition {};
+  [[no_unique_address]] std::conditional_t<HasTransitionLength, TemplatableFn<uint32_t, Ts...>, NoTransition>
+      transition_length_{};
 };
 
+// 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. `brightness: !lambda "return x;"`) keep working.
 template<typename... Ts> class LightControlAction : public Action<Ts...> {
  public:
-  explicit LightControlAction(LightState *parent) : parent_(parent) {}
-
-  TEMPLATABLE_VALUE(ColorMode, color_mode)
-  TEMPLATABLE_VALUE(bool, state)
-  TEMPLATABLE_VALUE(uint32_t, transition_length)
-  TEMPLATABLE_VALUE(uint32_t, flash_length)
-  TEMPLATABLE_VALUE(float, brightness)
-  TEMPLATABLE_VALUE(float, color_brightness)
-  TEMPLATABLE_VALUE(float, red)
-  TEMPLATABLE_VALUE(float, green)
-  TEMPLATABLE_VALUE(float, blue)
-  TEMPLATABLE_VALUE(float, white)
-  TEMPLATABLE_VALUE(float, color_temperature)
-  TEMPLATABLE_VALUE(float, cold_white)
-  TEMPLATABLE_VALUE(float, warm_white)
-  TEMPLATABLE_VALUE(uint32_t, effect)
+  using ApplyFn = void (*)(LightState *, LightCall &, const Ts &...);
+  LightControlAction(LightState *parent, ApplyFn apply) : parent_(parent), apply_(apply) {}
 
   void play(const Ts &...x) override {
     auto call = this->parent_->make_call();
-    if (this->color_mode_.has_value())
-      call.set_color_mode(this->color_mode_.value(x...));
-    if (this->state_.has_value())
-      call.set_state(this->state_.value(x...));
-    if (this->transition_length_.has_value())
-      call.set_transition_length(this->transition_length_.value(x...));
-    if (this->flash_length_.has_value())
-      call.set_flash_length(this->flash_length_.value(x...));
-    if (this->brightness_.has_value())
-      call.set_brightness(this->brightness_.value(x...));
-    if (this->color_brightness_.has_value())
-      call.set_color_brightness(this->color_brightness_.value(x...));
-    if (this->red_.has_value())
-      call.set_red(this->red_.value(x...));
-    if (this->green_.has_value())
-      call.set_green(this->green_.value(x...));
-    if (this->blue_.has_value())
-      call.set_blue(this->blue_.value(x...));
-    if (this->white_.has_value())
-      call.set_white(this->white_.value(x...));
-    if (this->color_temperature_.has_value())
-      call.set_color_temperature(this->color_temperature_.value(x...));
-    if (this->cold_white_.has_value())
-      call.set_cold_white(this->cold_white_.value(x...));
-    if (this->warm_white_.has_value())
-      call.set_warm_white(this->warm_white_.value(x...));
-    if (this->effect_.has_value())
-      call.set_effect(this->effect_.value(x...));
+    this->apply_(this->parent_, call, x...);
     call.perform();
   }
 
  protected:
   LightState *parent_;
+  ApplyFn apply_;
 };
 
-template<typename... Ts> class DimRelativeAction : public Action<Ts...> {
+template<bool HasTransitionLength, typename... Ts> class DimRelativeAction : public Action<Ts...> {
  public:
   explicit DimRelativeAction(LightState *parent) : parent_(parent) {}
 
   TEMPLATABLE_VALUE(float, relative_brightness)
-  TEMPLATABLE_VALUE(uint32_t, transition_length)
+
+  template<typename V> void set_transition_length(V value) requires(HasTransitionLength) {
+    this->transition_length_ = value;
+  }
 
   void play(const Ts &...x) override {
     auto call = this->parent_->make_call();
@@ -99,7 +74,9 @@ template<typename... Ts> class DimRelativeAction : public Action<Ts...> {
     call.set_state(new_brightness != 0.0f);
     call.set_brightness(new_brightness);
 
-    call.set_transition_length(this->transition_length_.optional_value(x...));
+    if constexpr (HasTransitionLength) {
+      call.set_transition_length(this->transition_length_.optional_value(x...));
+    }
     call.perform();
   }
 
@@ -115,6 +92,9 @@ template<typename... Ts> class DimRelativeAction : public Action<Ts...> {
   float min_brightness_{0.0};
   float max_brightness_{1.0};
   LimitMode limit_mode_{LimitMode::CLAMP};
+  struct NoTransition {};
+  [[no_unique_address]] std::conditional_t<HasTransitionLength, TemplatableFn<uint32_t, Ts...>, NoTransition>
+      transition_length_{};
 };
 
 template<typename... Ts> class LightIsOnCondition : public Condition<Ts...> {

esphome/components/light/automation.py

@@ -37,6 +37,7 @@ from .types import (
     AddressableSet,
     ColorMode,
     DimRelativeAction,
+    LightCall,
     LightControlAction,
     LightIsOffCondition,
     LightIsOnCondition,
@@ -60,8 +61,10 @@ from .types import (
 )
 async def light_toggle_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_TRANSITION_LENGTH in config:
+    has_transition_length = CONF_TRANSITION_LENGTH in config
+    toggle_template_arg = cg.TemplateArguments(has_transition_length, *template_arg)
+    var = cg.new_Pvariable(action_id, toggle_template_arg, paren)
+    if has_transition_length:
         template_ = await cg.templatable(
             config[CONF_TRANSITION_LENGTH], args, cg.uint32
         )
@@ -178,9 +181,9 @@ def _resolve_effect_index(config: ConfigType) -> int:
 )
 async def light_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)
 
-    # (config_key, setter_name, c++ type)
+    # All configured fields are folded into a single stateless lambda whose
+    # constants live in flash; the action stores only a function pointer.
     FIELDS = (
         (CONF_COLOR_MODE, "set_color_mode", ColorMode),
         (CONF_STATE, "set_state", cg.bool_),
@@ -196,38 +199,50 @@ async def light_control_to_code(config, action_id, template_arg, args):
         (CONF_COLD_WHITE, "set_cold_white", cg.float_),
         (CONF_WARM_WHITE, "set_warm_white", cg.float_),
     )
+
+    fwd_args = ", ".join(name for _, name in args)
+    body_lines: list[str] = []
+
     for conf_key, setter, type_ in FIELDS:
-        if conf_key in config:
-            template_ = await cg.templatable(config[conf_key], args, type_)
-            cg.add(getattr(var, setter)(template_))
+        if conf_key not in config:
+            continue
+        value = config[conf_key]
+        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)});")
 
     if CONF_EFFECT in config:
         if isinstance(config[CONF_EFFECT], Lambda):
-            # Lambda returns a string — wrap in a C++ lambda that resolves
-            # the effect name to its uint32_t index at runtime
             inner_lambda = await cg.process_lambda(
                 config[CONF_EFFECT], args, return_type=cg.std_string
             )
-            fwd_args = ", ".join(n for _, n in args)
-            # capture="" is correct: paren is a global variable name
-            # string-interpolated into the body at codegen time, not a
-            # C++ runtime capture.
-            wrapper = LambdaExpression(
-                f"auto __effect_s = ({inner_lambda})({fwd_args});\n"
-                f"return {paren}->get_effect_index("
-                f"__effect_s.c_str(), __effect_s.size());",
-                args,
-                capture="",
-                return_type=cg.uint32,
+            body_lines.append(
+                f"{{ auto __effect_s = ({inner_lambda})({fwd_args});\n"
+                f"call.set_effect(parent->get_effect_index("
+                f"__effect_s.c_str(), __effect_s.size())); }}"
             )
-            cg.add(var.set_effect(wrapper))
         else:
-            # Static string — resolve effect name to index at codegen time
-            template_ = await cg.templatable(
-                _resolve_effect_index(config), args, cg.uint32
+            # Cast disambiguates between set_effect(uint32_t) and
+            # set_effect(optional<uint32_t>) when the literal is an int.
+            body_lines.append(
+                f"call.set_effect(static_cast<uint32_t>({_resolve_effect_index(config)}));"
             )
-            cg.add(var.set_effect(template_))
-    return var
+
+    # Match LightControlAction::ApplyFn signature: const Ts &... for trigger args.
+    apply_args = [
+        (LightState.operator("ptr"), "parent"),
+        (LightCall.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)
 
 
 CONF_RELATIVE_BRIGHTNESS = "relative_brightness"
@@ -261,10 +276,12 @@ LIGHT_DIM_RELATIVE_ACTION_SCHEMA = cv.Schema(
 )
 async def light_dim_relative_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)
+    has_transition_length = CONF_TRANSITION_LENGTH in config
+    dim_template_arg = cg.TemplateArguments(has_transition_length, *template_arg)
+    var = cg.new_Pvariable(action_id, dim_template_arg, paren)
     templ = await cg.templatable(config[CONF_RELATIVE_BRIGHTNESS], args, cg.float_)
     cg.add(var.set_relative_brightness(templ))
-    if CONF_TRANSITION_LENGTH in config:
+    if has_transition_length:
         templ = await cg.templatable(config[CONF_TRANSITION_LENGTH], args, cg.uint32)
         cg.add(var.set_transition_length(templ))
     if conf := config.get(CONF_BRIGHTNESS_LIMITS):

esphome/components/light/types.py

@@ -13,6 +13,7 @@ Color = cg.esphome_ns.class_("Color")
 LightColorValues = light_ns.class_("LightColorValues")
 
 LightStateRTCState = light_ns.struct("LightStateRTCState")
+LightCall = light_ns.class_("LightCall")
 
 # Color modes
 ColorMode = light_ns.enum("ColorMode", is_class=True)

esphome/components/lvgl/lvgl_esphome.cpp

@@ -454,10 +454,12 @@ void LVTouchListener::update(const touchscreen::TouchPoints_t &tpoints) {
 
 #ifdef USE_LVGL_METER
 
-int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int value) {
+int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int32_t value) {
   auto *scale = lv_obj_get_parent(obj);
   auto min_value = lv_scale_get_range_min_value(scale);
-  return ((value - min_value) * lv_scale_get_angle_range(scale) / (lv_scale_get_range_max_value(scale) - min_value) +
+  auto max_value = lv_scale_get_range_max_value(scale);
+  value = clamp(value, min_value, max_value);
+  return ((value - min_value) * lv_scale_get_angle_range(scale) / (max_value - min_value) +
           lv_scale_get_rotation((scale))) %
          360;
 }

esphome/components/lvgl/lvgl_esphome.h

@@ -112,7 +112,7 @@ inline void lv_animimg_set_src(lv_obj_t *img, std::vector<image::Image *> images
 #endif  // USE_LVGL_ANIMIMG
 
 #ifdef USE_LVGL_METER
-int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int value);
+int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int32_t value);
 #endif
 
 #ifdef USE_LVGL_GRADIENT

esphome/components/mcp23xxx_base/__init__.py

@@ -2,6 +2,7 @@ from esphome import pins
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ALLOW_OTHER_USES,
     CONF_ID,
     CONF_INPUT,
     CONF_INTERRUPT,
@@ -30,10 +31,29 @@ MCP23XXX_INTERRUPT_MODES = {
     "FALLING": MCP23XXXInterruptMode.MCP23XXX_FALLING,
 }
 
+
+def _validate_interrupt_pin(value):
+    # The MCP component owns INT polarity (active-low, hardcoded falling-edge ISR)
+    # and installs a single ISR per GPIO, so neither inversion nor sharing is supported.
+    value = pins.internal_gpio_input_pin_schema(value)
+    if value.get(CONF_INVERTED):
+        raise cv.Invalid(
+            f"'{CONF_INVERTED}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
+            "the MCP23xxx INT line is fixed active-low"
+        )
+    if value.get(CONF_ALLOW_OTHER_USES):
+        raise cv.Invalid(
+            f"'{CONF_ALLOW_OTHER_USES}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
+            "sharing the interrupt pin between multiple MCP23xxx (or other components) "
+            "is not implemented. Remove the interrupt_pin to fall back to polling."
+        )
+    return value
+
+
 MCP23XXX_CONFIG_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_OPEN_DRAIN_INTERRUPT, default=False): cv.boolean,
-        cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
+        cv.Optional(CONF_INTERRUPT_PIN): _validate_interrupt_pin,
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/mdns/mdns_component.cpp

@@ -39,7 +39,39 @@ MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
 // Wrap build-time defines into flash storage
 MDNS_STATIC_CONST_CHAR(VALUE_VERSION, ESPHOME_VERSION);
 
-void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services, char *mac_address_buf) {
+void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {
+#ifdef USE_MDNS_STORE_SERVICES
+  auto &services = this->services_;
+#else
+  StaticVector<MDNSService, MDNS_SERVICE_COUNT> services_storage;
+  auto &services = services_storage;
+#endif
+
+#ifdef USE_API
+#ifdef USE_MDNS_STORE_SERVICES
+  get_mac_address_into_buffer(this->mac_address_);
+  char *mac_ptr = this->mac_address_;
+  format_hex_to(this->config_hash_str_, App.get_config_hash());
+  char *cfg_ptr = this->config_hash_str_;
+#else
+  char mac_address[MAC_ADDRESS_BUFFER_SIZE];
+  char config_hash_str[CONFIG_HASH_STR_SIZE];
+  get_mac_address_into_buffer(mac_address);
+  format_hex_to(config_hash_str, App.get_config_hash());
+  char *mac_ptr = mac_address;
+  char *cfg_ptr = config_hash_str;
+#endif
+#else
+  char *mac_ptr = nullptr;
+  char *cfg_ptr = nullptr;
+#endif
+
+  this->compile_records_(services, mac_ptr, cfg_ptr);
+  platform_register(this, services);
+}
+
+void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services, char *mac_address_buf,
+                                     char *config_hash_buf) {
   // IMPORTANT: The #ifdef blocks below must match COMPONENTS_WITH_MDNS_SERVICES
   // in mdns/__init__.py. If you add a new service here, update both locations.
 
@@ -47,6 +79,7 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
   MDNS_STATIC_CONST_CHAR(SERVICE_ESPHOMELIB, "_esphomelib");
   MDNS_STATIC_CONST_CHAR(TXT_FRIENDLY_NAME, "friendly_name");
   MDNS_STATIC_CONST_CHAR(TXT_VERSION, "version");
+  MDNS_STATIC_CONST_CHAR(TXT_CONFIG_HASH, "config_hash");
   MDNS_STATIC_CONST_CHAR(TXT_MAC, "mac");
   MDNS_STATIC_CONST_CHAR(TXT_PLATFORM, "platform");
   MDNS_STATIC_CONST_CHAR(TXT_BOARD, "board");
@@ -63,7 +96,7 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
     bool friendly_name_empty = friendly_name.empty();
 
     // Calculate exact capacity for txt_records
-    size_t txt_count = 3;  // version, mac, board (always present)
+    size_t txt_count = 4;  // version, config_hash, mac, board (always present)
     if (!friendly_name_empty) {
       txt_count++;  // friendly_name
     }
@@ -91,6 +124,9 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
     }
     txt_records.push_back({MDNS_STR(TXT_VERSION), MDNS_STR(VALUE_VERSION)});
 
+    // Config hash: passed from caller (either member buffer or stack buffer depending on USE_MDNS_STORE_SERVICES)
+    txt_records.push_back({MDNS_STR(TXT_CONFIG_HASH), MDNS_STR(config_hash_buf)});
+
     // MAC address: passed from caller (either member buffer or stack buffer depending on USE_MDNS_STORE_SERVICES)
     txt_records.push_back({MDNS_STR(TXT_MAC), MDNS_STR(mac_address_buf)});
 

esphome/components/mdns/mdns_component.h

@@ -70,6 +70,9 @@ class MDNSComponent final : public Component
   void setup() override;
   void dump_config() override;
 
+  /// Size of buffer required for config hash hex string (8 hex chars + null terminator)
+  static constexpr size_t CONFIG_HASH_STR_SIZE = format_hex_size(sizeof(uint32_t));
+
 #ifdef USE_MDNS_EVENT_DRIVEN_POLLING
   // LEAmDNS has meaningful work only during the probe+announce phase (3×250ms probes +
   // 8×1000ms announces, ~9s). Afterwards every internal timer is resetToNeverExpires()
@@ -124,30 +127,7 @@ class MDNSComponent final : public Component
   /// Helper to set up services and MAC buffers, then call platform-specific registration
   using PlatformRegisterFn = void (*)(MDNSComponent *, StaticVector<MDNSService, MDNS_SERVICE_COUNT> &);
 
-  void setup_buffers_and_register_(PlatformRegisterFn platform_register) {
-#ifdef USE_MDNS_STORE_SERVICES
-    auto &services = this->services_;
-#else
-    StaticVector<MDNSService, MDNS_SERVICE_COUNT> services_storage;
-    auto &services = services_storage;
-#endif
-
-#ifdef USE_API
-#ifdef USE_MDNS_STORE_SERVICES
-    get_mac_address_into_buffer(this->mac_address_);
-    char *mac_ptr = this->mac_address_;
-#else
-    char mac_address[MAC_ADDRESS_BUFFER_SIZE];
-    get_mac_address_into_buffer(mac_address);
-    char *mac_ptr = mac_address;
-#endif
-#else
-    char *mac_ptr = nullptr;
-#endif
-
-    this->compile_records_(services, mac_ptr);
-    platform_register(this, services);
-  }
+  void setup_buffers_and_register_(PlatformRegisterFn platform_register);
 
 #ifdef USE_MDNS_DYNAMIC_TXT
   /// Storage for runtime-generated TXT values from user lambdas
@@ -159,6 +139,8 @@ class MDNSComponent final : public Component
 #if defined(USE_API) && defined(USE_MDNS_STORE_SERVICES)
   /// Fixed buffer for MAC address (only needed when services are stored)
   char mac_address_[MAC_ADDRESS_BUFFER_SIZE];
+  /// Fixed buffer for config hash hex string (only needed when services are stored)
+  char config_hash_str_[CONFIG_HASH_STR_SIZE];
 #endif
 #ifdef USE_MDNS_STORE_SERVICES
   StaticVector<MDNSService, MDNS_SERVICE_COUNT> services_{};
@@ -167,7 +149,8 @@ class MDNSComponent final : public Component
   // RP2040 defers MDNS.begin() until the first IP-up event; this tracks that.
   bool initialized_{false};
 #endif
-  void compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services, char *mac_address_buf);
+  void compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services, char *mac_address_buf,
+                        char *config_hash_buf);
 };
 
 }  // namespace esphome::mdns

esphome/components/mdns/mdns_host.cpp

@@ -3,6 +3,8 @@
 
 #include "esphome/components/network/ip_address.h"
 #include "esphome/components/network/util.h"
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "mdns_component.h"
 
@@ -13,10 +15,13 @@ void MDNSComponent::setup() {
 #ifdef USE_API
   get_mac_address_into_buffer(this->mac_address_);
   char *mac_ptr = this->mac_address_;
+  format_hex_to(this->config_hash_str_, App.get_config_hash());
+  char *cfg_ptr = this->config_hash_str_;
 #else
   char *mac_ptr = nullptr;
+  char *cfg_ptr = nullptr;
 #endif
-  this->compile_records_(this->services_, mac_ptr);
+  this->compile_records_(this->services_, mac_ptr, cfg_ptr);
 #endif
   // Host platform doesn't have actual mDNS implementation
 }

esphome/components/mixer/speaker/mixer_speaker.cpp

@@ -588,6 +588,7 @@ void MixerSpeaker::mix_audio_samples(const int16_t *primary_buffer, audio::Audio
   }
 }
 
+// NOLINTBEGIN(bugprone-unchecked-optional-access) -- audio_stream_info_ always set before this task is created
 void MixerSpeaker::audio_mixer_task(void *params) {
   MixerSpeaker *this_mixer = static_cast<MixerSpeaker *>(params);
 
@@ -764,6 +765,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
 
   vTaskSuspend(nullptr);  // Suspend this task indefinitely until the loop method deletes it
 }
+// NOLINTEND(bugprone-unchecked-optional-access)
 
 }  // namespace esphome::mixer_speaker
 

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -88,6 +88,33 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
       this->write_array(buffer, buffer_size);
       App.feed_wdt();
       this->recv_ret_string_(recv_string, NEXTION_UPLOAD_ACK_TIMEOUT_MS, true);
+
+      // Some Nextion firmware variants (notably bootloader/recovery mode on panels
+      // with no installed TFT) emit the 5-byte 0x08+position fast-mode ack with a
+      // multi-second gap between the leading 0x08 byte and the 4 trailing position
+      // bytes. recv_ret_string_ returns after the first byte; manually drain the
+      // trailing bytes from the UART before continuing.
+      if (!recv_string.empty() && recv_string[0] == 0x08 && recv_string.size() < 5) {
+        const uint32_t deadline = millis() + NEXTION_UPLOAD_ACK_TIMEOUT_MS;
+        while (recv_string.size() < 5 && millis() < deadline) {
+          if (this->available()) {
+            uint8_t b = 0;
+            if (this->read_byte(&b)) {
+              recv_string.push_back(static_cast<char>(b));
+            }
+          } else {
+            delay(5);  // NOLINT
+            App.feed_wdt();
+          }
+        }
+        if (recv_string.size() < 5) {
+          ESP_LOGE(TAG, "Truncated 0x08 response: got %zu bytes within %" PRIu32 "ms", recv_string.size(),
+                   NEXTION_UPLOAD_ACK_TIMEOUT_MS);
+          allocator.deallocate(buffer, 4096);
+          buffer = nullptr;
+          return -1;
+        }
+      }
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
       ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 ")", upload_percentage, this->content_length_,

esphome/components/nextion/nextion_upload_esp32.cpp

@@ -104,6 +104,33 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
       this->write_array(buffer, buffer_size);
       App.feed_wdt();
       this->recv_ret_string_(recv_string, NEXTION_UPLOAD_ACK_TIMEOUT_MS, true);
+
+      // Some Nextion firmware variants (notably bootloader/recovery mode on panels
+      // with no installed TFT) emit the 5-byte 0x08+position fast-mode ack with a
+      // multi-second gap between the leading 0x08 byte and the 4 trailing position
+      // bytes. recv_ret_string_ returns after the first byte; manually drain the
+      // trailing bytes from the UART before continuing.
+      if (!recv_string.empty() && recv_string[0] == 0x08 && recv_string.size() < 5) {
+        const uint32_t deadline = millis() + NEXTION_UPLOAD_ACK_TIMEOUT_MS;
+        while (recv_string.size() < 5 && millis() < deadline) {
+          if (this->available()) {
+            uint8_t b = 0;
+            if (this->read_byte(&b)) {
+              recv_string.push_back(static_cast<char>(b));
+            }
+          } else {
+            vTaskDelay(pdMS_TO_TICKS(5));  // NOLINT
+            App.feed_wdt();
+          }
+        }
+        if (recv_string.size() < 5) {
+          ESP_LOGE(TAG, "Truncated 0x08 response: got %zu bytes within %" PRIu32 "ms", recv_string.size(),
+                   NEXTION_UPLOAD_ACK_TIMEOUT_MS);
+          allocator.deallocate(buffer, 4096);
+          buffer = nullptr;
+          return -1;
+        }
+      }
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
 #ifdef USE_PSRAM

esphome/components/nrf52/uicr.cpp

@@ -11,6 +11,7 @@ void nvmc_wait();
 nrfx_err_t nrfx_nvmc_uicr_erase();
 }
 
+// NOLINTBEGIN(clang-analyzer-core.FixedAddressDereference) -- NRF_UICR / NRF_TIMER2 are MMIO at fixed addresses
 namespace esphome::nrf52 {
 
 enum class StatusFlags : uint8_t {
@@ -113,6 +114,7 @@ static int board_esphome_init() {
   return 0;
 }
 }  // namespace esphome::nrf52
+// NOLINTEND(clang-analyzer-core.FixedAddressDereference)
 
 static int board_esphome_init() { return esphome::nrf52::board_esphome_init(); }
 

esphome/components/ota/__init__.py

@@ -24,6 +24,8 @@ def AUTO_LOAD() -> list[str]:
     components = ["safe_mode"]
     if not CORE.using_zephyr:
         components.extend(["md5"])
+    if CORE.is_esp32:
+        components.extend(["watchdog"])
     return components
 
 

esphome/components/ota/ota_backend.h

@@ -4,6 +4,8 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 
+#include <cstdint>
+
 #ifdef USE_OTA_STATE_LISTENER
 #include <vector>
 #endif
@@ -23,6 +25,7 @@ enum OTAResponseTypes {
   OTA_RESPONSE_UPDATE_END_OK = 0x45,
   OTA_RESPONSE_SUPPORTS_COMPRESSION = 0x46,
   OTA_RESPONSE_CHUNK_OK = 0x47,
+  OTA_RESPONSE_FEATURE_FLAGS = 0x48,
 
   OTA_RESPONSE_ERROR_MAGIC = 0x80,
   OTA_RESPONSE_ERROR_UPDATE_PREPARE = 0x81,
@@ -38,6 +41,7 @@ enum OTAResponseTypes {
   OTA_RESPONSE_ERROR_MD5_MISMATCH = 0x8B,
   OTA_RESPONSE_ERROR_RP2040_NOT_ENOUGH_SPACE = 0x8C,
   OTA_RESPONSE_ERROR_SIGNATURE_INVALID = 0x8D,
+  OTA_RESPONSE_ERROR_UNSUPPORTED_OTA_TYPE = 0x8E,
   OTA_RESPONSE_ERROR_UNKNOWN = 0xFF,
 };
 
@@ -49,6 +53,10 @@ enum OTAState {
   OTA_ERROR,
 };
 
+enum OTAType : uint8_t {
+  OTA_TYPE_UPDATE_APP = 0x00,
+};
+
 /** Listener interface for OTA state changes.
  *
  * Components can implement this interface to receive OTA state updates

esphome/components/ota/ota_backend_esp8266.cpp

@@ -60,6 +60,7 @@ OTAResponseTypes ESP8266OTABackend::begin(size_t image_size) {
 
   // Check boot mode - if boot mode is UART download mode,
   // we will not be able to reset into normal mode once update is done
+  // NOLINTNEXTLINE(clang-analyzer-core.FixedAddressDereference) -- GPI is MMIO at a fixed address
   int boot_mode = (GPI >> BOOT_MODE_SHIFT) & BOOT_MODE_MASK;
   if (boot_mode == BOOT_MODE_UART_DOWNLOAD) {
     return OTA_RESPONSE_ERROR_INVALID_BOOTSTRAPPING;

esphome/components/ota/ota_backend_esp_idf.cpp

@@ -2,6 +2,7 @@
 #include "ota_backend_esp_idf.h"
 
 #include "esphome/components/md5/md5.h"
+#include "esphome/components/watchdog/watchdog.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/log.h"
 
@@ -28,29 +29,9 @@ OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
     return OTA_RESPONSE_ERROR_NO_UPDATE_PARTITION;
   }
 
-#if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
-  // The following function takes longer than the 5 seconds timeout of WDT
-  esp_task_wdt_config_t wdtc;
-  wdtc.idle_core_mask = 0;
-#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
-  wdtc.idle_core_mask |= (1 << 0);
-#endif
-#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
-  wdtc.idle_core_mask |= (1 << 1);
-#endif
-  wdtc.timeout_ms = 15000;
-  wdtc.trigger_panic = false;
-  esp_task_wdt_reconfigure(&wdtc);
-#endif
-
+  watchdog::WatchdogManager watchdog(15000);
   esp_err_t err = esp_ota_begin(this->partition_, image_size, &this->update_handle_);
 
-#if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
-  // Set the WDT back to the configured timeout
-  wdtc.timeout_ms = CONFIG_ESP_TASK_WDT_TIMEOUT_S * 1000;
-  esp_task_wdt_reconfigure(&wdtc);
-#endif
-
   if (err != ESP_OK) {
     esp_ota_abort(this->update_handle_);
     this->update_handle_ = 0;

esphome/components/remote_base/remote_base.h

@@ -164,7 +164,7 @@ class RemoteTransmitterBase : public RemoteComponentBase {
     return TransmitCall(this);
   }
   template<typename Protocol>
-  void transmit(const typename Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
+  void transmit(const Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
     auto call = this->transmit();
     Protocol().encode(call.get_data(), data);
     call.set_send_times(send_times);
@@ -250,10 +250,10 @@ template<typename T> class RemoteReceiverBinarySensor : public RemoteReceiverBin
   }
 
  public:
-  void set_data(typename T::ProtocolData data) { data_ = data; }
+  void set_data(T::ProtocolData data) { data_ = data; }
 
  protected:
-  typename T::ProtocolData data_;
+  T::ProtocolData data_;
 };
 
 template<typename T>
@@ -278,7 +278,7 @@ class RemoteTransmittable {
 
  protected:
   template<typename Protocol>
-  void transmit_(const typename Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
+  void transmit_(const Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
     this->transmitter_->transmit<Protocol>(data, send_times, send_wait);
   }
   RemoteTransmitterBase *transmitter_;

esphome/components/rp2040/core.cpp

@@ -1,41 +1,6 @@
 #ifdef USE_RP2040
 
-#include "core.h"
-#include "esphome/core/defines.h"
-#ifdef USE_RP2040_CRASH_HANDLER
-#include "crash_handler.h"
-#endif
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
-
-#include "hardware/timer.h"
-#include "hardware/watchdog.h"
-
-namespace esphome {
-
-// yield(), delay(), micros(), millis(), millis_64() inlined in hal.h.
-void HOT delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
-void arch_restart() {
-  watchdog_reboot(0, 0, 10);
-  while (1) {
-    continue;
-  }
-}
-
-void arch_init() {
-#ifdef USE_RP2040_CRASH_HANDLER
-  rp2040::crash_handler_read_and_clear();
-#endif
-#if USE_RP2040_WATCHDOG_TIMEOUT > 0
-  watchdog_enable(USE_RP2040_WATCHDOG_TIMEOUT, false);
-#endif
-}
-
-void HOT arch_feed_wdt() { watchdog_update(); }
-
-uint32_t HOT arch_get_cpu_cycle_count() { return ulMainGetRunTimeCounterValue(); }
-uint32_t arch_get_cpu_freq_hz() { return RP2040::f_cpu(); }
-
-}  // namespace esphome
+// HAL functions live in hal.cpp. core.cpp is intentionally empty for
+// rp2040 — there is no extra component bootstrap to keep here.
 
 #endif  // USE_RP2040

esphome/components/rp2040/hal.cpp

@@ -0,0 +1,41 @@
+#ifdef USE_RP2040
+
+#include "core.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/hal.h"
+#ifdef USE_RP2040_CRASH_HANDLER
+#include "crash_handler.h"
+#endif
+
+#include "hardware/watchdog.h"
+
+// Empty rp2040 namespace block to satisfy ci-custom's lint_namespace check.
+// HAL functions live in namespace esphome (root) — they are not part of the
+// rp2040 component's API.
+namespace esphome::rp2040 {}  // namespace esphome::rp2040
+
+namespace esphome {
+
+// yield(), delay(), micros(), millis(), millis_64(), delayMicroseconds(),
+// arch_feed_wdt(), arch_get_cpu_cycle_count() inlined in components/rp2040/hal.h.
+void arch_restart() {
+  watchdog_reboot(0, 0, 10);
+  while (1) {
+    continue;
+  }
+}
+
+void arch_init() {
+#ifdef USE_RP2040_CRASH_HANDLER
+  rp2040::crash_handler_read_and_clear();
+#endif
+#if USE_RP2040_WATCHDOG_TIMEOUT > 0
+  watchdog_enable(USE_RP2040_WATCHDOG_TIMEOUT, false);
+#endif
+}
+
+uint32_t arch_get_cpu_freq_hz() { return RP2040::f_cpu(); }
+
+}  // namespace esphome
+
+#endif  // USE_RP2040

esphome/components/rp2040/hal.h

@@ -20,8 +20,19 @@ extern "C" unsigned long millis(void);
 // Forward decl from <pico/time.h>.
 extern "C" uint64_t time_us_64(void);
 
+// Forward decls from pico-sdk / FreeRTOS port for the inline arch_*
+// wrappers below.
+extern "C" void watchdog_update(void);
+extern "C" unsigned long ulMainGetRunTimeCounterValue(void);
+
+namespace esphome::rp2040 {}
+
 namespace esphome {
 
+// Forward decl from 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() {
   uint32_t ipsr;
@@ -35,6 +46,16 @@ __attribute__((always_inline)) inline uint32_t micros() { return static_cast<uin
 __attribute__((always_inline)) inline uint32_t millis() { return micros_to_millis(::time_us_64()); }
 __attribute__((always_inline)) inline uint64_t millis_64() { return micros_to_millis<uint64_t>(::time_us_64()); }
 
+// 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() { watchdog_update(); }
+__attribute__((always_inline)) inline uint32_t arch_get_cpu_cycle_count() {
+  return static_cast<uint32_t>(ulMainGetRunTimeCounterValue());
+}
+
+void arch_init();
+uint32_t arch_get_cpu_freq_hz();
+
 }  // namespace esphome
 
 #endif  // USE_RP2040

esphome/components/sendspin/__init__.py

@@ -24,6 +24,7 @@ CONF_SENDSPIN_ID = "sendspin_id"
 
 CONF_INITIAL_STATIC_DELAY = "initial_static_delay"
 CONF_FIXED_DELAY = "fixed_delay"
+CONF_DECODE_MEMORY = "decode_memory"
 
 # sendspin-cpp library lives in the global `sendspin` namespace.
 sendspin_library_ns = cg.global_ns.namespace("sendspin")
@@ -39,6 +40,18 @@ CODEC_FORMAT_UNSUPPORTED = SendspinCodecFormat.enum("UNSUPPORTED")
 AudioSupportedFormatObject = sendspin_library_ns.struct("AudioSupportedFormatObject")
 PlayerRoleConfig = sendspin_library_ns.struct("PlayerRoleConfig")
 
+# MemoryLocation enum (from sendspin/types.h) controls SPIRAM-vs-internal-RAM placement
+# preference for the player role's transfer buffers.
+SendspinMemoryLocation = sendspin_library_ns.enum("MemoryLocation", is_class=True)
+
+MEMORY_PSRAM = "psram"
+MEMORY_INTERNAL = "internal"
+MEMORY_LOCATIONS = [MEMORY_PSRAM, MEMORY_INTERNAL]
+MEMORY_LOCATION_ENUM = {
+    MEMORY_PSRAM: SendspinMemoryLocation.PREFER_EXTERNAL,
+    MEMORY_INTERNAL: SendspinMemoryLocation.PREFER_INTERNAL,
+}
+
 # Trailing underscore avoids clashing with sendspin-cpp's global `sendspin` namespace.
 # Analysis tools strip the trailing underscore (same pattern as `template_`).
 sendspin_ns = cg.esphome_ns.namespace("sendspin_")
@@ -193,7 +206,7 @@ async def to_code(config: ConfigType) -> None:
         )
 
     # sendspin-cpp library
-    esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.3.1")
+    esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.4.0")
 
     cg.add_define("USE_SENDSPIN", True)  # for MDNS
 
@@ -249,14 +262,23 @@ async def to_code(config: ConfigType) -> None:
                 "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
             )
 
-        player_config_struct = cg.StructInitializer(
-            PlayerRoleConfig,
+        # Library defaults: priority 18 (one above httpd_priority 17 so the decoder is not
+        # starved by the HTTP server during the initial encoded-audio burst at stream start),
+        # interpolation/decode buffer locations PREFER_EXTERNAL.
+        player_struct_fields = [
             ("audio_formats", audio_format_structs),
             ("audio_buffer_capacity", player_cfg[CONF_BUFFER_SIZE]),
             ("fixed_delay_us", player_cfg[CONF_FIXED_DELAY]),
             ("initial_static_delay_ms", player_cfg[CONF_INITIAL_STATIC_DELAY]),
             ("psram_stack", psram_stack),
-            ("priority", 2),
+        ]
+        if (decode_memory := player_cfg.get(CONF_DECODE_MEMORY)) is not None:
+            player_struct_fields.append(
+                ("decode_buffer_location", MEMORY_LOCATION_ENUM[decode_memory])
+            )
+        player_config_struct = cg.StructInitializer(
+            PlayerRoleConfig,
+            *player_struct_fields,
         )
         cg.add(var.set_player_config(player_config_struct))
     else:

esphome/components/sendspin/media_source/__init__.py

@@ -13,9 +13,11 @@ from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 from .. import (
+    CONF_DECODE_MEMORY,
     CONF_FIXED_DELAY,
     CONF_INITIAL_STATIC_DELAY,
     CONF_SENDSPIN_ID,
+    MEMORY_LOCATIONS,
     SendspinHub,
     _validate_task_stack_in_psram,
     register_player_config,
@@ -57,6 +59,7 @@ def _register(config: ConfigType) -> ConfigType:
             CONF_INITIAL_STATIC_DELAY: config[CONF_INITIAL_STATIC_DELAY],
             CONF_FIXED_DELAY: config[CONF_FIXED_DELAY],
             CONF_TASK_STACK_IN_PSRAM: config.get(CONF_TASK_STACK_IN_PSRAM, False),
+            CONF_DECODE_MEMORY: config.get(CONF_DECODE_MEMORY),
         }
     )
     return config
@@ -82,6 +85,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_SAMPLE_RATE, default=48000): cv.int_range(
                 min=16000, max=96000
             ),
+            cv.Optional(CONF_DECODE_MEMORY): cv.one_of(*MEMORY_LOCATIONS, lower=True),
         }
     ),
     cv.only_on_esp32,

esphome/components/sensor/__init__.py

@@ -266,7 +266,7 @@ StreamingMovingAverageFilter = sensor_ns.class_("StreamingMovingAverageFilter",
 ExponentialMovingAverageFilter = sensor_ns.class_(
     "ExponentialMovingAverageFilter", Filter
 )
-ThrottleAverageFilter = sensor_ns.class_("ThrottleAverageFilter", Filter, cg.Component)
+ThrottleAverageFilter = sensor_ns.class_("ThrottleAverageFilter", Filter)
 LambdaFilter = sensor_ns.class_("LambdaFilter", Filter)
 StatelessLambdaFilter = sensor_ns.class_("StatelessLambdaFilter", Filter)
 OffsetFilter = sensor_ns.class_("OffsetFilter", Filter)
@@ -283,8 +283,8 @@ ThrottleWithPriorityNanFilter = sensor_ns.class_(
 TimeoutFilterBase = sensor_ns.class_("TimeoutFilterBase", Filter, cg.Component)
 TimeoutFilterLast = sensor_ns.class_("TimeoutFilterLast", TimeoutFilterBase)
 TimeoutFilterConfigured = sensor_ns.class_("TimeoutFilterConfigured", TimeoutFilterBase)
-DebounceFilter = sensor_ns.class_("DebounceFilter", Filter, cg.Component)
-HeartbeatFilter = sensor_ns.class_("HeartbeatFilter", Filter, cg.Component)
+DebounceFilter = sensor_ns.class_("DebounceFilter", Filter)
+HeartbeatFilter = sensor_ns.class_("HeartbeatFilter", Filter)
 DeltaFilter = sensor_ns.class_("DeltaFilter", Filter)
 OrFilter = sensor_ns.class_("OrFilter", Filter)
 CalibrateLinearFilter = sensor_ns.class_("CalibrateLinearFilter", Filter)
@@ -564,12 +564,15 @@ async def exponential_moving_average_filter_to_code(config, filter_id):
 
 
 @FILTER_REGISTRY.register(
-    "throttle_average", ThrottleAverageFilter, cv.positive_time_period_milliseconds
+    "throttle_average",
+    ThrottleAverageFilter,
+    cv.All(
+        cv.positive_time_period_milliseconds,
+        cv.Range(max=cv.TimePeriod(hours=24)),
+    ),
 )
 async def throttle_average_filter_to_code(config, filter_id):
-    var = cg.new_Pvariable(filter_id, config)
-    await cg.register_component(var, {})
-    return var
+    return cg.new_Pvariable(filter_id, config)
 
 
 @FILTER_REGISTRY.register("lambda", LambdaFilter, cv.returning_lambda)
@@ -698,13 +701,10 @@ HEARTBEAT_SCHEMA = cv.Schema(
 async def heartbeat_filter_to_code(config, filter_id):
     if isinstance(config, dict):
         var = cg.new_Pvariable(filter_id, config[CONF_PERIOD])
-        await cg.register_component(var, {})
         cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
         return var
 
-    var = cg.new_Pvariable(filter_id, config)
-    await cg.register_component(var, {})
-    return var
+    return cg.new_Pvariable(filter_id, config)
 
 
 TIMEOUT_SCHEMA = cv.maybe_simple_value(
@@ -738,9 +738,7 @@ async def timeout_filter_to_code(config, filter_id):
     "debounce", DebounceFilter, cv.positive_time_period_milliseconds
 )
 async def debounce_filter_to_code(config, filter_id):
-    var = cg.new_Pvariable(filter_id, config)
-    await cg.register_component(var, {})
-    return var
+    return cg.new_Pvariable(filter_id, config)
 
 
 CONF_DATAPOINTS = "datapoints"

esphome/components/sensor/filter.cpp

@@ -13,11 +13,6 @@ namespace esphome::sensor {
 
 static const char *const TAG = "sensor.filter";
 
-// Filter scheduler IDs.
-// 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_ID = 0;
-
 // Filter
 void Filter::input(float value) {
   ESP_LOGVV(TAG, "Filter(%p)::input(%f)", this, value);
@@ -185,8 +180,9 @@ optional<float> ThrottleAverageFilter::new_value(float value) {
   }
   return {};
 }
-void ThrottleAverageFilter::setup() {
-  this->set_interval(FILTER_ID, this->time_period_, [this]() {
+void ThrottleAverageFilter::initialize(Sensor *parent, Filter *next) {
+  Filter::initialize(parent, next);
+  App.scheduler.set_interval(this, this->time_period_, [this]() {
     ESP_LOGVV(TAG, "ThrottleAverageFilter(%p)::interval(sum=%f, n=%i)", this, this->sum_, this->n_);
     if (this->n_ == 0) {
       if (this->have_nan_)
@@ -199,7 +195,6 @@ void ThrottleAverageFilter::setup() {
     this->have_nan_ = false;
   });
 }
-float ThrottleAverageFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 // LambdaFilter
 LambdaFilter::LambdaFilter(lambda_filter_t lambda_filter) : lambda_filter_(std::move(lambda_filter)) {}
@@ -362,13 +357,12 @@ optional<float> TimeoutFilterConfigured::new_value(float value) {
 
 // DebounceFilter
 optional<float> DebounceFilter::new_value(float value) {
-  this->set_timeout(FILTER_ID, this->time_period_, [this, value]() { this->output(value); });
+  App.scheduler.set_timeout(this, this->time_period_, [this, value]() { this->output(value); });
 
   return {};
 }
 
 DebounceFilter::DebounceFilter(uint32_t time_period) : time_period_(time_period) {}
-float DebounceFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 // HeartbeatFilter
 HeartbeatFilter::HeartbeatFilter(uint32_t time_period) : time_period_(time_period), last_input_(NAN) {}
@@ -384,8 +378,9 @@ optional<float> HeartbeatFilter::new_value(float value) {
   return {};
 }
 
-void HeartbeatFilter::setup() {
-  this->set_interval(FILTER_ID, this->time_period_, [this]() {
+void HeartbeatFilter::initialize(Sensor *parent, Filter *next) {
+  Filter::initialize(parent, next);
+  App.scheduler.set_interval(this, this->time_period_, [this]() {
     ESP_LOGVV(TAG, "HeartbeatFilter(%p)::interval(has_value=%s, last_input=%f)", this, YESNO(this->has_value_),
               this->last_input_);
     if (!this->has_value_)
@@ -395,8 +390,6 @@ void HeartbeatFilter::setup() {
   });
 }
 
-float HeartbeatFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
-
 optional<float> calibrate_linear_compute(const std::array<float, 3> *functions, size_t count, float value) {
   for (size_t i = 0; i < count; i++) {
     if (!std::isfinite(functions[i][2]) || value < functions[i][2])

esphome/components/sensor/filter.h

@@ -254,21 +254,22 @@ class ExponentialMovingAverageFilter : public Filter {
  *
  * It takes the average of all the values received in a period of time.
  */
-class ThrottleAverageFilter : public Filter, public Component {
+class ThrottleAverageFilter : public Filter {
  public:
   explicit ThrottleAverageFilter(uint32_t time_period);
 
-  void setup() override;
+  void initialize(Sensor *parent, Filter *next) override;
 
   optional<float> new_value(float value) override;
 
-  float get_setup_priority() const override;
-
  protected:
   float sum_{0.0f};
-  unsigned int n_{0};
   uint32_t time_period_;
-  bool have_nan_{false};
+  // Sample count packed with NaN-seen flag in a single 32-bit word.
+  // n_ is bounded by YAML cap on time_period_ (24 h) × max plausible source
+  // rate (1 kHz) = 86.4M ≪ 2^31, so 31 bits has 25x headroom.
+  uint32_t n_ : 31 {0};
+  uint32_t have_nan_ : 1 {0};
 };
 
 using lambda_filter_t = std::function<optional<float>(float)>;
@@ -454,25 +455,22 @@ class TimeoutFilterConfigured : public TimeoutFilterBase {
   // Total: 8 (base) + 4 = 12 bytes + vtable ptr + Component overhead
 };
 
-class DebounceFilter : public Filter, public Component {
+class DebounceFilter : public Filter {
  public:
   explicit DebounceFilter(uint32_t time_period);
 
   optional<float> new_value(float value) override;
 
-  float get_setup_priority() const override;
-
  protected:
   uint32_t time_period_;
 };
 
-class HeartbeatFilter : public Filter, public Component {
+class HeartbeatFilter : public Filter {
  public:
   explicit HeartbeatFilter(uint32_t time_period);
 
-  void setup() override;
+  void initialize(Sensor *parent, Filter *next) override;
   optional<float> new_value(float value) override;
-  float get_setup_priority() const override;
 
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 

esphome/components/speaker/media_player/__init__.py

@@ -1,5 +1,6 @@
 """Speaker Media Player Setup."""
 
+from functools import partial
 import hashlib
 import logging
 from pathlib import Path
@@ -32,7 +33,7 @@ from esphome.const import (
     CONF_URL,
 )
 from esphome.core import CORE, HexInt
-from esphome.external_files import download_content
+from esphome.external_files import download_web_files_in_config
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -92,15 +93,6 @@ def _compute_local_file_path(value: dict) -> Path:
     return base_dir / key
 
 
-def _download_web_file(value):
-    url = value[CONF_URL]
-    path = _compute_local_file_path(value)
-
-    download_content(url, path)
-    _LOGGER.debug("download_web_file: path=%s", path)
-    return value
-
-
 _PURPOSE_MAP = {
     "MEDIA": media_player.MEDIA_PLAYER_FORMAT_PURPOSE_ENUM["default"],
     "ANNOUNCEMENT": media_player.MEDIA_PLAYER_FORMAT_PURPOSE_ENUM["announcement"],
@@ -229,11 +221,10 @@ LOCAL_SCHEMA = cv.Schema(
     }
 )
 
-WEB_SCHEMA = cv.All(
+WEB_SCHEMA = cv.Schema(
     {
         cv.Required(CONF_URL): cv.url,
-    },
-    _download_web_file,
+    }
 )
 
 
@@ -285,7 +276,12 @@ CONFIG_SCHEMA = cv.All(
             ),
             # Remove before 2026.10.0
             cv.Optional(CONF_CODEC_SUPPORT_ENABLED): cv.Any(cv.boolean, cv.string),
-            cv.Optional(CONF_FILES): cv.ensure_list(MEDIA_FILE_TYPE_SCHEMA),
+            cv.Optional(CONF_FILES): cv.All(
+                cv.ensure_list(MEDIA_FILE_TYPE_SCHEMA),
+                partial(
+                    download_web_files_in_config, path_for=_compute_local_file_path
+                ),
+            ),
             cv.Optional(CONF_TASK_STACK_IN_PSRAM): cv.All(
                 cv.boolean, cv.requires_component(psram.DOMAIN)
             ),

esphome/components/sprinkler/sprinkler.cpp

@@ -669,7 +669,7 @@ uint32_t Sprinkler::valve_run_duration_adjusted(const size_t valve_number) {
   // run_duration must not be less than any of these
   if ((run_duration < this->start_delay_) || (run_duration < this->stop_delay_) ||
       (run_duration < this->switching_delay_.value_or(0) * 2)) {
-    return std::max(this->switching_delay_.value_or(0) * 2, std::max(this->start_delay_, this->stop_delay_));
+    return std::max({this->switching_delay_.value_or(0) * 2, this->start_delay_, this->stop_delay_});
   }
   return run_duration;
 }

esphome/components/st7789v/__init__.py

@@ -1,3 +1,8 @@
 import esphome.codegen as cg
 
 st7789v_ns = cg.esphome_ns.namespace("st7789v")
+
+DEPRECATED_COMPONENT = """
+The 'st7789v' component is deprecated and no new functionality will be added to it.
+PRs should target the newer and more performant 'mipi_spi' component.
+"""

esphome/components/st7789v/display.py

@@ -1,3 +1,5 @@
+import logging
+
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display, power_supply, spi
@@ -26,6 +28,8 @@ CODEOWNERS = ["@kbx81"]
 
 DEPENDENCIES = ["spi"]
 
+LOGGER = logging.getLogger(__name__)
+
 ST7789V = st7789v_ns.class_(
     "ST7789V", cg.PollingComponent, spi.SPIDevice, display.DisplayBuffer
 )
@@ -175,6 +179,9 @@ FINAL_VALIDATE_SCHEMA = spi.final_validate_device_schema(
 
 
 async def to_code(config):
+    LOGGER.warning(
+        "The 'st7789v' component is deprecated, it is recommended to use 'mipi_spi' instead."
+    )
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)
     await spi.register_spi_device(var, config, write_only=True)

esphome/components/sx126x/__init__.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import spi
@@ -5,6 +7,8 @@ from esphome.components.const import CONF_CRC_ENABLE, CONF_ON_PACKET
 import esphome.config_validation as cv
 from esphome.const import CONF_BUSY_PIN, CONF_DATA, CONF_FREQUENCY, CONF_ID
 from esphome.core import ID, TimePeriod
+from esphome.cpp_generator import MockObj
+from esphome.types import ConfigType, TemplateArgsType
 
 MULTI_CONF = True
 CODEOWNERS = ["@swoboda1337"]
@@ -15,6 +19,7 @@ CONF_SX126X_ID = "sx126x_id"
 CONF_BANDWIDTH = "bandwidth"
 CONF_BITRATE = "bitrate"
 CONF_CODING_RATE = "coding_rate"
+CONF_COLD = "cold"
 CONF_CRC_INVERTED = "crc_inverted"
 CONF_CRC_SIZE = "crc_size"
 CONF_CRC_POLYNOMIAL = "crc_polynomial"
@@ -144,7 +149,7 @@ SetModeStandbyAction = sx126x_ns.class_(
 )
 
 
-def validate_raw_data(value):
+def validate_raw_data(value: Any) -> bytes | list[int]:
     if isinstance(value, str):
         return value.encode("utf-8")
     if isinstance(value, list):
@@ -154,7 +159,7 @@ def validate_raw_data(value):
     )
 
 
-def validate_config(config):
+def validate_config(config: ConfigType) -> ConfigType:
     lora_bws = [
         "7_8kHz",
         "10_4kHz",
@@ -235,7 +240,7 @@ CONFIG_SCHEMA = (
 )
 
 
-async def to_code(config):
+async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await spi.register_spi_device(var, config)
@@ -307,24 +312,50 @@ NO_ARGS_ACTION_SCHEMA = automation.maybe_simple_id(
     NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
-@automation.register_action(
-    "sx126x.set_mode_sleep",
-    SetModeSleepAction,
-    NO_ARGS_ACTION_SCHEMA,
-    synchronous=True,
-)
 @automation.register_action(
     "sx126x.set_mode_standby",
     SetModeStandbyAction,
     NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
-async def no_args_action_to_code(config, action_id, template_arg, args):
+async def no_args_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     return var
 
 
+SET_MODE_SLEEP_ACTION_SCHEMA = automation.maybe_simple_id(
+    {
+        cv.GenerateID(): cv.use_id(SX126x),
+        cv.Optional(CONF_COLD, default=False): cv.templatable(cv.boolean),
+    }
+)
+
+
+@automation.register_action(
+    "sx126x.set_mode_sleep",
+    SetModeSleepAction,
+    SET_MODE_SLEEP_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def set_mode_sleep_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_COLD], args, bool)
+    cg.add(var.set_cold(template_))
+    return var
+
+
 SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
     {
         cv.GenerateID(): cv.use_id(SX126x),
@@ -340,7 +371,12 @@ SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
     SEND_PACKET_ACTION_SCHEMA,
     synchronous=True,
 )
-async def send_packet_action_to_code(config, action_id, template_arg, args):
+async def send_packet_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     data = config[CONF_DATA]

esphome/components/sx126x/automation.h

@@ -56,7 +56,8 @@ template<typename... Ts> class SetModeRxAction : public Action<Ts...>, public Pa
 
 template<typename... Ts> class SetModeSleepAction : public Action<Ts...>, public Parented<SX126x> {
  public:
-  void play(const Ts &...x) override { this->parent_->set_mode_sleep(); }
+  TEMPLATABLE_VALUE(bool, cold)
+  void play(const Ts &...x) override { this->parent_->set_mode_sleep(this->cold_.value(x...)); }
 };
 
 template<typename... Ts> class SetModeStandbyAction : public Action<Ts...>, public Parented<SX126x> {

esphome/components/sx126x/sx126x.cpp

@@ -459,9 +459,10 @@ void SX126x::set_mode_tx() {
   this->write_opcode_(RADIO_SET_TX, buf, 3);
 }
 
-void SX126x::set_mode_sleep() {
+void SX126x::set_mode_sleep(bool cold) {
+  // 0x04 = warm start (config retained), 0x00 = cold start (config lost, lowest power)
   uint8_t buf[1];
-  buf[0] = 0x05;
+  buf[0] = cold ? 0x00 : 0x04;
   this->write_opcode_(RADIO_SET_SLEEP, buf, 1);
 }
 

esphome/components/sx126x/sx126x.h

@@ -79,7 +79,7 @@ class SX126x : public Component,
   void set_mode_rx();
   void set_mode_tx();
   void set_mode_standby(SX126xStandbyMode mode);
-  void set_mode_sleep();
+  void set_mode_sleep(bool cold = false);
   void set_modulation(uint8_t modulation) { this->modulation_ = modulation; }
   void set_pa_power(int8_t power) { this->pa_power_ = power; }
   void set_pa_ramp(uint8_t ramp) { this->pa_ramp_ = ramp; }

esphome/components/time/automation.cpp

@@ -31,13 +31,14 @@ void CronTrigger::check_time_() {
     return;
 
   if (this->last_check_.has_value()) {
-    if (*this->last_check_ > time && this->last_check_->timestamp - time.timestamp > MAX_TIMESTAMP_DRIFT) {
+    auto &last_check = *this->last_check_;
+    if (last_check > time && last_check.timestamp - time.timestamp > MAX_TIMESTAMP_DRIFT) {
       // We went back in time (a lot), probably caused by time synchronization
       ESP_LOGW(TAG, "Time has jumped back!");
-    } else if (*this->last_check_ >= time) {
+    } else if (last_check >= time) {
       // already handled this one
       return;
-    } else if (time > *this->last_check_ && time.timestamp - this->last_check_->timestamp > MAX_TIMESTAMP_DRIFT) {
+    } else if (time > last_check && time.timestamp - last_check.timestamp > MAX_TIMESTAMP_DRIFT) {
       // We went ahead in time (a lot), probably caused by time synchronization
       ESP_LOGW(TAG, "Time has jumped ahead!");
       this->last_check_ = time;
@@ -45,11 +46,11 @@ void CronTrigger::check_time_() {
     }
 
     while (true) {
-      this->last_check_->increment_second();
-      if (*this->last_check_ >= time)
+      last_check.increment_second();
+      if (last_check >= time)
         break;
 
-      if (this->matches(*this->last_check_))
+      if (this->matches(last_check))
         this->trigger();
     }
   }

esphome/components/tormatic/tormatic_cover.cpp

@@ -282,12 +282,13 @@ optional<GateStatus> Tormatic::read_gate_status_() {
     }
   }
 
+  auto hdr = this->pending_hdr_.value();
+
   // Wait for all payload bytes to arrive before processing.
-  if (this->available() < this->pending_hdr_->payload_size()) {
+  if (this->available() < hdr.payload_size()) {
     return {};
   }
 
-  auto hdr = *this->pending_hdr_;
   this->pending_hdr_.reset();
 
   switch (hdr.type) {

esphome/components/toshiba/toshiba.cpp

@@ -275,7 +275,7 @@ static Ras2819tSecondPacketCodes get_ras_2819t_second_packet_codes(climate::Clim
  */
 static uint8_t get_ras_2819t_temp_code(float temperature) {
   int temp_index = static_cast<int>(temperature) - 18;
-  if (temp_index < 0 || temp_index >= static_cast<int>(sizeof(RAS_2819T_TEMP_CODES))) {
+  if (temp_index < 0 || static_cast<size_t>(temp_index) >= sizeof(RAS_2819T_TEMP_CODES)) {
     ESP_LOGW(TAG, "Temperature %.1f°C out of range [18-30°C], defaulting to 24°C", temperature);
     return 0x40;  // Default to 24°C
   }

esphome/components/usb_host/__init__.py

@@ -10,6 +10,7 @@ from esphome.components.esp32 import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DEVICES, CONF_ID
+from esphome.core import CORE
 from esphome.cpp_types import Component
 from esphome.types import ConfigType
 
@@ -19,14 +20,15 @@ DEPENDENCIES = ["esp32"]
 usb_host_ns = cg.esphome_ns.namespace("usb_host")
 USBHost = usb_host_ns.class_("USBHost", Component)
 USBClient = usb_host_ns.class_("USBClient", Component)
-
+DOMAIN = "usb_host"
 CONF_VID = "vid"
 CONF_PID = "pid"
 CONF_ENABLE_HUBS = "enable_hubs"
 CONF_MAX_TRANSFER_REQUESTS = "max_transfer_requests"
+CONF_MAX_PACKET_SIZE = "max_packet_size"
 
 
-def usb_device_schema(cls=USBClient, vid: int = None, pid: [int] = None) -> cv.Schema:
+def usb_device_schema(cls=USBClient, vid: int = None, pid: int = None) -> cv.Schema:
     schema = cv.COMPONENT_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(cls),
@@ -43,6 +45,17 @@ def usb_device_schema(cls=USBClient, vid: int = None, pid: [int] = None) -> cv.S
     return schema
 
 
+def _set_max_packet_size(config: dict) -> dict:
+    CORE.data.setdefault(DOMAIN, {})[CONF_MAX_PACKET_SIZE] = config[
+        CONF_MAX_PACKET_SIZE
+    ]
+    return config
+
+
+def get_max_packet_size() -> int:
+    return CORE.data.get(DOMAIN, {}).get(CONF_MAX_PACKET_SIZE, 64)
+
+
 CONFIG_SCHEMA = cv.All(
     cv.COMPONENT_SCHEMA.extend(
         {
@@ -51,10 +64,14 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_MAX_TRANSFER_REQUESTS, default=16): cv.int_range(
                 min=1, max=32
             ),
+            cv.Optional(CONF_MAX_PACKET_SIZE, default=64): cv.one_of(
+                64, 128, 256, 512, 1024, int=True
+            ),
             cv.Optional(CONF_DEVICES): cv.ensure_list(usb_device_schema()),
         }
     ),
     only_on_variant(supported=[VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3]),
+    _set_max_packet_size,
 )
 
 
@@ -72,8 +89,8 @@ async def to_code(config: ConfigType) -> None:
     if config.get(CONF_ENABLE_HUBS):
         add_idf_sdkconfig_option("CONFIG_USB_HOST_HUBS_SUPPORTED", True)
 
-    max_requests = config[CONF_MAX_TRANSFER_REQUESTS]
-    cg.add_define("USB_HOST_MAX_REQUESTS", max_requests)
+    cg.add_define("USB_HOST_MAX_REQUESTS", config[CONF_MAX_TRANSFER_REQUESTS])
+    cg.add_define("USB_HOST_MAX_PACKET_SIZE", config[CONF_MAX_PACKET_SIZE])
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/usb_host/usb_host.h

@@ -66,6 +66,8 @@ static_assert(MAX_REQUESTS >= 1 && MAX_REQUESTS <= 32, "MAX_REQUESTS must be bet
 using trq_bitmask_t = std::conditional<(MAX_REQUESTS <= 16), uint16_t, uint32_t>::type;
 static constexpr trq_bitmask_t ALL_REQUESTS_IN_USE = MAX_REQUESTS == 32 ? ~0 : (1 << MAX_REQUESTS) - 1;
 
+static constexpr size_t USB_MAX_PACKET_SIZE =
+    USB_HOST_MAX_PACKET_SIZE;                        // Max USB packet size (64 for FS, 512 for P4 HS)
 static constexpr size_t USB_EVENT_QUEUE_SIZE = 32;   // Size of event queue between USB task and main loop
 static constexpr size_t USB_TASK_STACK_SIZE = 4096;  // Stack size for USB task (same as ESP-IDF USB examples)
 static constexpr UBaseType_t USB_TASK_PRIORITY = 5;  // Higher priority than main loop (tskIDLE_PRIORITY + 5)