Merge branch 'dev' into app-loop-optimize-speed

# Conflicts:
#	esphome/core/application.h

.clang-tidy

@@ -5,30 +5,24 @@ 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,
@@ -48,7 +42,6 @@ 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,
@@ -61,13 +54,12 @@ 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,
@@ -79,23 +71,16 @@ 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,
@@ -103,42 +88,32 @@ 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-ranges,
+  -modernize-use-nodiscard,
+  -modernize-use-nullptr,
   -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 @@
-0c7f309d70eca8e3efd510092ddb23c530f3934c49371717efa124b788d761f8
+1b1ce6324c50c4595703c7df0a8a479b4fe84b71ff1a8793cce1a16f17a33324

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Generate cache-key
         id: cache-key
-        run: echo key="${{ hashFiles('requirements.txt', 'requirements_dev.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
+        run: echo key="${{ hashFiles('requirements.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -58,7 +58,7 @@ jobs:
           python -m venv venv
           . venv/bin/activate
           python --version
-          pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt pre-commit
+          pip install -r requirements.txt -r requirements_test.txt pre-commit
           pip install -e .
 
   pylint:
@@ -108,34 +108,6 @@ jobs:
           script/generate-esp32-boards.py --check
           script/generate-rp2040-boards.py --check
 
-  import-time:
-    name: Check import esphome.__main__ time
-    runs-on: ubuntu-24.04
-    needs:
-      - common
-      - determine-jobs
-    if: needs.determine-jobs.outputs.import-time == 'true'
-    steps:
-      - name: Check out code from GitHub
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Check import time against budget and write waterfall HAR
-        run: |
-          . venv/bin/activate
-          script/check_import_time.py --check --har importtime.har
-      - name: Upload waterfall HAR
-        if: always()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: import-time-waterfall
-          path: importtime.har
-          if-no-files-found: ignore
-          retention-days: 14
-
   pytest:
     name: Run pytest
     strategy:
@@ -199,11 +171,11 @@ jobs:
       - common
     outputs:
       integration-tests: ${{ steps.determine.outputs.integration-tests }}
-      integration-test-buckets: ${{ steps.determine.outputs.integration-test-buckets }}
+      integration-tests-run-all: ${{ steps.determine.outputs.integration-tests-run-all }}
+      integration-test-files: ${{ steps.determine.outputs.integration-test-files }}
       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 }}
       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 }}
@@ -242,11 +214,11 @@ jobs:
 
           # Extract individual fields
           echo "integration-tests=$(echo "$output" | jq -r '.integration_tests')" >> $GITHUB_OUTPUT
-          echo "integration-test-buckets=$(echo "$output" | jq -c '.integration_test_buckets')" >> $GITHUB_OUTPUT
+          echo "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 "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 "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
@@ -265,16 +237,12 @@ jobs:
           key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
 
   integration-tests:
-    name: Run integration tests (${{ matrix.bucket.name }})
+    name: Run integration tests
     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
@@ -301,14 +269,19 @@ jobs:
         run: echo "::add-matcher::.github/workflows/matchers/pytest.json"
       - name: Run integration tests
         env:
-          # JSON array of test paths; parsed into a bash array below to avoid
-          # shell word-splitting / glob hazards.
-          BUCKET_TESTS: ${{ toJson(matrix.bucket.tests) }}
+          INTEGRATION_TEST_FILES: ${{ needs.determine-jobs.outputs.integration-test-files }}
+          INTEGRATION_TESTS_RUN_ALL: ${{ needs.determine-jobs.outputs.integration-tests-run-all }}
         run: |
           . venv/bin/activate
-          mapfile -t test_files < <(echo "$BUCKET_TESTS" | jq -r '.[]')
-          echo "Bucket ${{ matrix.bucket.name }}: running ${#test_files[@]} integration tests"
-          pytest -vv --no-cov --tb=native -n auto "${test_files[@]}"
+          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
 
   cpp-unit-tests:
     name: Run C++ unit tests
@@ -366,7 +339,7 @@ jobs:
           echo "binary=$BINARY" >> $GITHUB_OUTPUT
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@c381be0bfd20e844fb45594f6aa182ffcd94545c # v4.15.0
+        uses: CodSpeedHQ/action@658a901452bb54c799643e060733b7afe9121b8d # v4.14.0
         with:
           run: ${{ steps.build.outputs.binary }}
           mode: simulation

.gitignore

@@ -146,6 +146,5 @@ sdkconfig.*
 
 /components
 /managed_components
-/dependencies.lock
 
 api-docs/

.pre-commit-config.yaml

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

CODEOWNERS

@@ -347,7 +347,6 @@ esphome/components/modbus_controller/select/* @martgras @stegm
 esphome/components/modbus_controller/sensor/* @martgras
 esphome/components/modbus_controller/switch/* @martgras
 esphome/components/modbus_controller/text_sensor/* @martgras
-esphome/components/modbus_server/* @exciton
 esphome/components/mopeka_ble/* @Fabian-Schmidt @spbrogan
 esphome/components/mopeka_pro_check/* @spbrogan
 esphome/components/mopeka_std_check/* @Fabian-Schmidt

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
+from esphome import const, writer, yaml_util
 import esphome.codegen as cg
 from esphome.config import iter_component_configs, read_config, strip_default_ids
 from esphome.const import (
@@ -72,12 +72,7 @@ from esphome.util import (
     run_external_process,
     safe_print,
 )
-
-# Keep expensive imports (zeroconf, writer, yaml_util, etc.) out of this
-# module's top level. Every `esphome` invocation — including fast paths
-# like `esphome version` — pays the cost of what's imported here before
-# any command runs. Import inside the function that needs it instead.
-# `script/check_import_time.py` enforces a budget in CI.
+from esphome.zeroconf import discover_mdns_devices
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -246,8 +241,6 @@ 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(
@@ -667,7 +660,7 @@ def run_miniterm(config: ConfigType, port: str, args) -> int:
     return 0
 
 
-def _wrap_to_code(name, comp, yaml_util):
+def wrap_to_code(name, comp):
     coro = coroutine(comp.to_code)
 
     @functools.wraps(comp.to_code)
@@ -687,8 +680,6 @@ def _wrap_to_code(name, comp, yaml_util):
 
 
 def write_cpp(config: ConfigType, native_idf: bool = False) -> int:
-    from esphome import writer
-
     if not get_bool_env(ENV_NOGITIGNORE):
         writer.write_gitignore()
 
@@ -700,21 +691,17 @@ 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, yaml_util)
+            coro = wrap_to_code(name, component)
             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)
 
@@ -1193,8 +1180,6 @@ 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)
@@ -1336,8 +1321,6 @@ 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:
@@ -1353,8 +1336,6 @@ 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:
@@ -1557,8 +1538,6 @@ 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,11 +793,8 @@ 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/`` (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.
+        under ``src/esphome/`` and build a symbol-to-component mapping. This catches
+        ``extern "C"`` functions and other symbols that lack C++ namespace prefixes.
 
         Skips scanning if ``_source_symbol_map`` was already populated by
         ``_parse_map_file()``.
@@ -809,12 +806,12 @@ class MemoryAnalyzer:
         if obj_dir is None:
             return
 
-        # 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():
+        # Find ESPHome source object files
+        esphome_src_dir = obj_dir / "src" / "esphome"
+        if not esphome_src_dir.is_dir():
             return
 
-        obj_files = sorted(src_dir.rglob("*.o"))
+        obj_files = sorted(esphome_src_dir.rglob("*.o"))
         if not obj_files:
             return
 
@@ -1067,10 +1064,6 @@ 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)
+DelayAction = cg.esphome_ns.class_("DelayAction", Action, cg.Component)
 LambdaAction = cg.esphome_ns.class_("LambdaAction", Action)
 StatelessLambdaAction = cg.esphome_ns.class_("StatelessLambdaAction", Action)
 IfAction = cg.esphome_ns.class_("IfAction", Action)
@@ -396,6 +396,7 @@ 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
@@ -596,7 +597,7 @@ async def component_resume_action_to_code(
     comp = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, comp)
     if CONF_UPDATE_INTERVAL in config:
-        template_ = await cg.templatable(config[CONF_UPDATE_INTERVAL], args, cg.uint32)
+        template_ = await cg.templatable(config[CONF_UPDATE_INTERVAL], args, int)
         cg.add(var.set_update_interval(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({led_data[0], led_data[1], led_data[2]});
+    auto white = std::min(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/alarm_control_panel/__init__.py

@@ -13,11 +13,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import (
-    entity_duplicate_validator,
-    queue_entity_register,
-    setup_entity,
-)
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@grahambrown11", "@hwstar"]
@@ -185,7 +181,7 @@ async def setup_alarm_control_panel_core_(var, config):
 async def register_alarm_control_panel(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    queue_entity_register("alarm_control_panel", config)
+    cg.add(cg.App.register_alarm_control_panel(var))
     CORE.register_platform_component("alarm_control_panel", var)
     await setup_alarm_control_panel_core_(var, config)
 

esphome/components/animation/animation.cpp

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

esphome/components/api/api.proto

@@ -1025,13 +1025,6 @@ message CameraImageRequest {
   bool stream = 2;
 }
 
-// ==================== TEMPERATURE UNIT ====================
-enum TemperatureUnit {
-  TEMPERATURE_UNIT_CELSIUS = 0;
-  TEMPERATURE_UNIT_FAHRENHEIT = 1;
-  TEMPERATURE_UNIT_KELVIN = 2;
-}
-
 // ==================== CLIMATE ====================
 enum ClimateMode {
   CLIMATE_MODE_OFF = 0;
@@ -1117,7 +1110,6 @@ message ListEntitiesClimateResponse {
   float visual_max_humidity = 25;
   uint32 device_id = 26 [(field_ifdef) = "USE_DEVICES"];
   uint32 feature_flags = 27;
-  TemperatureUnit temperature_unit = 28;
 }
 message ClimateStateResponse {
   option (id) = 47;
@@ -1211,7 +1203,6 @@ message ListEntitiesWaterHeaterResponse {
   repeated WaterHeaterMode supported_modes = 11 [(container_pointer_no_template) = "water_heater::WaterHeaterModeMask"];
   // Bitmask of WaterHeaterFeature flags
   uint32 supported_features = 12;
-  TemperatureUnit temperature_unit = 13;
 }
 
 message WaterHeaterStateResponse {
@@ -1419,8 +1410,6 @@ enum LockState {
   LOCK_STATE_JAMMED = 3;
   LOCK_STATE_LOCKING = 4;
   LOCK_STATE_UNLOCKING = 5;
-  LOCK_STATE_OPENING = 6;
-  LOCK_STATE_OPEN = 7;
 }
 enum LockCommand  {
   LOCK_UNLOCK = 0;
@@ -1639,7 +1628,7 @@ message BluetoothLEAdvertisementResponse {
 
 message BluetoothLERawAdvertisement {
   option (inline_encode) = true;
-  uint64 address = 1 [(force) = true, (mac_address) = true];
+  uint64 address = 1 [(force) = true];
   sint32 rssi = 2 [(force) = true];
   uint32 address_type = 3 [(max_value) = 4];
 

esphome/components/api/api_options.proto

@@ -110,10 +110,4 @@ extend google.protobuf.FieldOptions {
     // length varint calculations and direct byte writes, since the length
     // varint is guaranteed to be 1 byte.
     optional uint32 max_data_length = 50018;
-
-    // mac_address: Field is a 48-bit MAC address stored in a uint64.
-    // Emits encode_varint_raw_48bit which has a 7-byte fast path that avoids
-    // the per-byte loop when the upper bits are non-zero (the common case
-    // for real MAC addresses, since OUIs occupy the top 24 bits).
-    optional bool mac_address = 50019 [default=false];
 }

esphome/components/api/api_pb2.cpp

@@ -1439,7 +1439,6 @@ uint8_t *ListEntitiesClimateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 26, this->device_id);
 #endif
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 27, this->feature_flags);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 28, static_cast<uint32_t>(this->temperature_unit));
   return pos;
 }
 uint32_t ListEntitiesClimateResponse::calculate_size() const {
@@ -1489,7 +1488,6 @@ uint32_t ListEntitiesClimateResponse::calculate_size() const {
   size += ProtoSize::calc_uint32(2, this->device_id);
 #endif
   size += ProtoSize::calc_uint32(2, this->feature_flags);
-  size += this->temperature_unit ? 3 : 0;
   return size;
 }
 uint8_t *ClimateStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1647,7 +1645,6 @@ uint8_t *ListEntitiesWaterHeaterResponse::encode(ProtoWriteBuffer &buffer PROTO_
     ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(it), true);
   }
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->supported_features);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(this->temperature_unit));
   return pos;
 }
 uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
@@ -1670,7 +1667,6 @@ uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
     size += this->supported_modes->size() * 2;
   }
   size += ProtoSize::calc_uint32(1, this->supported_features);
-  size += this->temperature_unit ? 2 : 0;
   return size;
 }
 uint8_t *WaterHeaterStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -2352,7 +2348,7 @@ BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
     uint8_t *len_pos = pos;
     ProtoEncode::reserve_byte(pos PROTO_ENCODE_DEBUG_ARG);
     ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 8);
-    ProtoEncode::encode_varint_raw_48bit(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
+    ProtoEncode::encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
     ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 16);
     ProtoEncode::encode_varint_raw_short(pos PROTO_ENCODE_DEBUG_ARG, encode_zigzag32(sub_msg.rssi));
     if (sub_msg.address_type) {
@@ -2373,7 +2369,7 @@ BluetoothLERawAdvertisementsResponse::calculate_size() const {
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
     auto &sub_msg = this->advertisements[i];
     size += 2;
-    size += ProtoSize::calc_uint64_48bit_force(1, sub_msg.address);
+    size += ProtoSize::calc_uint64_force(1, sub_msg.address);
     size += ProtoSize::calc_sint32_force(1, sub_msg.rssi);
     size += sub_msg.address_type ? 2 : 0;
     size += 2 + sub_msg.data_len;

esphome/components/api/api_pb2.h

@@ -92,11 +92,6 @@ enum SupportsResponseType : uint32_t {
   SUPPORTS_RESPONSE_STATUS = 100,
 };
 #endif
-enum TemperatureUnit : uint32_t {
-  TEMPERATURE_UNIT_CELSIUS = 0,
-  TEMPERATURE_UNIT_FAHRENHEIT = 1,
-  TEMPERATURE_UNIT_KELVIN = 2,
-};
 #ifdef USE_CLIMATE
 enum ClimateMode : uint32_t {
   CLIMATE_MODE_OFF = 0,
@@ -181,8 +176,6 @@ enum LockState : uint32_t {
   LOCK_STATE_JAMMED = 3,
   LOCK_STATE_LOCKING = 4,
   LOCK_STATE_UNLOCKING = 5,
-  LOCK_STATE_OPENING = 6,
-  LOCK_STATE_OPEN = 7,
 };
 enum LockCommand : uint32_t {
   LOCK_UNLOCK = 0,
@@ -1379,7 +1372,7 @@ class CameraImageRequest final : public ProtoDecodableMessage {
 class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 46;
-  static constexpr uint8_t ESTIMATED_SIZE = 153;
+  static constexpr uint8_t ESTIMATED_SIZE = 150;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_climate_response"); }
 #endif
@@ -1401,7 +1394,6 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   float visual_min_humidity{0.0f};
   float visual_max_humidity{0.0f};
   uint32_t feature_flags{0};
-  enums::TemperatureUnit temperature_unit{};
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1479,7 +1471,7 @@ class ClimateCommandRequest final : public CommandProtoMessage {
 class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 132;
-  static constexpr uint8_t ESTIMATED_SIZE = 65;
+  static constexpr uint8_t ESTIMATED_SIZE = 63;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_water_heater_response"); }
 #endif
@@ -1488,7 +1480,6 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
   float target_temperature_step{0.0f};
   const water_heater::WaterHeaterModeMask *supported_modes{};
   uint32_t supported_features{0};
-  enums::TemperatureUnit temperature_unit{};
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

@@ -297,18 +297,6 @@ template<> const char *proto_enum_to_string<enums::SupportsResponseType>(enums::
   }
 }
 #endif
-template<> const char *proto_enum_to_string<enums::TemperatureUnit>(enums::TemperatureUnit value) {
-  switch (value) {
-    case enums::TEMPERATURE_UNIT_CELSIUS:
-      return ESPHOME_PSTR("TEMPERATURE_UNIT_CELSIUS");
-    case enums::TEMPERATURE_UNIT_FAHRENHEIT:
-      return ESPHOME_PSTR("TEMPERATURE_UNIT_FAHRENHEIT");
-    case enums::TEMPERATURE_UNIT_KELVIN:
-      return ESPHOME_PSTR("TEMPERATURE_UNIT_KELVIN");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
 #ifdef USE_CLIMATE
 template<> const char *proto_enum_to_string<enums::ClimateMode>(enums::ClimateMode value) {
   switch (value) {
@@ -487,10 +475,6 @@ template<> const char *proto_enum_to_string<enums::LockState>(enums::LockState v
       return ESPHOME_PSTR("LOCK_STATE_LOCKING");
     case enums::LOCK_STATE_UNLOCKING:
       return ESPHOME_PSTR("LOCK_STATE_UNLOCKING");
-    case enums::LOCK_STATE_OPENING:
-      return ESPHOME_PSTR("LOCK_STATE_OPENING");
-    case enums::LOCK_STATE_OPEN:
-      return ESPHOME_PSTR("LOCK_STATE_OPEN");
     default:
       return ESPHOME_PSTR("UNKNOWN");
   }
@@ -1555,7 +1539,6 @@ const char *ListEntitiesClimateResponse::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
-  dump_field(out, ESPHOME_PSTR("temperature_unit"), static_cast<enums::TemperatureUnit>(this->temperature_unit));
   return out.c_str();
 }
 const char *ClimateStateResponse::dump_to(DumpBuffer &out) const {
@@ -1629,7 +1612,6 @@ const char *ListEntitiesWaterHeaterResponse::dump_to(DumpBuffer &out) const {
     dump_field(out, ESPHOME_PSTR("supported_modes"), static_cast<enums::WaterHeaterMode>(it), 4);
   }
   dump_field(out, ESPHOME_PSTR("supported_features"), this->supported_features);
-  dump_field(out, ESPHOME_PSTR("temperature_unit"), static_cast<enums::TemperatureUnit>(this->temperature_unit));
   return out.c_str();
 }
 const char *WaterHeaterStateResponse::dump_to(DumpBuffer &out) const {

esphome/components/api/api_pb2_service.cpp

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

esphome/components/api/api_server.cpp

@@ -30,11 +30,6 @@ APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-c
 
 APIServer::APIServer() { global_api_server = this; }
 
-// Custom deleter defined here so `delete` sees the complete APIConnection type.
-// This prevents libc++ from emitting an "incomplete type" error when other
-// translation units only have the forward declaration of APIConnection.
-void APIServer::APIConnectionDeleter::operator()(APIConnection *p) const { delete p; }
-
 void APIServer::socket_failed_(const LogString *msg) {
   ESP_LOGW(TAG, "Socket %s: errno %d", LOG_STR_ARG(msg), errno);
   this->destroy_socket_();

esphome/components/api/api_server.h

@@ -193,13 +193,7 @@ class APIServer final : public Component,
   // Range-for view over the populated slice [0, api_connection_count_). Read-only with respect
   // to ownership — callers get `const unique_ptr&` so they can invoke non-const methods on the
   // APIConnection but cannot reset/move the slot and break the count invariant.
-  // Custom deleter is defined out-of-line in api_server.cpp so libc++ does not
-  // eagerly instantiate `delete static_cast<APIConnection *>(p)` here, where
-  // only the forward declaration of APIConnection is visible (incomplete type).
-  struct APIConnectionDeleter {
-    void operator()(APIConnection *p) const;
-  };
-  using APIConnectionPtr = std::unique_ptr<APIConnection, APIConnectionDeleter>;
+  using APIConnectionPtr = std::unique_ptr<APIConnection>;
   class ActiveClientsView {
     const APIConnectionPtr *begin_;
     const APIConnectionPtr *end_;
@@ -298,7 +292,7 @@ class APIServer final : public Component,
   uint32_t last_connected_{0};
 
   // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
-  std::array<APIConnectionPtr, MAX_API_CONNECTIONS> clients_{};
+  std::array<std::unique_ptr<APIConnection>, MAX_API_CONNECTIONS> clients_{};
   // Vectors and strings (12 bytes each on 32-bit)
   // Shared proto write buffer for all connections.
   // Not pre-allocated: all send paths call prepare_first_message_buffer() which

esphome/components/api/homeassistant_service.h

@@ -78,8 +78,7 @@ class ActionResponse {
       : success_(success), error_message_(error_message) {
     if (data == nullptr || data_len == 0)
       return;
-    JsonDocument tmp = json::parse_json(data, data_len);
-    swap(this->json_document_, tmp);
+    this->json_document_ = json::parse_json(data, data_len);
   }
 #endif
 

esphome/components/api/proto.h

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

esphome/components/aqi/aqi_calculator.h

@@ -14,7 +14,11 @@ 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, 0.0f});
+
+    float aqi = std::max(pm2_5_index, pm10_0_index);
+    if (aqi < 0.0f) {
+      aqi = 0.0f;
+    }
     return static_cast<uint16_t>(std::lround(aqi));
   }
 

esphome/components/aqi/caqi_calculator.h

@@ -12,7 +12,11 @@ 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, 0.0f});
+
+    float aqi = std::max(pm2_5_index, pm10_0_index);
+    if (aqi < 0.0f) {
+      aqi = 0.0f;
+    }
     return static_cast<uint16_t>(std::lround(aqi));
   }
 

esphome/components/at581x/__init__.py

@@ -183,19 +183,19 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
         cg.add(var.set_sensing_distance(template_))
 
     if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
-        template_ = await cg.templatable(selfcheck, args, cg.int_)
+        template_ = await cg.templatable(selfcheck, args, cg.int32)
         cg.add(var.set_poweron_selfcheck_time(template_))
 
     if protect := config.get(CONF_PROTECT_TIME):
-        template_ = await cg.templatable(protect, args, cg.int_)
+        template_ = await cg.templatable(protect, args, cg.int32)
         cg.add(var.set_protect_time(template_))
 
     if trig_base := config.get(CONF_TRIGGER_BASE):
-        template_ = await cg.templatable(trig_base, args, cg.int_)
+        template_ = await cg.templatable(trig_base, args, cg.int32)
         cg.add(var.set_trigger_base(template_))
 
     if trig_keep := config.get(CONF_TRIGGER_KEEP):
-        template_ = await cg.templatable(trig_keep, args, cg.int_)
+        template_ = await cg.templatable(trig_keep, args, cg.int32)
         cg.add(var.set_trigger_keep(template_))
 
     if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:

esphome/components/audio/__init__.py

@@ -220,7 +220,7 @@ async def to_code(config):
     data = _get_data()
 
     if data.micro_decoder_support:
-        add_idf_component(name="esphome/micro-decoder", ref="0.2.0")
+        add_idf_component(name="esphome/micro-decoder", ref="0.1.1")
 
         # All codecs are enabled by default in micro-decoder, so disable the ones that aren't requested to save flash
         if not data.flac_support:

esphome/components/audio_file/__init__.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, field
-from functools import partial
 import hashlib
 import logging
 from pathlib import Path
@@ -20,7 +19,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, HexInt
 from esphome.cpp_generator import MockObj
-from esphome.external_files import download_web_files_in_config
+from esphome.external_files import download_content
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -64,6 +63,15 @@ 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)
@@ -134,10 +142,11 @@ LOCAL_SCHEMA = cv.Schema(
     }
 )
 
-WEB_SCHEMA = cv.Schema(
+WEB_SCHEMA = cv.All(
     {
         cv.Required(CONF_URL): cv.url,
-    }
+    },
+    _download_web_file,
 )
 
 
@@ -200,7 +209,6 @@ 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/bh1750/bh1750.cpp

@@ -154,7 +154,7 @@ void BH1750Sensor::loop() {
         break;
       }
 
-      ESP_LOGV(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
       this->status_clear_warning();
       this->publish_state(lx);
       this->state_ = IDLE;

esphome/components/binary_sensor/__init__.py

@@ -62,7 +62,6 @@ from esphome.const import (
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
     entity_duplicate_validator,
-    queue_entity_register,
     setup_device_class,
     setup_entity,
 )
@@ -625,7 +624,7 @@ async def setup_binary_sensor_core_(var, config):
 async def register_binary_sensor(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    queue_entity_register("binary_sensor", config)
+    cg.add(cg.App.register_binary_sensor(var))
     CORE.register_platform_component("binary_sensor", var)
     await setup_binary_sensor_core_(var, config)
 

esphome/components/binary_sensor/automation.cpp

@@ -50,31 +50,29 @@ void MultiClickTriggerBase::on_state_(bool state) {
     return;
   }
 
-  // at_index_ has a value here (the !has_value() branch above returns).
-  size_t at_index = *this->at_index_;
-  if (at_index == this->timing_count_) {
+  if (*this->at_index_ == this->timing_count_) {
     this->trigger_();
     return;
   }
 
-  MultiClickTriggerEvent evt = this->timing_[at_index];
+  MultiClickTriggerEvent evt = this->timing_[*this->at_index_];
 
   if (evt.max_length != 4294967294UL) {
-    ESP_LOGV(TAG, "A i=%zu min=%" PRIu32 " max=%" PRIu32, at_index, evt.min_length, evt.max_length);  // NOLINT
+    ESP_LOGV(TAG, "A i=%zu min=%" PRIu32 " max=%" PRIu32, *this->at_index_, evt.min_length, evt.max_length);  // NOLINT
     this->schedule_is_valid_(evt.min_length);
     this->schedule_is_not_valid_(evt.max_length);
-  } else if (at_index + 1 != this->timing_count_) {
-    ESP_LOGV(TAG, "B i=%zu min=%" PRIu32, at_index, evt.min_length);  // NOLINT
+  } else if (*this->at_index_ + 1 != this->timing_count_) {
+    ESP_LOGV(TAG, "B i=%zu min=%" PRIu32, *this->at_index_, evt.min_length);  // NOLINT
     this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
     this->schedule_is_valid_(evt.min_length);
   } else {
-    ESP_LOGV(TAG, "C i=%zu min=%" PRIu32, at_index, evt.min_length);  // NOLINT
+    ESP_LOGV(TAG, "C i=%zu min=%" PRIu32, *this->at_index_, evt.min_length);  // NOLINT
     this->is_valid_ = false;
     this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
     this->set_timeout(MULTICLICK_TRIGGER_ID, evt.min_length, [this]() { this->trigger_(); });
   }
 
-  this->at_index_ = at_index + 1;
+  *this->at_index_ = *this->at_index_ + 1;
 }
 void MultiClickTriggerBase::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);

esphome/components/bk72xx/boards.py

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

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -30,6 +30,19 @@ void BluetoothProxy::setup() {
   this->configured_scan_active_ = this->parent_->get_scan_active();
 
   this->parent_->add_scanner_state_listener(this);
+
+  this->set_interval(100, [this]() {
+    if (api::global_api_server->is_connected() && this->api_connection_ != nullptr) {
+      this->flush_pending_advertisements_();
+      return;
+    }
+    for (uint8_t i = 0; i < this->connection_count_; i++) {
+      auto *connection = this->connections_[i];
+      if (connection->get_address() != 0 && !connection->disconnect_pending()) {
+        connection->disconnect();
+      }
+    }
+  });
 }
 
 void BluetoothProxy::on_scanner_state(esp32_ble_tracker::ScannerState state) {
@@ -120,25 +133,6 @@ void BluetoothProxy::dump_config() {
                 YESNO(this->active_), this->connection_count_);
 }
 
-void BluetoothProxy::loop() {
-  // Run advertisement flush / connection cleanup every 100ms
-  uint32_t now = App.get_loop_component_start_time();
-  if (now - this->last_advertisement_flush_time_ < 100)
-    return;
-  this->last_advertisement_flush_time_ = now;
-
-  if (api::global_api_server->is_connected() && this->api_connection_ != nullptr) {
-    this->flush_pending_advertisements_();
-    return;
-  }
-  for (uint8_t i = 0; i < this->connection_count_; i++) {
-    auto *connection = this->connections_[i];
-    if (connection->get_address() != 0 && !connection->disconnect_pending()) {
-      connection->disconnect();
-    }
-  }
-}
-
 esp32_ble_tracker::AdvertisementParserType BluetoothProxy::get_advertisement_parser_type() {
   return esp32_ble_tracker::AdvertisementParserType::RAW_ADVERTISEMENTS;
 }
@@ -207,6 +201,7 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
         connection->set_connection_type(espbt::ConnectionType::V3_WITHOUT_CACHE);
         this->log_connection_info_(connection, "v3 without cache");
       }
+      uint64_to_bd_addr(msg.address, connection->remote_bda_);
       connection->set_remote_addr_type(static_cast<esp_ble_addr_type_t>(msg.address_type));
       connection->set_state(espbt::ClientState::DISCOVERED);
       this->send_connections_free();

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -65,7 +65,6 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener,
   bool parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) override;
   void dump_config() override;
   void setup() override;
-  void loop() override;
   esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;
 
   void register_connection(BluetoothConnection *connection) {
@@ -177,9 +176,6 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener,
   // BLE advertisement batching
   api::BluetoothLERawAdvertisementsResponse response_;
 
-  // Group 3: 4-byte types
-  uint32_t last_advertisement_flush_time_{0};
-
   // Pre-allocated response message - always ready to send
   api::BluetoothConnectionsFreeResponse connections_free_response_;
 

esphome/components/bme680/bme680.cpp

@@ -78,43 +78,43 @@ void BME680Component::setup() {
   }
 
   // Read calibration
-  uint8_t coeff1[25];
-  if (!this->read_bytes(BME680_REGISTER_COEFF1, coeff1, 25)) {
+  uint8_t cal1[25];
+  if (!this->read_bytes(BME680_REGISTER_COEFF1, cal1, 25)) {
     this->mark_failed();
     return;
   }
-  uint8_t coeff2[16];
-  if (!this->read_bytes(BME680_REGISTER_COEFF2, coeff2, 16)) {
+  uint8_t cal2[16];
+  if (!this->read_bytes(BME680_REGISTER_COEFF2, cal2, 16)) {
     this->mark_failed();
     return;
   }
 
-  this->calibration_.t1 = coeff2[9] << 8 | coeff2[8];
-  this->calibration_.t2 = coeff1[2] << 8 | coeff1[1];
-  this->calibration_.t3 = coeff1[3];
+  this->calibration_.t1 = cal2[9] << 8 | cal2[8];
+  this->calibration_.t2 = cal1[2] << 8 | cal1[1];
+  this->calibration_.t3 = cal1[3];
 
-  this->calibration_.h1 = coeff2[2] << 4 | (coeff2[1] & 0x0F);
-  this->calibration_.h2 = coeff2[0] << 4 | coeff2[1] >> 4;
-  this->calibration_.h3 = coeff2[3];
-  this->calibration_.h4 = coeff2[4];
-  this->calibration_.h5 = coeff2[5];
-  this->calibration_.h6 = coeff2[6];
-  this->calibration_.h7 = coeff2[7];
+  this->calibration_.h1 = cal2[2] << 4 | (cal2[1] & 0x0F);
+  this->calibration_.h2 = cal2[0] << 4 | cal2[1] >> 4;
+  this->calibration_.h3 = cal2[3];
+  this->calibration_.h4 = cal2[4];
+  this->calibration_.h5 = cal2[5];
+  this->calibration_.h6 = cal2[6];
+  this->calibration_.h7 = cal2[7];
 
-  this->calibration_.p1 = coeff1[6] << 8 | coeff1[5];
-  this->calibration_.p2 = coeff1[8] << 8 | coeff1[7];
-  this->calibration_.p3 = coeff1[9];
-  this->calibration_.p4 = coeff1[12] << 8 | coeff1[11];
-  this->calibration_.p5 = coeff1[14] << 8 | coeff1[13];
-  this->calibration_.p6 = coeff1[16];
-  this->calibration_.p7 = coeff1[15];
-  this->calibration_.p8 = coeff1[20] << 8 | coeff1[19];
-  this->calibration_.p9 = coeff1[22] << 8 | coeff1[21];
-  this->calibration_.p10 = coeff1[23];
+  this->calibration_.p1 = cal1[6] << 8 | cal1[5];
+  this->calibration_.p2 = cal1[8] << 8 | cal1[7];
+  this->calibration_.p3 = cal1[9];
+  this->calibration_.p4 = cal1[12] << 8 | cal1[11];
+  this->calibration_.p5 = cal1[14] << 8 | cal1[13];
+  this->calibration_.p6 = cal1[16];
+  this->calibration_.p7 = cal1[15];
+  this->calibration_.p8 = cal1[20] << 8 | cal1[19];
+  this->calibration_.p9 = cal1[22] << 8 | cal1[21];
+  this->calibration_.p10 = cal1[23];
 
-  this->calibration_.gh1 = coeff2[14];
-  this->calibration_.gh2 = coeff2[12] << 8 | coeff2[13];
-  this->calibration_.gh3 = coeff2[15];
+  this->calibration_.gh1 = cal2[14];
+  this->calibration_.gh2 = cal2[12] << 8 | cal2[13];
+  this->calibration_.gh3 = cal2[15];
 
   uint8_t temp_var = 0;
   if (!this->read_byte(0x02, &temp_var)) {

esphome/components/button/__init__.py

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

esphome/components/climate/__init__.py

@@ -49,11 +49,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import (
-    entity_duplicate_validator,
-    queue_entity_register,
-    setup_entity,
-)
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
 IS_PLATFORM_COMPONENT = True
@@ -446,7 +442,7 @@ async def setup_climate_core_(var, config):
 async def register_climate(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    queue_entity_register("climate", config)
+    cg.add(cg.App.register_climate(var))
     CORE.register_platform_component("climate", var)
     await setup_climate_core_(var, config)
 

esphome/components/climate/climate.cpp

@@ -374,8 +374,7 @@ void Climate::save_state_(const ClimateTraits &traits) {
 #define TEMP_IGNORE_MEMACCESS
 #endif
   ClimateDeviceRestoreState state{};
-  // 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
+  // initialize as zero to prevent random data on stack triggering erase
   memset(&state, 0, sizeof(ClimateDeviceRestoreState));
 #ifdef TEMP_IGNORE_MEMACCESS
 #pragma GCC diagnostic pop

esphome/components/cover/__init__.py

@@ -39,7 +39,6 @@ from esphome.const import (
 from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
     entity_duplicate_validator,
-    queue_entity_register,
     setup_device_class,
     setup_entity,
 )
@@ -233,7 +232,7 @@ async def setup_cover_core_(var, config):
 async def register_cover(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    queue_entity_register("cover", config)
+    cg.add(cg.App.register_cover(var))
     CORE.register_platform_component("cover", var)
     await setup_cover_core_(var, config)
 

esphome/components/cover/cover.h

@@ -1,6 +1,5 @@
 #pragma once
 
-// DNM: integration-test bucketing CI probe — do not merge.
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"

esphome/components/datetime/__init__.py

@@ -22,11 +22,7 @@ from esphome.const import (
     CONF_YEAR,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import (
-    entity_duplicate_validator,
-    queue_entity_register,
-    setup_entity,
-)
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@rfdarter", "@jesserockz"]
@@ -164,7 +160,7 @@ async def register_datetime(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     entity_type = config[CONF_TYPE].lower()
-    queue_entity_register(entity_type, config)
+    cg.add(getattr(cg.App, f"register_{entity_type}")(var))
     CORE.register_platform_component(entity_type, var)
     await setup_datetime_core_(var, config)
 

esphome/components/debug/debug_zephyr.cpp

@@ -17,13 +17,11 @@ 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) {
-  // NOLINTNEXTLINE(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
-  return *reinterpret_cast<volatile uint32_t *>(addr);
+  return *reinterpret_cast<volatile uint32_t *>(addr);  // NOLINT(performance-no-int-to-ptr)
 }
 
 static inline uint8_t read_mem_u8(uintptr_t addr) {
-  // NOLINTNEXTLINE(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
-  return *reinterpret_cast<volatile uint8_t *>(addr);
+  return *reinterpret_cast<volatile uint8_t *>(addr);  // NOLINT(performance-no-int-to-ptr)
 }
 
 // defines from https://github.com/adafruit/Adafruit_nRF52_Bootloader which prints those information
@@ -100,7 +98,6 @@ 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:");
@@ -134,7 +131,6 @@ 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
 
@@ -163,9 +159,8 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   char *buf = buffer.data();
 
   // Main supply status
-  // 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.";
+  const char *supply_status =
+      (nrf_power_mainregstatus_get(NRF_POWER) == 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/deep_sleep/__init__.py

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

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -9,11 +9,18 @@ static const char *const TAG = "deep_sleep";
 // 5 seconds for deep sleep to ensure clean disconnect from Home Assistant
 static const uint32_t TEARDOWN_TIMEOUT_DEEP_SLEEP_MS = 5000;
 
-bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+bool global_has_deep_sleep = false;                   // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+std::atomic<DeepSleepComponent *> global_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void DeepSleepComponent::setup() {
+#ifdef USE_ZEPHYR
+  k_sem_init(&this->wakeup_sem_, 0, 1);
+#endif
   global_has_deep_sleep = true;
   this->schedule_sleep_();
+  // It can be used from another thread for waking up the device.
+  // It should be called as last item in setup.
+  global_deep_sleep.store(this);
 }
 
 void DeepSleepComponent::schedule_sleep_() {

esphome/components/deep_sleep/deep_sleep_component.h

@@ -4,6 +4,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include <atomic>
+
 #ifdef USE_ESP32
 #include <esp_sleep.h>
 #endif
@@ -13,6 +15,10 @@
 #include "esphome/core/time.h"
 #endif
 
+#ifdef USE_ZEPHYR
+#include <zephyr/kernel.h>
+#endif
+
 #include <cinttypes>
 
 namespace esphome {
@@ -119,6 +125,9 @@ class DeepSleepComponent : public Component {
 
   void prevent_deep_sleep();
   void allow_deep_sleep();
+#ifdef USE_ZEPHYR
+  void wakeup();
+#endif
 
  protected:
   // Returns nullopt if no run duration is set. Otherwise, returns the run
@@ -158,6 +167,9 @@ class DeepSleepComponent : public Component {
   optional<uint32_t> run_duration_;
   bool next_enter_deep_sleep_{false};
   bool prevent_{false};
+#ifdef USE_ZEPHYR
+  k_sem wakeup_sem_;
+#endif
 };
 
 extern bool global_has_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -244,5 +256,8 @@ template<typename... Ts> class AllowDeepSleepAction : public Action<Ts...>, publ
   void play(const Ts &...x) override { this->parent_->allow_deep_sleep(); }
 };
 
+extern std::atomic<DeepSleepComponent *>
+    global_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 }  // namespace deep_sleep
 }  // namespace esphome

esphome/components/deep_sleep/deep_sleep_zephyr.cpp

@@ -1,13 +1,17 @@
 #include "deep_sleep_component.h"
 #ifdef USE_ZEPHYR
 #include "esphome/core/log.h"
-#include "esphome/core/wake.h"
 #include <zephyr/sys/poweroff.h>
+#include <zephyr/kernel.h>
+#include <zephyr/stats/stats.h>
+#include <zephyr/pm/pm.h>
 
 namespace esphome::deep_sleep {
 
 static const char *const TAG = "deep_sleep";
 
+void DeepSleepComponent::wakeup() { k_sem_give(&this->wakeup_sem_); }
+
 optional<uint32_t> DeepSleepComponent::get_run_duration_() const { return this->run_duration_; }
 
 void DeepSleepComponent::dump_config_platform_() {}
@@ -15,8 +19,9 @@ void DeepSleepComponent::dump_config_platform_() {}
 bool DeepSleepComponent::prepare_to_sleep_() { return true; }
 
 void DeepSleepComponent::deep_sleep_() {
+  k_timeout_t sleep_duration = K_FOREVER;
   if (this->sleep_duration_.has_value()) {
-    esphome::internal::wakeable_delay(static_cast<uint32_t>(*this->sleep_duration_ / 1000));
+    sleep_duration = K_USEC(*this->sleep_duration_);
   } else {
 #ifndef USE_ZIGBEE
     // the device can be woken up through one of the following signals:
@@ -28,12 +33,11 @@ void DeepSleepComponent::deep_sleep_() {
     //
     // The system is reset when it wakes up from System OFF mode.
     sys_poweroff();
-#else
-    esphome::internal::wakeable_delay(UINT32_MAX);
 #endif
   }
-  const bool woke = esphome::wake_request_take();
-  if (woke) {
+  // It might wake up immediately if k_sem_give was called again after wake up
+  int ret = k_sem_take(&this->wakeup_sem_, sleep_duration);
+  if (ret == 0) {
     ESP_LOGD(TAG, "Woken up by another thread");
   } else {
     ESP_LOGD(TAG, "Timeout expired (normal sleep)");

esphome/components/demo/demo_alarm_control_panel.h

@@ -29,7 +29,7 @@ class DemoAlarmControlPanel : public AlarmControlPanel, public Component {
  protected:
   void control(const AlarmControlPanelCall &call) override {
     auto state = call.get_state().value_or(ACP_STATE_DISARMED);
-    const auto &code = call.get_code();
+    auto code = call.get_code();
     switch (state) {
       case ACP_STATE_ARMED_AWAY:
         if (this->get_requires_code_to_arm()) {

esphome/components/dfrobot_sen0395/dfrobot_sen0395.cpp

@@ -104,9 +104,8 @@ int8_t CircularCommandQueue::enqueue(std::unique_ptr<Command> cmd) {
   if (this->is_full()) {
     ESP_LOGE(TAG, "Command queue is full");
     return -1;
-  } else if (this->is_empty()) {
+  } else if (this->is_empty())
     front_++;
-  }
   rear_ = (rear_ + 1) % COMMAND_QUEUE_SIZE;
   commands_[rear_] = std::move(cmd);  // Transfer ownership using std::move
   return 1;

esphome/components/e131/e131_addressable_light_effect.cpp

@@ -56,7 +56,8 @@ 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(), output_offset + get_lights_per_universe(), output_offset + lights_in_packet});
+  int output_end =
+      std::min(it->size(), std::min(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,15 +5,6 @@
 // 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"
@@ -23,9 +14,7 @@ namespace ens160_base {
 
 static const char *const TAG = "ens160";
 
-// 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 uint8_t ENS160_BOOTING = 10;
 
 static const uint16_t ENS160_PART_ID = 0x0160;
 
@@ -102,8 +91,6 @@ 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;
@@ -115,7 +102,6 @@ void ENS160Component::setup() {
     this->mark_failed();
     return;
   }
-  delay(ENS160_BOOTING);
 
   // read firmware version
   if (!this->write_byte(ENS160_REG_COMMAND, ENS160_COMMAND_GET_APPVER)) {
@@ -123,8 +109,6 @@ 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;
@@ -239,6 +223,7 @@ 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,9 +729,6 @@ 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",
@@ -1727,11 +1724,6 @@ async def to_code(config):
         CORE.relative_internal_path(".espressif")
     )
 
-    # Both ESP-IDF and ESP32 Arduino builds generate IDF app metadata. Keep
-    # volatile build path/time data out of the binary so equivalent projects can
-    # produce reproducible outputs and downstream tooling can reuse artifacts.
-    add_idf_sdkconfig_option("CONFIG_APP_REPRODUCIBLE_BUILD", True)
-
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         cg.add_build_flag("-DUSE_ESP_IDF")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")

esphome/components/esp32/core.cpp

@@ -1,8 +1,17 @@
 #ifdef USE_ESP32
 
-#include "esphome/core/application.h"
 #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 "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>
 
@@ -13,13 +22,70 @@ extern "C" __attribute__((weak)) void initArduino() {}
 
 namespace esphome {
 
-// HAL functions live in hal.cpp. This file keeps only the loop task setup.
+void HOT yield() { vPortYield(); }
+// Use xTaskGetTickCount() when tick rate is 1 kHz (ESPHome's default via sdkconfig),
+// falling back to esp_timer for non-standard rates. IRAM_ATTR is required because
+// Wiegand and ZyAura call millis() from IRAM_ATTR ISR handlers on ESP32.
+// xTaskGetTickCountFromISR() is used in ISR context to satisfy the FreeRTOS API contract.
+uint32_t IRAM_ATTR HOT millis() {
+#if CONFIG_FREERTOS_HZ == 1000
+  if (xPortInIsrContext()) [[unlikely]] {
+    return xTaskGetTickCountFromISR();
+  }
+  return xTaskGetTickCount();
+#else
+  return micros_to_millis(static_cast<uint64_t>(esp_timer_get_time()));
+#endif
+}
+// millis_64() stays on esp_timer — a different clock from xTaskGetTickCount(). This is
+// safe because the two are never cross-compared: millis() values are only used for
+// millis()-vs-millis() deltas (feed_wdt, warn_blocking, component start time), while
+// millis_64() is used by the Scheduler and uptime sensors. On ESP32 (USE_NATIVE_64BIT_TIME),
+// Scheduler::millis_64_from_(now) discards the 32-bit now and calls millis_64() directly,
+// so the Scheduler is internally consistent on the esp_timer clock.
+uint64_t HOT millis_64() { return micros_to_millis<uint64_t>(static_cast<uint64_t>(esp_timer_get_time())); }
+void HOT delay(uint32_t ms) { vTaskDelay(ms / portTICK_PERIOD_MS); }
+uint32_t IRAM_ATTR HOT micros() { return (uint32_t) esp_timer_get_time(); }
+void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
+void arch_restart() {
+  esp_restart();
+  // restart() doesn't always end execution
+  while (true) {  // NOLINT(clang-diagnostic-unreachable-code)
+    yield();
+  }
+}
+
+void arch_init() {
+#ifdef USE_ESP32_CRASH_HANDLER
+  // Read crash data from previous boot before anything else
+  esp32::crash_handler_read_and_clear();
+#endif
+
+  // Enable the task watchdog only on the loop task (from which we're currently running)
+  esp_task_wdt_add(nullptr);
+
+  // Handle OTA rollback: mark partition valid immediately unless USE_OTA_ROLLBACK is enabled,
+  // in which case safe_mode will mark it valid after confirming successful boot.
+#ifndef USE_OTA_ROLLBACK
+  esp_ota_mark_app_valid_cancel_rollback();
+#endif
+}
+void HOT arch_feed_wdt() { esp_task_wdt_reset(); }
+
+uint32_t arch_get_cpu_cycle_count() { return esp_cpu_get_cycle_count(); }
+uint32_t arch_get_cpu_freq_hz() {
+  uint32_t freq = 0;
+  esp_clk_tree_src_get_freq_hz(SOC_MOD_CLK_CPU, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq);
+  return freq;
+}
+
 TaskHandle_t loop_task_handle = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 static StaticTask_t loop_task_tcb;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 static StackType_t
     loop_task_stack[ESPHOME_LOOP_TASK_STACK_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-void loop_task(void *pv_params) {
+void __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+loop_task(void *pv_params) {
   setup();
   while (true) {
     App.loop();

esphome/components/esp32/hal.cpp

@@ -1,71 +0,0 @@
-#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/preferences.cpp

@@ -18,12 +18,6 @@ struct NVSData {
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-// open() runs from app_main() before the logger is initialized, so any failure
-// must be deferred until after global_logger is set. This is emitted from the
-// first make_preference() call, which runs from the generated setup() after
-// log->pre_setup() has run at EARLY_INIT priority.
-static esp_err_t s_open_err = ESP_OK;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
 bool ESP32PreferenceBackend::save(const uint8_t *data, size_t len) {
   // try find in pending saves and update that
   for (auto &obj : s_pending_save) {
@@ -76,14 +70,12 @@ bool ESP32PreferenceBackend::load(uint8_t *data, size_t len) {
 }
 
 void ESP32Preferences::open() {
-  // Runs from app_main() before the logger is initialized; any logging here
-  // must be deferred. See s_open_err and make_preference() below.
   nvs_flash_init();
   esp_err_t err = nvs_open("esphome", NVS_READWRITE, &this->nvs_handle);
   if (err == 0)
     return;
 
-  s_open_err = err;
+  ESP_LOGW(TAG, "nvs_open failed: %s - erasing NVS", esp_err_to_name(err));
   nvs_flash_deinit();
   nvs_flash_erase();
   nvs_flash_init();
@@ -95,14 +87,6 @@ void ESP32Preferences::open() {
 }
 
 ESPPreferenceObject ESP32Preferences::make_preference(size_t length, uint32_t type) {
-  if (s_open_err != ESP_OK) {
-    if (this->nvs_handle == 0) {
-      ESP_LOGW(TAG, "nvs_open failed: %s - NVS unavailable", esp_err_to_name(s_open_err));
-    } else {
-      ESP_LOGW(TAG, "nvs_open failed: %s - erased NVS", esp_err_to_name(s_open_err));
-    }
-    s_open_err = ESP_OK;
-  }
   auto *pref = new ESP32PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
   pref->nvs_handle = this->nvs_handle;
   pref->key = type;

esphome/components/esp32_ble/ble_uuid.cpp

@@ -104,7 +104,7 @@ ESPBTUUID ESPBTUUID::as_128bit() const {
   } else {
     uuid32 = this->uuid_.uuid.uuid16;
   }
-  for (uint16_t i = 0; i < this->uuid_.len; i++) {
+  for (uint8_t i = 0; i < this->uuid_.len; i++) {
     data[12 + i] = ((uuid32 >> i * 8) & 0xFF);
   }
   return ESPBTUUID::from_raw(data);

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

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

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -160,13 +160,9 @@ struct ClientStateCounts {
   uint8_t connecting = 0;
   uint8_t discovered = 0;
   uint8_t disconnecting = 0;
-  // CONNECTED + ESTABLISHED clients. Tracked so coex stays at PREFER_BT
-  // while active connections may still need to send/receive GATT traffic.
-  uint8_t active = 0;
 
   bool operator==(const ClientStateCounts &other) const {
-    return connecting == other.connecting && discovered == other.discovered && disconnecting == other.disconnecting &&
-           active == other.active;
+    return connecting == other.connecting && discovered == other.discovered && disconnecting == other.disconnecting;
   }
 
   bool operator!=(const ClientStateCounts &other) const { return !(*this == other); }
@@ -385,10 +381,6 @@ class ESP32BLETracker : public Component,
         case ClientState::CONNECTING:
           counts.connecting++;
           break;
-        case ClientState::CONNECTED:
-        case ClientState::ESTABLISHED:
-          counts.active++;
-          break;
         default:
           break;
       }

esphome/components/esp32_touch/esp32_touch.cpp

@@ -216,7 +216,6 @@ void ESP32TouchComponent::setup() {
   // Do initial oneshot scans to populate baseline values
   for (uint32_t i = 0; i < ONESHOT_SCAN_COUNT; i++) {
     err = touch_sensor_trigger_oneshot_scanning(this->sens_handle_, ONESHOT_SCAN_TIMEOUT_MS);
-    App.feed_wdt();  // 3 scans with 2s timeout might exceed WDT, so feed it here to be safe
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Oneshot scan %" PRIu32 " failed: %s", i, esp_err_to_name(err));
     }

esphome/components/esp8266/__init__.py

@@ -314,11 +314,6 @@ async def to_code(config):
         for symbol in ("vprintf", "printf", "fprintf"):
             cg.add_build_flag(f"-Wl,--wrap={symbol}")
 
-    # Wrap Arduino's millis() so all callers (including Arduino libraries and ISR
-    # handlers) use our fast accumulator instead of the expensive 4x 64-bit multiply
-    # implementation in the Arduino ESP8266 core.
-    cg.add_build_flag("-Wl,--wrap=millis")
-
     cg.add_platformio_option("board_build.flash_mode", config[CONF_BOARD_FLASH_MODE])
 
     ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]

esphome/components/esp8266/core.cpp

@@ -15,76 +15,12 @@ extern "C" {
 
 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);
-  }
-}
-// delayMicroseconds(), arch_feed_wdt(), and progmem_read_*() are inlined in hal/hal_esp8266.h.
+void HOT yield() { ::yield(); }
+uint32_t IRAM_ATTR HOT millis() { return ::millis(); }
+uint64_t millis_64() { return Millis64Impl::compute(::millis()); }
+void HOT delay(uint32_t ms) { ::delay(ms); }
+uint32_t IRAM_ATTR HOT micros() { return ::micros(); }
+void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
 void arch_restart() {
   system_restart();
   // restart() doesn't always end execution
@@ -93,6 +29,17 @@ void arch_restart() {
   }
 }
 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; }
 
@@ -131,12 +78,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,7 +140,6 @@ 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/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,clang-analyzer-core.FixedAddressDereference)
+  *dest = ESP_RTC_USER_MEM[index];  // NOLINT(performance-no-int-to-ptr)
   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;                          // NOLINT(clang-analyzer-core.FixedAddressDereference)
+  *ptr = value;
   return true;
 }
 

esphome/components/esphome/ota/ota_esphome.cpp

@@ -292,7 +292,6 @@ void ESPHomeOTAComponent::handle_data_() {
   bool update_started = false;
   size_t total = 0;
   uint32_t last_progress = 0;
-  uint32_t last_data_ms = 0;
   uint8_t buf[OTA_BUFFER_SIZE];
   char *sbuf = reinterpret_cast<char *>(buf);
   size_t ota_size;
@@ -351,18 +350,8 @@ void ESPHomeOTAComponent::handle_data_() {
   // Acknowledge MD5 OK - 1 byte
   this->write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK);
 
-  // Track when we last received data so a silently-vanished peer (no FIN/RST
-  // delivered, e.g. uploader killed mid-transfer or NAT/router dropped state)
-  // can't wedge the device indefinitely. Without this, the loop only exits
-  // on actual data, EOF, or a non-EWOULDBLOCK error from read(), and lwIP
-  // TCP keepalive isn't enabled here.
-  last_data_ms = millis();
   while (total < ota_size) {
-    if (millis() - last_data_ms > OTA_SOCKET_TIMEOUT_DATA) {
-      ESP_LOGW(TAG, "No data received for %u ms", (unsigned) OTA_SOCKET_TIMEOUT_DATA);
-      error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
-      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
-    }
+    // TODO: timeout check
     size_t remaining = ota_size - total;
     size_t requested = remaining < OTA_BUFFER_SIZE ? remaining : OTA_BUFFER_SIZE;
     ssize_t read = this->client_->read(buf, requested);
@@ -380,7 +369,6 @@ void ESPHomeOTAComponent::handle_data_() {
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
 
-    last_data_ms = millis();
     error_code = this->backend_->write(buf, read);
     if (error_code != ota::OTA_RESPONSE_OK) {
       ESP_LOGW(TAG, "Flash write err %d", error_code);

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
-ESPNowReceivePacketHandler = espnow_ns.class_("ESPNowReceivePacketHandler")
+ESPNowReceivedPacketHandler = espnow_ns.class_("ESPNowReceivedPacketHandler")
 ESPNowUnknownPeerHandler = espnow_ns.class_("ESPNowUnknownPeerHandler")
-ESPNowBroadcastHandler = espnow_ns.class_("ESPNowBroadcastHandler")
+ESPNowBroadcastedHandler = espnow_ns.class_("ESPNowBroadcastedHandler")
 
 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, ESPNowReceivePacketHandler
+    "OnReceiveTrigger", ESPNowHandlerTrigger, ESPNowReceivedPacketHandler
 )
-OnBroadcastTrigger = espnow_ns.class_(
-    "OnBroadcastTrigger", ESPNowHandlerTrigger, ESPNowBroadcastHandler
+OnBroadcastedTrigger = espnow_ns.class_(
+    "OnBroadcastedTrigger", ESPNowHandlerTrigger, ESPNowBroadcastedHandler
 )
 
 
@@ -94,7 +94,7 @@ CONFIG_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_ON_BROADCAST): automation.validate_automation(
                 {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnBroadcastTrigger),
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnBroadcastedTrigger),
                     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_receive_handler(trigger))
+        cg.add(var.register_received_handler(trigger))
 
     for on_receive in config.get(CONF_ON_BROADCAST, []):
         trigger = await _trigger_to_code(on_receive)
-        cg.add(var.register_broadcast_handler(trigger))
+        cg.add(var.register_broadcasted_handler(trigger))
 
 
 # ========================================== A C T I O N S ================================================

esphome/components/espnow/automation.h

@@ -67,7 +67,6 @@ template<typename... Ts> class SendAction : public Action<Ts...>, public Parente
     }
   }
 
- protected:
   void play(const Ts &...x) override { /* ignore - see play_complex */
   }
 
@@ -76,6 +75,7 @@ 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);
 
- protected:
+ public:
   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);
 
- protected:
+ public:
   void play(const Ts &...x) override {
     peer_address_t address = this->address_.value(x...);
     this->parent_->del_peer(address.data());
@@ -107,9 +107,8 @@ 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;
@@ -126,9 +125,9 @@ class OnReceiveTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *,
     memcpy(this->address_, address.data(), ESP_NOW_ETH_ALEN);
   }
 
-  explicit OnReceiveTrigger() {}
+  explicit OnReceiveTrigger() : has_address_(false) {}
 
-  bool on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
+  bool on_received(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;
@@ -139,7 +138,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 {
@@ -149,15 +148,15 @@ class OnUnknownPeerTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_
     return false;  // Return false to continue processing other internal handlers
   }
 };
-class OnBroadcastTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
-                           public ESPNowBroadcastHandler {
+class OnBroadcastedTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
+                             public ESPNowBroadcastedHandler {
  public:
-  explicit OnBroadcastTrigger(std::array<uint8_t, ESP_NOW_ETH_ALEN> address) : has_address_(true) {
+  explicit OnBroadcastedTrigger(std::array<uint8_t, ESP_NOW_ETH_ALEN> address) : has_address_(true) {
     memcpy(this->address_, address.data(), ESP_NOW_ETH_ALEN);
   }
-  explicit OnBroadcastTrigger() {}
+  explicit OnBroadcastedTrigger() : has_address_(false) {}
 
-  bool on_broadcast(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 match = !this->has_address_ || (memcmp(this->address_, info.src_addr, ESP_NOW_ETH_ALEN) == 0);
     if (!match)
       return false;
@@ -168,7 +167,7 @@ class OnBroadcastTrigger : 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];
 };
 
 }  // 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->broadcast_handlers_) {
-              if (handler->on_broadcast(info, packet->packet_.receive.data, packet->packet_.receive.size))
+            for (auto *handler : this->broadcasted_handlers_) {
+              if (handler->on_broadcasted(info, packet->packet_.receive.data, packet->packet_.receive.size))
                 break;  // If a handler returns true, stop processing further handlers
             }
           } else {
-            for (auto *handler : this->receive_handlers_) {
-              if (handler->on_receive(info, packet->packet_.receive.data, packet->packet_.receive.size))
+            for (auto *handler : this->received_handlers_) {
+              if (handler->on_received(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_RECEIVE = 2,
-  ON_BROADCAST = 3,
+  ON_RECEIVED = 2,
+  ON_BROADCASTED = 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_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+  virtual bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
 };
-/// Handler interface for receiving ESPNow broadcast packets
+/// Handler interface for receiving broadcasted ESPNow packets
 /// Components should inherit from this class to handle incoming ESPNow data
-class ESPNowBroadcastHandler {
+class ESPNowBroadcastedHandler {
  public:
-  /// Called when an ESPNow broadcast packet is received
+  /// Called when a broadcasted ESPNow 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_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+  virtual bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
 };
 
 class ESPNowComponent : public Component {
@@ -136,11 +136,13 @@ 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_receive_handler(ESPNowReceivedPacketHandler *handler) { this->receive_handlers_.push_back(handler); }
+  void register_received_handler(ESPNowReceivedPacketHandler *handler) { this->received_handlers_.push_back(handler); }
   void register_unknown_peer_handler(ESPNowUnknownPeerHandler *handler) {
     this->unknown_peer_handlers_.push_back(handler);
   }
-  void register_broadcast_handler(ESPNowBroadcastHandler *handler) { this->broadcast_handlers_.push_back(handler); }
+  void register_broadcasted_handler(ESPNowBroadcastedHandler *handler) {
+    this->broadcasted_handlers_.push_back(handler);
+  }
 
  protected:
   friend void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size);
@@ -154,8 +156,8 @@ class ESPNowComponent : public Component {
   void send_();
 
   std::vector<ESPNowUnknownPeerHandler *> unknown_peer_handlers_;
-  std::vector<ESPNowReceivedPacketHandler *> receive_handlers_;
-  std::vector<ESPNowBroadcastHandler *> broadcast_handlers_;
+  std::vector<ESPNowReceivedPacketHandler *> received_handlers_;
+  std::vector<ESPNowBroadcastedHandler *> broadcasted_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_receive_handler(this);
+  this->parent_->register_received_handler(this);
 
-  // Register broadcast handler
-  this->parent_->register_broadcast_handler(this);
+  // Register broadcasted handler
+  this->parent_->register_broadcasted_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_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) {
+bool ESPNowTransport::on_received(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_receive(const ESPNowRecvInfo &info, const uint8_t *data
   return false;  // Allow other handlers to run
 }
 
-bool ESPNowTransport::on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) {
+bool ESPNowTransport::on_broadcasted(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 ESPNowBroadcastHandler {
+                        public ESPNowBroadcastedHandler {
  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_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;
+  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;
 
  protected:
   void send_packet(const std::vector<uint8_t> &buf) const override;

esphome/components/event/__init__.py

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

esphome/components/external_components/__init__.py

@@ -1,6 +1,5 @@
 import logging
 from pathlib import Path
-from typing import Any
 
 from esphome import git, loader
 import esphome.config_validation as cv
@@ -18,7 +17,7 @@ from esphome.const import (
     TYPE_GIT,
     TYPE_LOCAL,
 )
-from esphome.core import CORE, TimePeriodSeconds
+from esphome.core import CORE
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,15 +35,17 @@ CONFIG_SCHEMA = cv.ensure_list(
 )
 
 
-async def to_code(config: dict[str, Any]) -> None:
+async def to_code(config):
     pass
 
 
-def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> Path:
+def _process_git_config(config: dict, refresh, skip_update: bool = False) -> str:
+    # When skip_update is True, use NEVER_REFRESH to prevent updates
+    actual_refresh = git.NEVER_REFRESH if skip_update else refresh
     repo_dir, _ = git.clone_or_update(
         url=config[CONF_URL],
         ref=config.get(CONF_REF),
-        refresh=refresh,
+        refresh=actual_refresh,
         domain=DOMAIN,
         username=config.get(CONF_USERNAME),
         password=config.get(CONF_PASSWORD),
@@ -71,12 +72,12 @@ def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> P
     return components_dir
 
 
-def _process_single_config(config: dict[str, Any]) -> None:
+def _process_single_config(config: dict, skip_update: bool = False):
     conf = config[CONF_SOURCE]
     if conf[CONF_TYPE] == TYPE_GIT:
         with cv.prepend_path([CONF_SOURCE]):
             components_dir = _process_git_config(
-                config[CONF_SOURCE], config[CONF_REFRESH]
+                config[CONF_SOURCE], config[CONF_REFRESH], skip_update
             )
     elif conf[CONF_TYPE] == TYPE_LOCAL:
         components_dir = Path(CORE.relative_config_path(conf[CONF_PATH]))
@@ -106,7 +107,7 @@ def _process_single_config(config: dict[str, Any]) -> None:
     loader.install_meta_finder(components_dir, allowed_components=allowed_components)
 
 
-def do_external_components_pass(config: dict[str, Any]) -> None:
+def do_external_components_pass(config: dict, skip_update: bool = False) -> None:
     conf = config.get(DOMAIN)
     if conf is None:
         return
@@ -114,4 +115,4 @@ def do_external_components_pass(config: dict[str, Any]) -> None:
         conf = CONFIG_SCHEMA(conf)
         for i, c in enumerate(conf):
             with cv.prepend_path(i):
-                _process_single_config(c)
+                _process_single_config(c, skip_update)

esphome/components/ezo/ezo.cpp

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

esphome/components/fan/__init__.py

@@ -31,19 +31,13 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-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
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 
 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 = {
@@ -298,7 +292,7 @@ async def setup_fan_core_(var, config):
 async def register_fan(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    queue_entity_register("fan", config)
+    cg.add(cg.App.register_fan(var))
     CORE.register_platform_component("fan", var)
     await setup_fan_core_(var, config)
 
@@ -349,38 +343,17 @@ 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])
-
-    # 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)
+    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
 
 
 @automation.register_action(

esphome/components/fan/automation.h

@@ -7,24 +7,29 @@
 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:
-  using ApplyFn = void (*)(FanCall &, const Ts &...);
-  TurnOnAction(Fan *state, ApplyFn apply) : state_(state), apply_(apply) {}
+  explicit TurnOnAction(Fan *state) : state_(state) {}
+
+  TEMPLATABLE_VALUE(bool, oscillating)
+  TEMPLATABLE_VALUE(int, speed)
+  TEMPLATABLE_VALUE(FanDirection, direction)
 
   void play(const Ts &...x) override {
     auto call = this->state_->turn_on();
-    this->apply_(call, x...);
+    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...));
+    }
     call.perform();
   }
 
   Fan *state_;
-  ApplyFn apply_;
 };
 
 template<typename... Ts> class TurnOffAction : public Action<Ts...> {

esphome/components/feedback/feedback_cover.cpp

@@ -3,12 +3,11 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 
-namespace esphome::feedback {
+namespace esphome {
+namespace feedback {
 
 static const char *const TAG = "feedback.cover";
 
-static constexpr uint32_t DIRECTION_CHANGE_TIMEOUT_ID = 1;
-
 using namespace esphome::cover;
 
 void FeedbackCover::setup() {
@@ -38,7 +37,7 @@ void FeedbackCover::setup() {
   }
 #endif
 
-  this->last_recompute_time_ = this->start_dir_time_ = App.get_loop_component_start_time();
+  this->last_recompute_time_ = this->start_dir_time_ = millis();
 }
 
 CoverTraits FeedbackCover::get_traits() {
@@ -136,7 +135,7 @@ void FeedbackCover::set_close_endstop(binary_sensor::BinarySensor *close_endstop
 #endif
 
 void FeedbackCover::endstop_reached_(bool open_endstop) {
-  const uint32_t now = App.get_loop_component_start_time();
+  const uint32_t now = millis();
 
   this->position = open_endstop ? COVER_OPEN : COVER_CLOSED;
 
@@ -175,7 +174,7 @@ void FeedbackCover::set_current_operation_(cover::CoverOperation operation, bool
   if (!is_triggered || (this->open_feedback_ == nullptr || this->close_feedback_ == nullptr))
 #endif
   {
-    const uint32_t now = App.get_loop_component_start_time();
+    auto now = millis();
     this->current_operation = operation;
     this->start_dir_time_ = this->last_recompute_time_ = now;
     this->publish_state();
@@ -307,7 +306,7 @@ void FeedbackCover::control(const CoverCall &call) {
 
 void FeedbackCover::stop_prev_trigger_() {
   if (this->direction_change_waittime_.has_value()) {
-    this->cancel_timeout(DIRECTION_CHANGE_TIMEOUT_ID);
+    this->cancel_timeout("direction_change");
   }
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
@@ -375,10 +374,12 @@ 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, waittime, [this, dir]() { this->start_direction_(dir); });
+
+    this->set_timeout("direction_change", *this->direction_change_waittime_,
+                      [this, dir]() { this->start_direction_(dir); });
+
   } else {
     this->set_current_operation_(dir, true);
     this->prev_command_trigger_ = trig;
@@ -394,7 +395,7 @@ void FeedbackCover::recompute_position_() {
   if (this->current_operation == COVER_OPERATION_IDLE)
     return;
 
-  const uint32_t now = App.get_loop_component_start_time();
+  const uint32_t now = millis();
   float dir;
   float action_dur;
   float min_pos;
@@ -450,4 +451,5 @@ void FeedbackCover::recompute_position_() {
   this->last_recompute_time_ = now;
 }
 
-}  // namespace esphome::feedback
+}  // namespace feedback
+}  // namespace esphome

esphome/components/feedback/feedback_cover.h

@@ -8,7 +8,8 @@
 #endif
 #include "esphome/components/cover/cover.h"
 
-namespace esphome::feedback {
+namespace esphome {
+namespace feedback {
 
 class FeedbackCover : public cover::Cover, public Component {
  public:
@@ -84,4 +85,5 @@ class FeedbackCover : public cover::Cover, public Component {
   uint32_t update_interval_{1000};
 };
 
-}  // namespace esphome::feedback
+}  // namespace feedback
+}  // namespace esphome

esphome/components/haier/hon_climate.cpp

@@ -85,7 +85,7 @@ void HonClimate::set_horizontal_airflow(hon_protocol::HorizontalSwingMode direct
   this->force_send_control_ = true;
 }
 
-const char *HonClimate::get_cleaning_status_text() const {
+std::string HonClimate::get_cleaning_status_text() const {
   switch (this->cleaning_status_) {
     case CleaningState::SELF_CLEAN:
       return "Self clean";
@@ -134,22 +134,29 @@ haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(haie
     }
     // All OK
     hon_protocol::DeviceVersionAnswer *answr = (hon_protocol::DeviceVersionAnswer *) data;
-    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];
+    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);
 #ifdef USE_TEXT_SENSOR
-    this->update_sub_text_sensor_(SubTextSensorType::APPLIANCE_NAME, info.device_name_);
-    this->update_sub_text_sensor_(SubTextSensorType::PROTOCOL_VERSION, info.protocol_version_);
+    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_);
 #endif
-    this->hvac_hardware_info_ = info;
+    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->set_phase(ProtocolPhases::SENDING_INIT_2);
     return result;
   } else {
@@ -340,9 +347,10 @@ void HonClimate::dump_config() {
                   "  Device software version: %s\n"
                   "  Device hardware version: %s\n"
                   "  Device name: %s",
-                  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_);
+                  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());
     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" : ""),
@@ -452,7 +460,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();  // NOLINT(bugprone-unchecked-optional-access)
+          this->action_request_.value().message.reset();
         } else {
           // Message already sent, reseting request and return to idle
           this->action_request_.reset();
@@ -788,7 +796,7 @@ void HonClimate::set_sub_text_sensor(SubTextSensorType type, text_sensor::TextSe
   }
 }
 
-void HonClimate::update_sub_text_sensor_(SubTextSensorType type, const char *value) {
+void HonClimate::update_sub_text_sensor_(SubTextSensorType type, const std::string &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 char *value);
+  void update_sub_text_sensor_(SubTextSensorType type, const std::string &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);
-  const char *get_cleaning_status_text() const;
+  std::string get_cleaning_status_text() const;
   CleaningState get_cleaning_status() const;
   void start_self_cleaning();
   void start_steri_cleaning();
@@ -166,12 +166,11 @@ 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 {
-    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];
+    std::string protocol_version_;
+    std::string software_version_;
+    std::string hardware_version_;
+    std::string device_name_;
     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();  // NOLINT(bugprone-unchecked-optional-access)
+          this->action_request_.value().message.reset();
         } else {
           // Message already sent, reseting request and return to idle
           this->action_request_.reset();
@@ -210,9 +210,8 @@ void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now)
 #ifdef USE_WIFI
       else if (this->send_wifi_signal_ &&
                (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_signal_request_).count() >
-                SIGNAL_LEVEL_UPDATE_INTERVAL_MS)) {
+                SIGNAL_LEVEL_UPDATE_INTERVAL_MS))
         this->set_phase(ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
-      }
 #endif
     } break;
     default:

esphome/components/host/core.cpp

@@ -8,6 +8,7 @@
 #include <csignal>
 #include <sched.h>
 #include <time.h>
+#include <cmath>
 #include <cstdlib>
 
 namespace {
@@ -21,7 +22,9 @@ 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);
+  time_t seconds = spec.tv_sec;
+  uint32_t ms = round(spec.tv_nsec / 1e6);
+  return ((uint32_t) seconds) * 1000U + ms;
 }
 uint64_t millis_64() {
   struct timespec spec;
@@ -40,7 +43,9 @@ void HOT delay(uint32_t ms) {
 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);
+  time_t seconds = spec.tv_sec;
+  uint32_t us = round(spec.tv_nsec / 1e3);
+  return ((uint32_t) seconds) * 1000000U + us;
 }
 void IRAM_ATTR HOT delayMicroseconds(uint32_t us) {
   struct timespec ts;
@@ -72,7 +77,8 @@ uint32_t arch_get_cpu_freq_hz() { return 1000000000U; }
 
 void setup();
 void loop();
-int main() {
+int __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+main() {
   // Install signal handlers for graceful shutdown (flushes preferences to disk)
   std::signal(SIGINT, signal_handler);
   std::signal(SIGTERM, signal_handler);

esphome/components/http_request/http_request.h

@@ -462,7 +462,7 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
     this->request_headers_.push_back({key, value});
   }
 
-  void add_collect_header(const char *value) { this->lower_case_collect_headers_.emplace_back(value); }
+  void add_collect_header(const char *value) { this->lower_case_collect_headers_.push_back(value); }
 
   void init_json(size_t count) { this->json_.init(count); }
   void add_json(const char *key, TemplatableValue<std::string, Ts...> value) { this->json_.push_back({key, value}); }

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, remaining, (size_t) available_data});
+  int bufsize = std::min(max_len, std::min(remaining, (size_t) available_data));
 
   if (bufsize == 0) {
     this->duration_ms += (millis() - start);

esphome/components/i2c/i2c_bus_zephyr.h

@@ -5,7 +5,7 @@
 #include "i2c_bus.h"
 #include "esphome/core/component.h"
 
-struct device;  // NOLINT(readability-identifier-naming) - forward decl of Zephyr's device type
+struct device;
 
 namespace esphome::i2c {
 

esphome/components/image/__init__.py

@@ -744,28 +744,21 @@ async def write_image(config, all_frames=False):
         if frame_count <= 1:
             _LOGGER.warning("Image file %s has no animation frames", path)
 
-    # Encode each frame with its own encoder and concatenate. This keeps every
-    # frame self-contained on disk (e.g. RGB565+alpha emits [RGB plane | alpha plane]
-    # per frame) so animation frame stepping in image.cpp / animation.cpp stays
-    # correct without needing to know the total frame count.
-    byte_order = config.get(CONF_BYTE_ORDER)
-    combined_data: list[int] = []
-    encoder: ImageEncoder | None = None
+    total_rows = height * frame_count
+    encoder = IMAGE_TYPE[type](width, total_rows, transparency, dither, invert_alpha)
+    if byte_order := config.get(CONF_BYTE_ORDER):
+        # Check for valid type has already been done in validate_settings
+        encoder.set_big_endian(byte_order == "BIG_ENDIAN")
     for frame_index in range(frame_count):
         image.seek(frame_index)
-        encoder = IMAGE_TYPE[type](width, height, transparency, dither, invert_alpha)
-        if byte_order is not None:
-            # Check for valid type has already been done in validate_settings
-            encoder.set_big_endian(byte_order == "BIG_ENDIAN")
         pixels = encoder.convert(image.resize((width, height)), path).getdata()
         for row in range(height):
             for col in range(width):
                 encoder.encode(pixels[row * width + col])
             encoder.end_row()
-        encoder.end_image()
-        combined_data.extend(encoder.data)
+    encoder.end_image()
 
-    rhs = [HexInt(x) for x in combined_data]
+    rhs = [HexInt(x) for x in encoder.data]
     prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
     image_type = get_image_type_enum(type)
     trans_value = get_transparency_enum(encoder.transparency)

esphome/components/infrared/__init__.py

@@ -12,7 +12,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.core import CORE, coroutine_with_priority
-from esphome.core.entity_helpers import queue_entity_register, setup_entity
+from esphome.core.entity_helpers import setup_entity
 from esphome.coroutine import CoroPriority
 from esphome.types import ConfigType
 
@@ -54,8 +54,8 @@ async def register_infrared(var: cg.Pvariable, config: ConfigType) -> None:
     """Register an infrared device with the core."""
     cg.add_define("USE_IR_RF")
     await cg.register_component(var, config)
-    queue_entity_register("infrared", config)
     await setup_infrared_core_(var, config)
+    cg.add(cg.App.register_infrared(var))
     CORE.register_platform_component("infrared", var)
 
 

esphome/components/inkbird_ibsth1_mini/inkbird_ibsth1_mini.cpp

@@ -41,12 +41,12 @@ bool InkbirdIbstH1Mini::parse_device(const esp32_ble_tracker::ESPBTDevice &devic
     ESP_LOGVV(TAG, "parse_device(): service_data is expected to be empty");
     return false;
   }
-  const auto &mnf_datas = device.get_manufacturer_datas();
+  auto mnf_datas = device.get_manufacturer_datas();
   if (mnf_datas.size() != 1) {
     ESP_LOGVV(TAG, "parse_device(): manufacturer_datas is expected to have a single element");
     return false;
   }
-  const auto &mnf_data = mnf_datas[0];
+  auto mnf_data = mnf_datas[0];
   if (mnf_data.uuid.get_uuid().len != ESP_UUID_LEN_16) {
     ESP_LOGVV(TAG, "parse_device(): manufacturer data element is expected to have uuid of length 16");
     return false;

esphome/components/ir_rf_proxy/ir_rf_proxy.cpp

@@ -1,73 +1,13 @@
 #include "ir_rf_proxy.h"
-
-#include <cinttypes>
-
 #include "esphome/core/log.h"
 
 namespace esphome::ir_rf_proxy {
 
 static const char *const TAG = "ir_rf_proxy";
 
-// ========== Shared transmit helper ==========
-// Static template: all instantiations occur in this translation unit.
-
-template<typename CallT>
-static void transmit_raw_timings(remote_base::RemoteTransmitterBase *transmitter, uint32_t carrier_frequency,
-                                 const CallT &call) {
-  if (transmitter == nullptr) {
-    ESP_LOGW(TAG, "No transmitter configured");
-    return;
-  }
-
-  if (!call.has_raw_timings()) {
-    ESP_LOGE(TAG, "No raw timings provided");
-    return;
-  }
-
-  auto transmit_call = transmitter->transmit();
-  auto *transmit_data = transmit_call.get_data();
-  transmit_data->set_carrier_frequency(carrier_frequency);
-
-  if (call.is_packed()) {
-    transmit_data->set_data_from_packed_sint32(call.get_packed_data(), call.get_packed_length(),
-                                               call.get_packed_count());
-    ESP_LOGD(TAG, "Transmitting packed raw timings: count=%" PRIu16 ", repeat=%" PRIu32, call.get_packed_count(),
-             call.get_repeat_count());
-  } else if (call.is_base64url()) {
-    if (!transmit_data->set_data_from_base64url(call.get_base64url_data())) {
-      ESP_LOGE(TAG, "Invalid base64url data");
-      return;
-    }
-    constexpr int32_t max_timing_us = 500000;
-    for (int32_t timing : transmit_data->get_data()) {
-      int32_t abs_timing = timing < 0 ? -timing : timing;
-      if (abs_timing > max_timing_us) {
-        ESP_LOGE(TAG, "Invalid timing value: %" PRId32 " µs (max %" PRId32 ")", timing, max_timing_us);
-        return;
-      }
-    }
-    ESP_LOGD(TAG, "Transmitting base64url raw timings: count=%zu, repeat=%" PRIu32, transmit_data->get_data().size(),
-             call.get_repeat_count());
-  } else {
-    transmit_data->set_data(call.get_raw_timings());
-    ESP_LOGD(TAG, "Transmitting raw timings: count=%zu, repeat=%" PRIu32, call.get_raw_timings().size(),
-             call.get_repeat_count());
-  }
-
-  if (call.get_repeat_count() > 0) {
-    transmit_call.set_send_times(call.get_repeat_count());
-  }
-
-  transmit_call.perform();
-}
-
-// ========== IrRfProxy (Infrared platform) ==========
-
-#ifdef USE_IR_RF
-
 void IrRfProxy::dump_config() {
   ESP_LOGCONFIG(TAG,
-                "IR Proxy '%s'\n"
+                "IR/RF Proxy '%s'\n"
                 "  Supports Transmitter: %s\n"
                 "  Supports Receiver: %s",
                 this->get_name().c_str(), YESNO(this->traits_.get_supports_transmitter()),
@@ -80,54 +20,4 @@ void IrRfProxy::dump_config() {
   }
 }
 
-void IrRfProxy::control(const infrared::InfraredCall &call) {
-  uint32_t carrier = call.get_carrier_frequency().value_or(0);
-  transmit_raw_timings(this->transmitter_, carrier, call);
-}
-
-#endif  // USE_IR_RF
-
-// ========== RfProxy (Radio Frequency platform) ==========
-
-#ifdef USE_RADIO_FREQUENCY
-
-void RfProxy::setup() {
-  this->traits_.set_supports_transmitter(this->transmitter_ != nullptr);
-  this->traits_.set_supports_receiver(this->receiver_ != nullptr);
-
-  // remote_transmitter/receiver always uses OOK (on-off keying)
-  this->traits_.add_supported_modulation(radio_frequency::RadioFrequencyModulation::RADIO_FREQUENCY_MODULATION_OOK);
-
-  if (this->receiver_ != nullptr) {
-    this->receiver_->register_listener(this);
-  }
-}
-
-void RfProxy::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "RF Proxy '%s'\n"
-                "  Backend: remote_transmitter/receiver\n"
-                "  Supports Transmitter: %s\n"
-                "  Supports Receiver: %s",
-                this->get_name().c_str(), YESNO(this->traits_.get_supports_transmitter()),
-                YESNO(this->traits_.get_supports_receiver()));
-
-  const auto &traits = this->traits_;
-  if (traits.get_frequency_min_hz() > 0) {
-    if (traits.get_frequency_min_hz() == traits.get_frequency_max_hz()) {
-      ESP_LOGCONFIG(TAG, "  Frequency: %.3f MHz (fixed)", traits.get_frequency_min_hz() / 1e6f);
-    } else {
-      ESP_LOGCONFIG(TAG, "  Frequency Range: %.3f - %.3f MHz", traits.get_frequency_min_hz() / 1e6f,
-                    traits.get_frequency_max_hz() / 1e6f);
-    }
-  }
-}
-
-void RfProxy::control(const radio_frequency::RadioFrequencyCall &call) {
-  // RF: no IR carrier modulation
-  transmit_raw_timings(this->transmitter_, 0, call);
-}
-
-#endif  // USE_RADIO_FREQUENCY
-
 }  // namespace esphome::ir_rf_proxy

esphome/components/ir_rf_proxy/ir_rf_proxy.h

@@ -4,19 +4,10 @@
 // without following the normal breaking changes policy. Use at your own risk.
 // Once the API is considered stable, this warning will be removed.
 
-#include "esphome/components/remote_base/remote_base.h"
-
-#ifdef USE_IR_RF
 #include "esphome/components/infrared/infrared.h"
-#endif
-
-#ifdef USE_RADIO_FREQUENCY
-#include "esphome/components/radio_frequency/radio_frequency.h"
-#endif
 
 namespace esphome::ir_rf_proxy {
 
-#ifdef USE_IR_RF
 /// IrRfProxy - Infrared platform implementation using remote_transmitter/receiver as backend
 class IrRfProxy : public infrared::Infrared {
  public:
@@ -35,36 +26,8 @@ class IrRfProxy : public infrared::Infrared {
   void set_receiver_frequency(uint32_t frequency_hz) { this->get_traits().set_receiver_frequency_hz(frequency_hz); }
 
  protected:
-  void control(const infrared::InfraredCall &call) override;
-
   // RF frequency in kHz (Hz / 1000); 0 = infrared, non-zero = RF
   uint32_t frequency_khz_{0};
 };
-#endif  // USE_IR_RF
-
-#ifdef USE_RADIO_FREQUENCY
-/// RfProxy - Radio Frequency platform implementation using remote_transmitter/receiver as backend
-class RfProxy : public radio_frequency::RadioFrequency {
- public:
-  RfProxy() = default;
-
-  void setup() override;
-  void dump_config() override;
-
-  /// Set the remote transmitter component
-  void set_transmitter(remote_base::RemoteTransmitterBase *transmitter) { this->transmitter_ = transmitter; }
-  /// Set the remote receiver component
-  void set_receiver(remote_base::RemoteReceiverBase *receiver) { this->receiver_ = receiver; }
-
-  /// Set the fixed carrier frequency in Hz (metadata: advertised via traits, does not tune hardware)
-  void set_frequency_hz(uint32_t freq_hz) { this->traits_.set_fixed_frequency_hz(freq_hz); }
-
- protected:
-  void control(const radio_frequency::RadioFrequencyCall &call) override;
-
-  remote_base::RemoteTransmitterBase *transmitter_{nullptr};
-  remote_base::RemoteReceiverBase *receiver_{nullptr};
-};
-#endif  // USE_RADIO_FREQUENCY
 
 }  // namespace esphome::ir_rf_proxy

esphome/components/ir_rf_proxy/radio_frequency.py

@@ -1,68 +0,0 @@
-"""Radio Frequency platform implementation using remote_base (remote_transmitter/receiver)."""
-
-import esphome.codegen as cg
-from esphome.components import radio_frequency, remote_receiver, remote_transmitter
-import esphome.config_validation as cv
-from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_FREQUENCY
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-from . import CONF_REMOTE_RECEIVER_ID, CONF_REMOTE_TRANSMITTER_ID, ir_rf_proxy_ns
-
-CODEOWNERS = ["@kbx81"]
-DEPENDENCIES = ["radio_frequency"]
-
-RfProxy = ir_rf_proxy_ns.class_("RfProxy", radio_frequency.RadioFrequency)
-
-CONFIG_SCHEMA = cv.All(
-    radio_frequency.radio_frequency_schema(RfProxy).extend(
-        {
-            cv.Optional(CONF_FREQUENCY): cv.frequency,
-            cv.Optional(CONF_REMOTE_RECEIVER_ID): cv.use_id(
-                remote_receiver.RemoteReceiverComponent
-            ),
-            cv.Optional(CONF_REMOTE_TRANSMITTER_ID): cv.use_id(
-                remote_transmitter.RemoteTransmitterComponent
-            ),
-        }
-    ),
-    cv.has_exactly_one_key(CONF_REMOTE_RECEIVER_ID, CONF_REMOTE_TRANSMITTER_ID),
-)
-
-
-def _final_validate(config: ConfigType) -> None:
-    """Validate that RF transmitters have carrier duty set to 100%."""
-    if CONF_REMOTE_TRANSMITTER_ID not in config:
-        return
-
-    transmitter_id = config[CONF_REMOTE_TRANSMITTER_ID]
-    full_config = fv.full_config.get()
-    transmitter_path = full_config.get_path_for_id(transmitter_id)[:-1]
-    transmitter_config = full_config.get_config_for_path(transmitter_path)
-
-    duty_percent = transmitter_config.get(CONF_CARRIER_DUTY_PERCENT)
-    if duty_percent is not None and duty_percent != 100:
-        raise cv.Invalid(
-            f"Transmitter '{transmitter_id}' must have '{CONF_CARRIER_DUTY_PERCENT}' "
-            "set to 100% for RF transmission. Dedicated RF hardware handles modulation; "
-            "applying a carrier duty cycle would corrupt the signal"
-        )
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
-async def to_code(config: ConfigType) -> None:
-    """Code generation for remote_base radio frequency platform."""
-    var = await radio_frequency.new_radio_frequency(config)
-
-    if CONF_FREQUENCY in config:
-        cg.add(var.set_frequency_hz(int(config[CONF_FREQUENCY])))
-
-    if CONF_REMOTE_TRANSMITTER_ID in config:
-        transmitter = await cg.get_variable(config[CONF_REMOTE_TRANSMITTER_ID])
-        cg.add(var.set_transmitter(transmitter))
-
-    if CONF_REMOTE_RECEIVER_ID in config:
-        receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
-        cg.add(var.set_receiver(receiver))

esphome/components/json/json_util.cpp

@@ -39,8 +39,7 @@ bool parse_json(const uint8_t *data, size_t len, const json_parse_t &f) {
 }
 
 JsonDocument parse_json(const uint8_t *data, size_t len) {
-  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks,clang-analyzer-core.StackAddressEscape) false positives with
-  // ArduinoJson
+  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   if (data == nullptr || len == 0) {
     ESP_LOGE(TAG, "No data to parse");
     return JsonObject();  // return unbound object
@@ -64,7 +63,7 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
   }
   ESP_LOGE(TAG, "Parse error: %s", err.c_str());
   return JsonObject();  // return unbound object
-  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks,clang-analyzer-core.StackAddressEscape)
+  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
 SerializationBuffer<> JsonBuilder::serialize() {

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};
-  size_t buffer_len = 0;
+  int buffer_len = 0;
   int data;
   int timeout = 250;  // ms
 
   // Read the data from the UART
-  while (timeout > 0 && buffer_len < sizeof(buffer)) {
+  while (timeout > 0 && buffer_len < static_cast<int>(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 (size_t i = 1; i < buffer_len - 1; i++) {
+  for (int i = 1; i < buffer_len - 1; i++) {
     if (buffer[i] == 0x1B) {
       msg[msg_len++] = buffer[i + 1] ^ 0xFF;
       i++;

esphome/components/libretiny/const.py

@@ -58,7 +58,6 @@ COMPONENT_RTL87XX = "rtl87xx"
 FAMILY_BK7231N = "BK7231N"
 FAMILY_BK7231Q = "BK7231Q"
 FAMILY_BK7231T = "BK7231T"
-FAMILY_BK7238 = "BK7238"
 FAMILY_BK7251 = "BK7251"
 FAMILY_LN882H = "LN882H"
 FAMILY_RTL8710B = "RTL8710B"
@@ -67,7 +66,6 @@ FAMILIES = [
     FAMILY_BK7231N,
     FAMILY_BK7231Q,
     FAMILY_BK7231T,
-    FAMILY_BK7238,
     FAMILY_BK7251,
     FAMILY_LN882H,
     FAMILY_RTL8710B,
@@ -77,7 +75,6 @@ FAMILY_FRIENDLY = {
     FAMILY_BK7231N: "BK7231N",
     FAMILY_BK7231Q: "BK7231Q",
     FAMILY_BK7231T: "BK7231T",
-    FAMILY_BK7238: "BK7238",
     FAMILY_BK7251: "BK7251",
     FAMILY_LN882H: "LN882H",
     FAMILY_RTL8710B: "RTL8710B",
@@ -87,7 +84,6 @@ FAMILY_COMPONENT = {
     FAMILY_BK7231N: COMPONENT_BK72XX,
     FAMILY_BK7231Q: COMPONENT_BK72XX,
     FAMILY_BK7231T: COMPONENT_BK72XX,
-    FAMILY_BK7238: COMPONENT_BK72XX,
     FAMILY_BK7251: COMPONENT_BK72XX,
     FAMILY_LN882H: COMPONENT_LN882X,
     FAMILY_RTL8710B: COMPONENT_RTL87XX,

esphome/components/libretiny/core.cpp

@@ -3,6 +3,7 @@
 #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"
 
@@ -14,7 +15,32 @@ void loop();
 
 namespace esphome {
 
-// yield(), delay(), micros(), millis(), millis_64() inlined in hal.h.
+void HOT yield() { ::yield(); }
+// Inline the tick read so esphome::millis() matches MillisInternal::get()'s fast
+// path instead of going through the Arduino core's out-of-line ::millis() wrapper.
+//
+// RTL87xx / LN882x (1 kHz): xTaskGetTickCount() is already ms. IRAM_ATTR + ISR
+// dispatch are needed because ISR handlers (e.g. rotary_encoder) call millis().
+//
+// BK72xx (500 Hz): ticks * portTICK_PERIOD_MS (== 2). IRAM_ATTR and ISR dispatch
+// are both unnecessary — the SDK masks FIQ + IRQ during flash writes (see hal.h),
+// so no ISR runs while flash is stalled.
+#if defined(USE_RTL87XX) || defined(USE_LN882X)
+uint32_t IRAM_ATTR HOT millis() {
+  static_assert(configTICK_RATE_HZ == 1000, "millis() fast path requires 1 kHz FreeRTOS tick");
+  return in_isr_context() ? xTaskGetTickCountFromISR() : xTaskGetTickCount();
+}
+#elif defined(USE_BK72XX)
+uint32_t HOT millis() {
+  static_assert(configTICK_RATE_HZ == 500, "BK72xx millis() fast path assumes 500 Hz FreeRTOS tick");
+  return xTaskGetTickCount() * portTICK_PERIOD_MS;
+}
+#else
+uint32_t IRAM_ATTR HOT millis() { return ::millis(); }
+#endif
+uint64_t millis_64() { return Millis64Impl::compute(millis()); }
+uint32_t IRAM_ATTR HOT micros() { return ::micros(); }
+void HOT delay(uint32_t ms) { ::delay(ms); }
 void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { ::delayMicroseconds(us); }
 
 void arch_init() {

esphome/components/light/__init__.py

@@ -40,11 +40,7 @@ from esphome.const import (
     CONF_WHITE,
 )
 from esphome.core import CORE, ID, CoroPriority, HexInt, Lambda, coroutine_with_priority
-from esphome.core.entity_helpers import (
-    entity_duplicate_validator,
-    queue_entity_register,
-    setup_entity,
-)
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 import esphome.final_validate as fv
 from esphome.types import ConfigType
@@ -409,7 +405,7 @@ async def setup_light_core_(light_var, config, output_var):
 
 async def register_light(output_var, config):
     light_var = cg.new_Pvariable(config[CONF_ID], output_var)
-    queue_entity_register("light", config)
+    cg.add(cg.App.register_light(light_var))
     CORE.register_platform_component("light", light_var)
     await cg.register_component(light_var, config)
     await setup_light_core_(light_var, config, output_var)

esphome/components/light/automation.h

@@ -8,59 +8,84 @@ namespace esphome::light {
 
 enum class LimitMode { CLAMP, DO_NOTHING };
 
-template<bool HasTransitionLength, typename... Ts> class ToggleAction : public Action<Ts...> {
+template<typename... Ts> class ToggleAction : public Action<Ts...> {
  public:
   explicit ToggleAction(LightState *state) : state_(state) {}
 
-  template<typename V> void set_transition_length(V value) requires(HasTransitionLength) {
-    this->transition_length_ = value;
-  }
+  TEMPLATABLE_VALUE(uint32_t, transition_length)
 
   void play(const Ts &...x) override {
     auto call = this->state_->toggle();
-    if constexpr (HasTransitionLength) {
-      call.set_transition_length(this->transition_length_.optional_value(x...));
-    }
+    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:
-  using ApplyFn = void (*)(LightState *, LightCall &, const Ts &...);
-  LightControlAction(LightState *parent, ApplyFn apply) : parent_(parent), apply_(apply) {}
+  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)
 
   void play(const Ts &...x) override {
     auto call = this->parent_->make_call();
-    this->apply_(this->parent_, call, x...);
+    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...));
     call.perform();
   }
 
  protected:
   LightState *parent_;
-  ApplyFn apply_;
 };
 
-template<bool HasTransitionLength, typename... Ts> class DimRelativeAction : public Action<Ts...> {
+template<typename... Ts> class DimRelativeAction : public Action<Ts...> {
  public:
   explicit DimRelativeAction(LightState *parent) : parent_(parent) {}
 
   TEMPLATABLE_VALUE(float, relative_brightness)
-
-  template<typename V> void set_transition_length(V value) requires(HasTransitionLength) {
-    this->transition_length_ = value;
-  }
+  TEMPLATABLE_VALUE(uint32_t, transition_length)
 
   void play(const Ts &...x) override {
     auto call = this->parent_->make_call();
@@ -74,9 +99,7 @@ template<bool HasTransitionLength, typename... Ts> class DimRelativeAction : pub
     call.set_state(new_brightness != 0.0f);
     call.set_brightness(new_brightness);
 
-    if constexpr (HasTransitionLength) {
-      call.set_transition_length(this->transition_length_.optional_value(x...));
-    }
+    call.set_transition_length(this->transition_length_.optional_value(x...));
     call.perform();
   }
 
@@ -92,9 +115,6 @@ template<bool HasTransitionLength, typename... Ts> class DimRelativeAction : pub
   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,7 +37,6 @@ from .types import (
     AddressableSet,
     ColorMode,
     DimRelativeAction,
-    LightCall,
     LightControlAction,
     LightIsOffCondition,
     LightIsOnCondition,
@@ -61,10 +60,8 @@ from .types import (
 )
 async def light_toggle_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    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:
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    if CONF_TRANSITION_LENGTH in config:
         template_ = await cg.templatable(
             config[CONF_TRANSITION_LENGTH], args, cg.uint32
         )
@@ -181,9 +178,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)
 
-    # All configured fields are folded into a single stateless lambda whose
-    # constants live in flash; the action stores only a function pointer.
+    # (config_key, setter_name, c++ type)
     FIELDS = (
         (CONF_COLOR_MODE, "set_color_mode", ColorMode),
         (CONF_STATE, "set_state", cg.bool_),
@@ -199,50 +196,38 @@ 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 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_key in config:
+            template_ = await cg.templatable(config[conf_key], args, type_)
+            cg.add(getattr(var, setter)(template_))
 
     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
             )
-            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())); }}"
+            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,
             )
+            cg.add(var.set_effect(wrapper))
         else:
-            # 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)}));"
+            # Static string — resolve effect name to index at codegen time
+            template_ = await cg.templatable(
+                _resolve_effect_index(config), args, cg.uint32
             )
-
-    # 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)
+            cg.add(var.set_effect(template_))
+    return var
 
 
 CONF_RELATIVE_BRIGHTNESS = "relative_brightness"
@@ -276,12 +261,10 @@ 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])
-    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)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
     templ = await cg.templatable(config[CONF_RELATIVE_BRIGHTNESS], args, cg.float_)
     cg.add(var.set_relative_brightness(templ))
-    if has_transition_length:
+    if CONF_TRANSITION_LENGTH in config:
         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,7 +13,6 @@ 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/lock/__init__.py

@@ -13,11 +13,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.core.entity_helpers import (
-    entity_duplicate_validator,
-    queue_entity_register,
-    setup_entity,
-)
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@esphome/core"]
@@ -116,7 +112,7 @@ async def _setup_lock_core(var, config):
 async def register_lock(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    queue_entity_register("lock", config)
+    cg.add(cg.App.register_lock(var))
     CORE.register_platform_component("lock", var)
     await _setup_lock_core(var, config)
 

esphome/components/lvgl/binary_sensor/__init__.py

@@ -4,25 +4,15 @@ from esphome.components.binary_sensor import (
     new_binary_sensor,
 )
 import esphome.config_validation as cv
-from esphome.const import CONF_STATE
 
-from ..defines import CONF_WIDGET, LV_OBJ_FLAG, LvConstant
-from ..lvcode import EVENT_ARG, UPDATE_EVENT, LambdaContext, LvContext, lvgl_static
-from ..types import LV_EVENT, LV_STATE, lv_pseudo_button_t
+from ..defines import CONF_WIDGET
+from ..lvcode import EVENT_ARG, LambdaContext, LvContext, lvgl_static
+from ..types import LV_EVENT, lv_pseudo_button_t
 from ..widgets import Widget, get_widgets, wait_for_widgets
 
-STATE_PRESSED = "PRESSED"
-STATE_CHECKED = "CHECKED"
-
-BS_STATE = LvConstant(
-    "LV_STATE_",
-    STATE_PRESSED,
-    STATE_CHECKED,
-)
 CONFIG_SCHEMA = binary_sensor_schema(BinarySensor).extend(
     {
         cv.Required(CONF_WIDGET): cv.use_id(lv_pseudo_button_t),
-        cv.Optional(CONF_STATE, default=STATE_PRESSED): BS_STATE.one_of,
     }
 )
 
@@ -32,23 +22,16 @@ async def to_code(config):
     widget = await get_widgets(config, CONF_WIDGET)
     widget = widget[0]
     assert isinstance(widget, Widget)
-    state = await BS_STATE.process(config[CONF_STATE])
     await wait_for_widgets()
-    is_pressed = str(state) == str(LV_STATE.PRESSED)
-    test_expr = widget.is_pressed() if is_pressed else widget.is_checked()
-    async with LambdaContext(EVENT_ARG) as test_ctx:
-        test_ctx.add(sensor.publish_state(test_expr))
+    async with LambdaContext(EVENT_ARG) as pressed_ctx:
+        pressed_ctx.add(sensor.publish_state(widget.is_pressed()))
     async with LvContext() as ctx:
-        ctx.add(sensor.publish_initial_state(test_expr))
-        if is_pressed:
-            events = [LV_EVENT.PRESSED, LV_EVENT.RELEASED]
-            widget.add_flag(LV_OBJ_FLAG.CLICKABLE)
-        else:
-            events = [LV_EVENT.VALUE_CHANGED, UPDATE_EVENT]
+        ctx.add(sensor.publish_initial_state(widget.is_pressed()))
         ctx.add(
             lvgl_static.add_event_cb(
                 widget.obj,
-                await test_ctx.get_lambda(),
-                *events,
+                await pressed_ctx.get_lambda(),
+                LV_EVENT.PRESSED,
+                LV_EVENT.RELEASED,
             )
         )

esphome/components/lvgl/gradient.py

@@ -1,5 +1,3 @@
-from operator import itemgetter
-
 from esphome import config_validation as cv
 import esphome.codegen as cg
 from esphome.const import (
@@ -13,7 +11,6 @@ from esphome.core import ID
 from esphome.cpp_generator import MockObj
 
 from .defines import CONF_GRADIENTS, CONF_OPA, LV_DITHER, add_define, add_warning
-from .helpers import add_lv_use
 from .lv_validation import lv_color, lv_percentage, opacity
 from .lvcode import lv
 from .types import lv_color_t, lv_gradient_t, lv_opa_t
@@ -53,7 +50,6 @@ GRADIENT_SCHEMA = cv.ensure_list(
 
 
 async def gradients_to_code(config):
-    add_lv_use("gradient")
     max_stops = 2
     if any(CONF_DITHER in x for x in config.get(CONF_GRADIENTS, ())):
         add_warning(
@@ -62,7 +58,7 @@ async def gradients_to_code(config):
     for gradient in config.get(CONF_GRADIENTS, ()):
         var = MockObj(cg.new_Pvariable(gradient[CONF_ID]), "->")
         idbase = gradient[CONF_ID].id
-        stops = sorted(gradient[CONF_STOPS], key=itemgetter(CONF_POSITION))
+        stops = gradient[CONF_STOPS]
         max_stops = max(max_stops, len(stops))
         if gradient[CONF_DIRECTION].startswith("VER"):
             lv.grad_vertical_init(var)

esphome/components/lvgl/layout.py

@@ -1,4 +1,3 @@
-import math
 import re
 import textwrap
 
@@ -86,22 +85,6 @@ def grid_free_space(value):
 
 grid_spec = cv.Any(size, LvConstant("LV_GRID_", "CONTENT").one_of, grid_free_space)
 
-
-def grid_dimension(value):
-    """
-    Validator for a grid `rows` or `columns` value.
-    Accepts either a positive integer (interpreted as that many cells of equal
-    `LV_GRID_FR(1)` size) or a non-empty list of grid specs.
-    """
-    if isinstance(value, int):
-        value = cv.int_range(min=1)(value)
-        return ["LV_GRID_FR(1)"] * value
-    result = cv.Schema([grid_spec])(value)
-    if not result:
-        raise cv.Invalid("Grid dimension list must contain at least one entry")
-    return result
-
-
 GRID_CELL_SCHEMA = {
     cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
     cv.Optional(CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
@@ -201,16 +184,7 @@ class DirectionalLayout(FlexLayout):
 
 
 class GridLayout(Layout):
-    # Match shorthand grid layout strings: "NxM", "Nx" or "xM".
-    # At least one of the two numbers must be present; this is enforced after matching.
-    _GRID_LAYOUT_REGEX = re.compile(r"^\s*(\d+)?\s*x\s*(\d+)?\s*$")
-
-    @staticmethod
-    def _match_shorthand(layout):
-        match = GridLayout._GRID_LAYOUT_REGEX.match(layout)
-        if match is None or (match.group(1) is None and match.group(2) is None):
-            return None
-        return match
+    _GRID_LAYOUT_REGEX = re.compile(r"^\s*(\d+)\s*x\s*(\d+)\s*$")
 
     def get_type(self):
         return TYPE_GRID
@@ -218,7 +192,7 @@ class GridLayout(Layout):
     def get_layout_schemas(self, config: dict) -> tuple:
         layout = config.get(CONF_LAYOUT)
         if isinstance(layout, str):
-            if GridLayout._match_shorthand(layout):
+            if GridLayout._GRID_LAYOUT_REGEX.match(layout):
                 return (
                     cv.string,
                     {
@@ -239,107 +213,59 @@ class GridLayout(Layout):
 
         if not isinstance(layout, dict) or layout.get(CONF_TYPE).lower() != TYPE_GRID:
             return None, {}
-        x_default = (
-            "center" if isinstance(layout.get(CONF_GRID_ROWS), int) else cv.UNDEFINED
-        )
-        y_default = (
-            "center" if isinstance(layout.get(CONF_GRID_COLUMNS), int) else cv.UNDEFINED
-        )
-        x_align = layout.get(CONF_GRID_CELL_X_ALIGN, x_default)
-        y_align = layout.get(CONF_GRID_CELL_Y_ALIGN, y_default)
         return (
             {
                 cv.Required(CONF_TYPE): cv.one_of(TYPE_GRID, lower=True),
-                cv.Optional(CONF_GRID_ROWS): grid_dimension,
-                cv.Optional(CONF_GRID_COLUMNS): grid_dimension,
+                cv.Required(CONF_GRID_ROWS): [grid_spec],
+                cv.Required(CONF_GRID_COLUMNS): [grid_spec],
                 cv.Optional(CONF_GRID_COLUMN_ALIGN): grid_alignments,
                 cv.Optional(CONF_GRID_ROW_ALIGN): grid_alignments,
                 cv.Optional(CONF_PAD_ROW): padding,
                 cv.Optional(CONF_PAD_COLUMN): padding,
                 cv.Optional(CONF_MULTIPLE_WIDGETS_PER_CELL, default=False): cv.boolean,
-                cv.Optional(CONF_GRID_CELL_X_ALIGN): grid_alignments,
-                cv.Optional(CONF_GRID_CELL_Y_ALIGN): grid_alignments,
             },
             {
                 cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
                 cv.Optional(CONF_GRID_CELL_COLUMN_POS): cv.positive_int,
                 cv.Optional(CONF_GRID_CELL_ROW_SPAN): cv.int_range(min=1),
                 cv.Optional(CONF_GRID_CELL_COLUMN_SPAN): cv.int_range(min=1),
-                cv.Optional(CONF_GRID_CELL_X_ALIGN, default=x_align): grid_alignments,
-                cv.Optional(CONF_GRID_CELL_Y_ALIGN, default=y_align): grid_alignments,
+                cv.Optional(CONF_GRID_CELL_X_ALIGN): grid_alignments,
+                cv.Optional(CONF_GRID_CELL_Y_ALIGN): grid_alignments,
             },
         )
 
     def validate(self, config: dict):
         """
         Validate the grid layout.
-        The `layout:` key may be a dictionary with `rows` and/or `columns` keys, or a
-        shorthand string in the format "<rows>x<columns>", "<rows>x" or "x<columns>".
-        Either dimension may be omitted, in which case it will be calculated from the
-        other dimension and the number of configured widgets.
+        The `layout:` key may be a dictionary with `rows` and `columns` keys, or a string in the format "rows x columns".
         Either all cells must have a row and column,
         or none, in which case the grid layout is auto-generated.
         :param config:
         :return: The config updated with auto-generated values
         """
         layout = config.get(CONF_LAYOUT)
-        widgets = config.get(CONF_WIDGETS, [])
-        num_widgets = len(widgets)
         if isinstance(layout, str):
-            # Shorthand string: "<rows>x<columns>", "<rows>x" or "x<columns>".
-            # Each dimension defaults to LV_GRID_FR(1). A missing dimension is
-            # calculated from the other dimension and the number of widgets.
+            # If the layout is a string, assume it is in the format "rows x columns", implying
+            # a grid layout with the specified number of rows and columns each with CONTENT sizing.
             layout = layout.strip()
-            match = GridLayout._match_shorthand(layout)
-            if not match:
+            match = GridLayout._GRID_LAYOUT_REGEX.match(layout)
+            if match:
+                rows = int(match.group(1))
+                cols = int(match.group(2))
+                layout = {
+                    CONF_TYPE: TYPE_GRID,
+                    CONF_GRID_ROWS: ["LV_GRID_FR(1)"] * rows,
+                    CONF_GRID_COLUMNS: ["LV_GRID_FR(1)"] * cols,
+                }
+                config[CONF_LAYOUT] = layout
+            else:
                 raise cv.Invalid(
-                    f"Invalid grid layout format: {layout!r}, expected "
-                    "'<rows>x<columns>', '<rows>x' or 'x<columns>'",
+                    f"Invalid grid layout format: {config}, expected 'rows x columns'",
                     [CONF_LAYOUT],
                 )
-            rows_int = int(match.group(1)) if match.group(1) is not None else None
-            cols_int = int(match.group(2)) if match.group(2) is not None else None
-            for label, val in (("row", rows_int), ("column", cols_int)):
-                if val is not None and val < 1:
-                    raise cv.Invalid(
-                        f"Invalid grid layout {layout!r}: {label} count must be "
-                        "at least 1",
-                        [CONF_LAYOUT],
-                    )
-            if rows_int is not None and cols_int is not None:
-                rows = rows_int
-                cols = cols_int
-            elif rows_int is not None:
-                rows = rows_int
-                cols = max(1, math.ceil(num_widgets / rows)) if num_widgets else 1
-            else:
-                cols = cols_int
-                rows = max(1, math.ceil(num_widgets / cols)) if num_widgets else 1
-            layout = {
-                CONF_TYPE: TYPE_GRID,
-                CONF_GRID_ROWS: ["LV_GRID_FR(1)"] * rows,
-                CONF_GRID_COLUMNS: ["LV_GRID_FR(1)"] * cols,
-            }
-            config[CONF_LAYOUT] = layout
         # should be guaranteed to be a dict at this point
         assert isinstance(layout, dict)
         assert layout.get(CONF_TYPE).lower() == TYPE_GRID
-        rows_list = layout.get(CONF_GRID_ROWS)
-        cols_list = layout.get(CONF_GRID_COLUMNS)
-        if rows_list is None and cols_list is None:
-            raise cv.Invalid(
-                "Grid layout requires at least one of 'rows' or 'columns' to be "
-                "specified",
-                [CONF_LAYOUT],
-            )
-        if rows_list is None:
-            cols = len(cols_list)
-            rows = max(1, math.ceil(num_widgets / cols)) if num_widgets else 1
-            layout[CONF_GRID_ROWS] = ["LV_GRID_FR(1)"] * rows
-        elif cols_list is None:
-            rows = len(rows_list)
-            cols = max(1, math.ceil(num_widgets / rows)) if num_widgets else 1
-            layout[CONF_GRID_COLUMNS] = ["LV_GRID_FR(1)"] * cols
         allow_multiple = layout.get(CONF_MULTIPLE_WIDGETS_PER_CELL, False)
         rows = len(layout[CONF_GRID_ROWS])
         columns = len(layout[CONF_GRID_COLUMNS])
@@ -453,8 +379,7 @@ def append_layout_schema(schema, config: dict):
         textwrap.dedent(
             """
                 Invalid 'layout' value
-                layout choices are 'horizontal', 'vertical',
-                '<rows>x<cols>', '<rows>x', 'x<cols>',
+                layout choices are 'horizontal', 'vertical', '<rows>x<cols>',
                 or a dictionary with a 'type' key
             """
         ),