Clear the scan-end skip on every promotion

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.12.4
+RUN uv pip install --no-cache-dir esphome-device-builder==1.12.3
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/__main__.py

@@ -762,11 +762,9 @@ def _wrap_to_code(name, comp, yaml_util):
     async def wrapped(conf):
         cg.add(cg.LineComment(f"{name}:"))
         if comp.config_schema is not None:
-            # sort_keys: voluptuous fills defaults in set order, so an
-            # unsorted dump would churn main.cpp and relink every run
-            conf_str = yaml_util.dump(conf, sort_keys=True)
+            conf_str = yaml_util.dump(conf)
             conf_str = conf_str.replace("//", "")
-            # remove trailing \ to avoid multi-line comment warning
+            # remove tailing \ to avoid multi-line comment warning
             conf_str = conf_str.replace("\\\n", "\n")
             cg.add(cg.LineComment(indent(conf_str)))
         await coro(conf)
@@ -857,20 +855,7 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
         toolchain.create_factory_bin()
         toolchain.create_ota_bin()
         toolchain.create_elf_copy()
-        from esphome.build_helpers.idedata import IDEDATA_BEST_EFFORT_ERRORS
-
-        try:
-            if toolchain.get_idedata() is None:
-                _LOGGER.warning("No idedata was generated for this build")
-        except IDEDATA_BEST_EFFORT_ERRORS as err:
-            # The firmware already built; an idedata failure must not fail
-            # a successful build.
-            _LOGGER.warning(
-                "Could not generate idedata: %s (IDE, clang-tidy, and "
-                "memory-analysis data will be unavailable for this build)",
-                err,
-            )
-            _LOGGER.debug("Idedata failure detail", exc_info=True)
+        toolchain.get_idedata()
     else:
         from esphome.platformio import toolchain
 

esphome/build_helpers/__init__.py

@@ -1 +0,0 @@
-"""Build helpers shared by the native (non-PlatformIO) toolchains."""

esphome/build_helpers/size_summary.py

@@ -1,24 +0,0 @@
-"""The PlatformIO-format size bar shared by the native toolchains."""
-
-from __future__ import annotations
-
-
-def format_bar(used: int, total: int) -> str:
-    """Match PlatformIO's ``_format_availale_bytes`` (sic, pioupload.py) exactly."""
-    pct_raw = used / total if total else 0
-    blocks = 10
-    filled = min(int(round(blocks * pct_raw)), blocks)
-    progress = "=" * filled
-    return (
-        f"[{progress:<{blocks}}] {pct_raw: 6.1%} "
-        f"(used {used:d} bytes from {total:d} bytes)"
-    )
-
-
-def print_size_line(label: str, used: int, total: int) -> None:
-    """One PlatformIO-format summary line (``RAM``/``Flash``).
-
-    The label padding is part of the format: ``script/ci_memory_impact_extract.py``
-    matches these lines verbatim.
-    """
-    print(f"{label + ':':<7}{format_bar(used, total)}")

esphome/components/adc/__init__.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components.esp32 import (
@@ -18,7 +16,6 @@ from esphome.components.esp32 import (
 import esphome.config_validation as cv
 from esphome.const import CONF_ANALOG, CONF_INPUT, CONF_NUMBER, PLATFORM_ESP8266
 from esphome.core import CORE
-from esphome.types import ConfigType
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -228,7 +225,7 @@ ESP32_VARIANT_ADC2_PIN_TO_CHANNEL = {
 }
 
 
-def validate_adc_pin(value: Any) -> ConfigType | str:
+def validate_adc_pin(value):
     if str(value).upper() == "VCC":
         if CORE.is_rp2:
             return pins.internal_gpio_input_pin_schema(29)

esphome/components/adc/sensor.py

@@ -52,7 +52,7 @@ _attenuation = cv.enum(ATTENUATION_MODES, lower=True)
 _sampling_mode = cv.enum(SAMPLING_MODES, lower=True)
 
 
-def validate_config(config: ConfigType) -> ConfigType:
+def validate_config(config):
     if config[CONF_RAW] and config.get(CONF_ATTENUATION, None) == "auto":
         raise cv.Invalid("Automatic attenuation cannot be used when raw output is set")
 
@@ -120,7 +120,7 @@ CONFIG_SCHEMA = cv.All(
 CONF_ADC_CHANNEL_ID = "adc_channel_id"
 
 
-def _overlay_io_channels() -> str:
+def _overlay_io_channels():
     channel_count = CORE.data[CONF_ADC_CHANNEL_ID]
     entries = ", ".join(f"<&adc {channel_id}>" for channel_id in range(channel_count))
     return f"""
@@ -132,7 +132,7 @@ def _overlay_io_channels() -> str:
             """
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await sensor.register_sensor(var, config)

esphome/components/api/__init__.py

@@ -1,6 +1,5 @@
 import base64
 import logging
-from typing import Any
 
 from esphome import automation
 from esphome.automation import Condition
@@ -130,7 +129,7 @@ def _register_provisioning_source(config: ConfigType) -> ConfigType:
     return config
 
 
-def validate_encryption_key(value: Any) -> str:
+def validate_encryption_key(value):
     value = cv.string_strict(value)
     try:
         decoded = base64.b64decode(value, validate=True)
@@ -218,7 +217,7 @@ def _auto_detect_supports_response(config: ConfigType) -> ConfigType:
     return config
 
 
-def _validate_supports_response(value: Any) -> str:
+def _validate_supports_response(value):
     """Validate supports_response after auto-detection has set the value."""
     return cv.enum(SUPPORTS_RESPONSE_OPTIONS, lower=True)(value)
 
@@ -257,7 +256,7 @@ ENCRYPTION_SCHEMA = cv.Schema(
 )
 
 
-def _encryption_schema(config: ConfigType | None) -> ConfigType:
+def _encryption_schema(config):
     if config is None:
         config = {}
     return ENCRYPTION_SCHEMA(config)
@@ -394,7 +393,7 @@ async def to_code(config: ConfigType) -> None:
 
     if actions := config.get(CONF_ACTIONS, []):
         # Collect all triggers first, then register all at once with initializer_list
-        triggers: list[cg.MockObj] = []
+        triggers: list[cg.Pvariable] = []
         for conf in actions:
             func_args: list[tuple[MockObj, str]] = []
             service_template_args: list[MockObj] = []  # User service argument types
@@ -582,7 +581,7 @@ async def homeassistant_service_to_code(
     action_id: ID,
     template_arg: cg.TemplateArguments,
     args: TemplateArgsType,
-) -> MockObj:
+):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, False)
@@ -648,7 +647,7 @@ async def homeassistant_service_to_code(
     return var
 
 
-def validate_homeassistant_event(value: Any) -> str:
+def validate_homeassistant_event(value):
     value = cv.string(value)
     if not value.startswith("esphome."):
         raise cv.Invalid(
@@ -677,12 +676,7 @@ HOMEASSISTANT_EVENT_ACTION_SCHEMA = cv.Schema(
     HOMEASSISTANT_EVENT_ACTION_SCHEMA,
     synchronous=True,
 )
-async def homeassistant_event_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def homeassistant_event_to_code(config, action_id, template_arg, args):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
@@ -730,12 +724,7 @@ HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value(
     HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA,
     synchronous=True,
 )
-async def homeassistant_tag_scanned_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def homeassistant_tag_scanned_to_code(config, action_id, template_arg, args):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
@@ -751,7 +740,7 @@ CONF_SUCCESS = "success"
 CONF_ERROR_MESSAGE = "error_message"
 
 
-def _validate_api_respond_data(config: ConfigType) -> ConfigType:
+def _validate_api_respond_data(config):
     """Set flag during validation so AUTO_LOAD can include json component."""
     if CONF_DATA in config:
         CORE.data.setdefault(DOMAIN, {})[CONF_CAPTURE_RESPONSE] = True
@@ -835,12 +824,7 @@ API_CONNECTED_CONDITION_SCHEMA = cv.Schema(
 @automation.register_condition(
     "api.connected", APIConnectedCondition, API_CONNECTED_CONDITION_SCHEMA
 )
-async def api_connected_to_code(
-    config: ConfigType,
-    condition_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def api_connected_to_code(config, condition_id, template_arg, args):
     var = cg.new_Pvariable(condition_id, template_arg)
     templ = await cg.templatable(config[CONF_STATE_SUBSCRIPTION_ONLY], args, cg.bool_)
     cg.add(var.set_state_subscription_only(templ))

esphome/components/api/api_server.cpp

@@ -423,6 +423,12 @@ void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_
 API_DISPATCH_UPDATE(alarm_control_panel::AlarmControlPanel, alarm_control_panel)
 #endif
 
+float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
+
+void APIServer::set_port(uint16_t port) { this->port_ = port; }
+
+void APIServer::set_batch_delay(uint16_t batch_delay) { this->batch_delay_ = batch_delay; }
+
 #ifdef USE_API_HOMEASSISTANT_SERVICES
 void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call) {
   bool has_subscriber = false;
@@ -547,6 +553,10 @@ const std::vector<APIServer::HomeAssistantStateSubscription> &APIServer::get_sta
 }
 #endif
 
+uint16_t APIServer::get_port() const { return this->port_; }
+
+void APIServer::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
+
 #ifdef USE_API_NOISE
 bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg,
                                   const LogString *fail_log_msg, bool make_active) {

esphome/components/api/api_server.h

@@ -51,8 +51,8 @@ class APIServer final : public Component,
  public:
   APIServer();
   void setup() override;
-  uint16_t get_port() const { return this->port_; }
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  uint16_t get_port() const;
+  float get_setup_priority() const override;
   void loop() override;
   void dump_config() override;
   void on_shutdown() override;
@@ -63,9 +63,9 @@ class APIServer final : public Component,
 #ifdef USE_CAMERA
   void on_camera_image(const std::shared_ptr<camera::CameraImage> &image) override;
 #endif
-  void set_port(uint16_t port) { this->port_ = port; }
-  void set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
-  void set_batch_delay(uint16_t batch_delay) { this->batch_delay_ = batch_delay; }
+  void set_port(uint16_t port);
+  void set_reboot_timeout(uint32_t reboot_timeout);
+  void set_batch_delay(uint16_t batch_delay);
   uint16_t get_batch_delay() const { return batch_delay_; }
   void set_listen_backlog(uint8_t listen_backlog) { this->listen_backlog_ = listen_backlog; }
 

esphome/components/bk72xx_ble/__init__.py

@@ -4,12 +4,9 @@ The platform analog of esp32_ble / rp2040_ble: owns the Beken BDK BLE stack
 bring-up and the controller BLE address. Consumers (bk72xx_ble_tracker) build
 on this component and contain no SDK calls of their own.
 
-Supported SoCs (BLE 5.x): BK7231N/BK7236 (BLE 5.1), BK7252N/BK7253 (BLE 5.2),
-and any future BLE-5.x SoC. BK7238 (BLE 5.2) is blocked for now: with BLE
-compiled in, the Beken SDK erases the bootloader flash sector at boot because
-LibreTiny's partition table has no BLE bonding entry (esphome#18646,
-libretiny-eu/libretiny#408). Known non-5.x families and BK7238 are rejected in
-to_code. Unknown families are capability-checked at compile time via
+Supported SoCs (BLE 5.x): BK7231N/BK7236 (BLE 5.1), BK7238/BK7252N/BK7253
+(BLE 5.2), and any future BLE-5.x SoC. Known non-5.x families are rejected in
+to_code; unknown families are capability-checked at compile time via
 `__has_include("app_ble.h")`, a header only on the BLE 5.x include path
 (ble_api.h ships for every SoC, so it cannot be the probe). A non-5.x build
 fails with a clear #error.
@@ -68,14 +65,6 @@ def _unsupported_family_message(family: str) -> str | None:
         )
     if family == FAMILY_BK7231Q:
         return "bk72xx_ble does not support BK7231Q: this SoC has no BLE"
-    if family == FAMILY_BK7238:
-        return (
-            "bk72xx_ble is disabled on BK7238: with BLE compiled in, the Beken SDK "
-            "erases the bootloader flash sector at boot and the device can no longer "
-            "start (see https://github.com/esphome/esphome/issues/18646); support "
-            "returns once the LibreTiny partition table fix "
-            "(libretiny-eu/libretiny#408) is released"
-        )
     return None
 
 
@@ -124,7 +113,18 @@ async def to_code(config: ConfigType) -> None:
     # BK7231N, but NOT on BK7238 (its BLE stack has no such symbol; the address is
     # derived from the WiFi MAC instead — the BDK's own fallback). Tell the C++
     # which path is available so it doesn't reference a missing symbol.
-    if libretiny.get_libretiny_family() == FAMILY_BK7231N:
+    family = libretiny.get_libretiny_family()
+    if family == FAMILY_BK7231N:
         cg.add_define("BK72XX_BLE_HAS_COMMON_BDADDR")
+    elif family == FAMILY_BK7238:
+        # ESPHome's LibreTiny disables BLE on BK7238 because the SDK can hang at
+        # WiFi STA startup when BLE init runs. This component re-enables BLE, so
+        # warn loudly: BK7238 is accepted but not hardware-verified and may be
+        # WiFi-unstable with BLE on.
+        _LOGGER.warning(
+            "bk72xx_ble on BK7238: enabling BLE is known to risk a WiFi STA startup "
+            "hang on this family and is not yet hardware-verified. Expect possible "
+            "instability."
+        )
 
     cg.add_define("USE_BK72XX_BLE")

esphome/components/ble_device_base/__init__.py

@@ -206,32 +206,36 @@ def validate_scan_parameters(config: ConfigType) -> ConfigType:
     interval = config[CONF_INTERVAL]
     window = config[CONF_WINDOW]
 
-    if window > interval:
-        raise cv.Invalid(
-            f"Scan window ({window}) needs to be smaller than scan interval ({interval})"
-        )
+    # Labels are reused in every error below; the optional one names its key.
+    windows = [("Scan window", window)]
+    if (connection_window := config.get(CONF_CONNECTION_SCAN_WINDOW)) is not None:
+        windows.append((CONF_CONNECTION_SCAN_WINDOW, connection_window))
+
+    for name, value in windows:
+        if value > interval:
+            raise cv.Invalid(
+                f"{name} ({value}) needs to be smaller than scan interval ({interval})"
+            )
 
     # BLE scan interval/window are programmed in 0.625 ms units as a 16-bit value; the
     # controller only accepts 2.5 ms .. 10240 ms (0x0004 .. 0x4000). Reject out-of-range
     # values here instead of letting the unit conversion silently overflow.
-    for name, value in (("interval", interval), ("window", window)):
+    for name, value in (("Scan interval", interval), *windows):
         if value.total_microseconds < 2500 or value.total_microseconds > 10_240_000:
-            raise cv.Invalid(
-                f"Scan {name} ({value}) must be between 2.5 ms and 10240 ms"
-            )
+            raise cv.Invalid(f"{name} ({value}) must be between 2.5 ms and 10240 ms")
 
     # Validate what actually reaches the controller: both values are truncated to
     # whole 0.625 ms units, so a window/interval pair that differs by less than one
     # unit collapses to the same value — silently programming a 100 % duty cycle
     # (radio permanently on) from a config that asked for less.
     interval_units = to_ble_units(interval)
-    window_units = to_ble_units(window)
-    if window_units == interval_units and window < interval:
-        raise cv.Invalid(
-            f"Scan window ({window}) and interval ({interval}) both truncate to "
-            f"{interval_units} x 0.625 ms, which the controller scans at a 100 % duty "
-            f"cycle. Separate them by at least 0.625 ms."
-        )
+    for name, value in windows:
+        if to_ble_units(value) == interval_units and value < interval:
+            raise cv.Invalid(
+                f"{name} ({value}) and interval ({interval}) both truncate to "
+                f"{interval_units} x 0.625 ms, which the controller scans at a 100 % duty "
+                f"cycle. Separate them by at least 0.625 ms."
+            )
 
     if interval.total_microseconds * 3 > duration.total_microseconds:
         raise cv.Invalid(
@@ -247,11 +251,14 @@ def validate_scan_parameters(config: ConfigType) -> ConfigType:
 # their own; also the fallback for esp32's conditional default.
 DEFAULT_SCAN_WINDOW = "30ms"
 
+CONF_CONNECTION_SCAN_WINDOW = "connection_scan_window"
+
 
 def scan_parameters_schema(
     interval_default: str,
     *,
     window_default: str | Callable[[], TimePeriod] = DEFAULT_SCAN_WINDOW,
+    connection_window: bool = False,
 ) -> cv.All:
     """Build the scan_parameters value schema shared by all BLE trackers.
 
@@ -263,7 +270,9 @@ def scan_parameters_schema(
     can adjust it once sibling keys are resolved). The `active` option
     (default on) is unconditional: active scanning is part of the tracker
     contract — every current proxy client assumes it, so a passive-only
-    tracker must not share this schema.
+    tracker must not share this schema. connection_window opts in to the
+    `connection_scan_window` option for trackers that can fall back to a
+    smaller window while a GATT connection is active.
     """
     schema = {
         cv.Optional(CONF_DURATION, default="5min"): cv.positive_time_period_seconds,
@@ -272,6 +281,8 @@ def scan_parameters_schema(
         cv.Optional(CONF_CONTINUOUS, default=True): cv.boolean,
         cv.Optional(CONF_ACTIVE, default=True): cv.boolean,
     }
+    if connection_window:
+        schema[cv.Optional(CONF_CONNECTION_SCAN_WINDOW)] = cv.positive_time_period
     return cv.All(cv.Schema(schema), validate_scan_parameters)
 
 

esphome/components/button/__init__.py

@@ -16,15 +16,14 @@ from esphome.const import (
     DEVICE_CLASS_RESTART,
     DEVICE_CLASS_UPDATE,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+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,
 )
-from esphome.cpp_generator import MockObj, MockObjClass, TemplateArgsType
-from esphome.types import ConfigType, SafeExpType
+from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@esphome/core"]
 IS_PLATFORM_COMPONENT = True
@@ -89,7 +88,7 @@ _CALLBACK_AUTOMATIONS = (
 
 
 @setup_entity("button")
-async def setup_button_core_(var: MockObj, config: ConfigType) -> None:
+async def setup_button_core_(var, config):
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
     setup_device_class(config)
@@ -102,7 +101,7 @@ async def setup_button_core_(var: MockObj, config: ConfigType) -> None:
         await web_server.add_entity_config(var, web_server_config)
 
 
-async def register_button(var: MockObj, config: ConfigType) -> None:
+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)
@@ -110,7 +109,7 @@ async def register_button(var: MockObj, config: ConfigType) -> None:
     await setup_button_core_(var, config)
 
 
-async def new_button(config: ConfigType, *args: SafeExpType) -> MockObj:
+async def new_button(config, *args):
     var = cg.new_Pvariable(config[CONF_ID], *args)
     await register_button(var, config)
     return var
@@ -126,16 +125,11 @@ BUTTON_PRESS_SCHEMA = maybe_simple_id(
 @automation.register_action(
     "button.press", PressAction, BUTTON_PRESS_SCHEMA, synchronous=True
 )
-async def button_press_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def button_press_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 @coroutine_with_priority(CoroPriority.CORE)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_global(button_ns.using)

esphome/components/captive_portal/captive_portal.cpp

@@ -6,7 +6,6 @@
 #include "esphome/core/string_ref.h"
 #include "esphome/components/wifi/wifi_component.h"
 #include "captive_index.h"
-#include "scan_list.h"
 
 namespace esphome::captive_portal {
 
@@ -34,10 +33,8 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
     // Invariant: only bounded in-memory work under the lock; the network send
     // happens later in request->send()
     wifi::ScanResultsLock lock(wifi::global_wifi_component);
-    const auto &results = wifi::global_wifi_component->get_scan_result();
-    for (const auto &scan : results) {
-      bool with_auth = false;
-      if (!should_show_scan_entry(results, scan, with_auth))
+    for (const auto &scan : wifi::global_wifi_component->get_scan_result()) {
+      if (scan.get_is_hidden())
         continue;
 
       json_escape_into_buffer(escaped_ssid, scan.get_ssid());
@@ -47,10 +44,10 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
       stream->print(ESPHOME_F("\",\"rssi\":"));
       stream->print(scan.get_rssi());
       stream->print(ESPHOME_F(",\"lock\":"));
-      stream->print(with_auth);
+      stream->print(scan.get_with_auth());
       stream->print(ESPHOME_F("}"));
 #else
-      stream->printf(R"(,{"ssid":"%s","rssi":%d,"lock":%d})", escaped_ssid, scan.get_rssi(), with_auth);
+      stream->printf(R"(,{"ssid":"%s","rssi":%d,"lock":%d})", escaped_ssid, scan.get_rssi(), scan.get_with_auth());
 #endif
     }
   }

esphome/components/captive_portal/scan_list.h

@@ -1,28 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace esphome::captive_portal {
-
-// A scan lists every BSSID, so one SSID can appear several times. Returns true for
-// the strongest entry per SSID (earliest on ties), never for hidden entries. scan
-// must be an element of results. with_auth is written only when returning true and
-// is set if any entry with that SSID needs a key. Templated for host tests.
-template<typename Results, typename Entry>
-bool should_show_scan_entry(const Results &results, const Entry &scan, bool &with_auth) {
-  if (scan.get_is_hidden())
-    return false;
-  const int8_t rssi = scan.get_rssi();
-  bool any_auth = false;
-  for (const auto &other : results) {
-    if (other.get_is_hidden() || !other.ssid_equals(scan))
-      continue;
-    // Same array, so address order is index order. scan fails both checks against itself.
-    if (other.get_rssi() > rssi || (other.get_rssi() == rssi && &other < &scan))
-      return false;
-    any_auth |= other.get_with_auth();
-  }
-  with_auth = any_auth;
-  return true;
-}
-
-}  // namespace esphome::captive_portal

esphome/components/climate/__init__.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import mqtt, web_server
@@ -50,19 +48,13 @@ from esphome.const import (
     CONF_VISUAL,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, ID, CoroPriority, Lambda, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
 from esphome.core.entity_helpers import (
     entity_duplicate_validator,
     queue_entity_register,
     setup_entity,
 )
-from esphome.cpp_generator import (
-    LambdaExpression,
-    MockObj,
-    MockObjClass,
-    TemplateArgsType,
-)
-from esphome.types import ConfigType, SafeExpType
+from esphome.cpp_generator import LambdaExpression, MockObjClass
 
 IS_PLATFORM_COMPONENT = True
 
@@ -140,7 +132,7 @@ VISUAL_TEMPERATURE_STEP_SCHEMA = cv.Schema(
 )
 
 
-def visual_temperature_step(value: Any) -> ConfigType:
+def visual_temperature_step(value):
     # Allow defining target/current temperature steps separately
     if isinstance(value, dict):
         return VISUAL_TEMPERATURE_STEP_SCHEMA(value)
@@ -281,7 +273,7 @@ def climate_schema(
 
 
 @setup_entity("climate")
-async def setup_climate_core_(var: MockObj, config: ConfigType) -> None:
+async def setup_climate_core_(var, config):
     visual = config.get(CONF_VISUAL, {})
     if (min_temp := visual.get(CONF_MIN_TEMPERATURE)) is not None:
         cg.add_define("USE_CLIMATE_VISUAL_OVERRIDES")
@@ -451,7 +443,7 @@ async def setup_climate_core_(var: MockObj, config: ConfigType) -> None:
         await web_server.add_entity_config(var, web_server_config)
 
 
-async def register_climate(var: MockObj, config: ConfigType) -> None:
+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)
@@ -459,7 +451,7 @@ async def register_climate(var: MockObj, config: ConfigType) -> None:
     await setup_climate_core_(var, config)
 
 
-async def new_climate(config: ConfigType, *args: SafeExpType) -> MockObj:
+async def new_climate(config, *args):
     var = cg.new_Pvariable(config[CONF_ID], *args)
     await register_climate(var, config)
     return var
@@ -493,12 +485,7 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
     CLIMATE_CONTROL_ACTION_SCHEMA,
     synchronous=True,
 )
-async def climate_control_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def climate_control_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
@@ -562,5 +549,5 @@ async def climate_control_to_code(
 
 
 @coroutine_with_priority(CoroPriority.CORE)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_global(climate_ns.using)

esphome/components/climate/climate.cpp

@@ -511,6 +511,29 @@ ClimateTraits Climate::get_traits() {
   return traits;
 }
 
+#ifdef USE_CLIMATE_VISUAL_OVERRIDES
+void Climate::set_visual_min_temperature_override(float visual_min_temperature_override) {
+  this->visual_min_temperature_override_ = visual_min_temperature_override;
+}
+
+void Climate::set_visual_max_temperature_override(float visual_max_temperature_override) {
+  this->visual_max_temperature_override_ = visual_max_temperature_override;
+}
+
+void Climate::set_visual_temperature_step_override(float target, float current) {
+  this->visual_target_temperature_step_override_ = target;
+  this->visual_current_temperature_step_override_ = current;
+}
+
+void Climate::set_visual_min_humidity_override(float visual_min_humidity_override) {
+  this->visual_min_humidity_override_ = visual_min_humidity_override;
+}
+
+void Climate::set_visual_max_humidity_override(float visual_max_humidity_override) {
+  this->visual_max_humidity_override_ = visual_max_humidity_override;
+}
+#endif
+
 ClimateCall Climate::make_call() { return ClimateCall(this); }
 
 ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {

esphome/components/climate/climate.h

@@ -228,22 +228,11 @@ class Climate : public EntityBase {
   ClimateTraits get_traits();
 
 #ifdef USE_CLIMATE_VISUAL_OVERRIDES
-  void set_visual_min_temperature_override(float visual_min_temperature_override) {
-    this->visual_min_temperature_override_ = visual_min_temperature_override;
-  }
-  void set_visual_max_temperature_override(float visual_max_temperature_override) {
-    this->visual_max_temperature_override_ = visual_max_temperature_override;
-  }
-  void set_visual_temperature_step_override(float target, float current) {
-    this->visual_target_temperature_step_override_ = target;
-    this->visual_current_temperature_step_override_ = current;
-  }
-  void set_visual_min_humidity_override(float visual_min_humidity_override) {
-    this->visual_min_humidity_override_ = visual_min_humidity_override;
-  }
-  void set_visual_max_humidity_override(float visual_max_humidity_override) {
-    this->visual_max_humidity_override_ = visual_max_humidity_override;
-  }
+  void set_visual_min_temperature_override(float visual_min_temperature_override);
+  void set_visual_max_temperature_override(float visual_max_temperature_override);
+  void set_visual_temperature_step_override(float target, float current);
+  void set_visual_min_humidity_override(float visual_min_humidity_override);
+  void set_visual_max_humidity_override(float visual_max_humidity_override);
 #endif
 
   /// Set the supported custom fan modes (stored on Climate, referenced by ClimateTraits).

esphome/components/cover/__init__.py

@@ -46,7 +46,7 @@ from esphome.core.entity_helpers import (
     setup_entity,
 )
 from esphome.cpp_generator import LambdaExpression, MockObj, MockObjClass
-from esphome.types import ConfigType, SafeExpType, TemplateArgsType
+from esphome.types import ConfigType, TemplateArgsType
 
 IS_PLATFORM_COMPONENT = True
 
@@ -162,7 +162,7 @@ _COVER_SCHEMA = (
 _COVER_SCHEMA.add_extra(entity_duplicate_validator("cover"))
 
 
-def _validate_mqtt_state_topics(config: ConfigType) -> ConfigType:
+def _validate_mqtt_state_topics(config):
     if config.get(CONF_MQTT_JSON_STATE_PAYLOAD):
         if CONF_POSITION_STATE_TOPIC in config:
             raise cv.Invalid(
@@ -201,7 +201,7 @@ def cover_schema(
 
 
 @setup_entity("cover")
-async def setup_cover_core_(var: MockObj, config: ConfigType) -> None:
+async def setup_cover_core_(var, config):
     setup_device_class(config)
 
     if CONF_ON_OPEN in config:
@@ -235,7 +235,7 @@ async def setup_cover_core_(var: MockObj, config: ConfigType) -> None:
         await web_server.add_entity_config(var, web_server_config)
 
 
-async def register_cover(var: MockObj, config: ConfigType) -> None:
+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)
@@ -243,7 +243,7 @@ async def register_cover(var: MockObj, config: ConfigType) -> None:
     await setup_cover_core_(var, config)
 
 
-async def new_cover(config: ConfigType, *args: SafeExpType) -> MockObj:
+async def new_cover(config, *args):
     var = cg.new_Pvariable(config[CONF_ID], *args)
     await register_cover(var, config)
     return var
@@ -259,12 +259,7 @@ COVER_ACTION_SCHEMA = maybe_simple_id(
 @automation.register_action(
     "cover.open", OpenAction, COVER_ACTION_SCHEMA, synchronous=True
 )
-async def cover_open_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def cover_open_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
 
@@ -272,12 +267,7 @@ async def cover_open_to_code(
 @automation.register_action(
     "cover.close", CloseAction, COVER_ACTION_SCHEMA, synchronous=True
 )
-async def cover_close_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def cover_close_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
 
@@ -285,12 +275,7 @@ async def cover_close_to_code(
 @automation.register_action(
     "cover.stop", StopAction, COVER_ACTION_SCHEMA, synchronous=True
 )
-async def cover_stop_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def cover_stop_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
 
@@ -298,12 +283,7 @@ async def cover_stop_to_code(
 @automation.register_action(
     "cover.toggle", ToggleAction, COVER_ACTION_SCHEMA, synchronous=True
 )
-async def cover_toggle_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def cover_toggle_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
 
@@ -441,5 +421,5 @@ automation.register_condition(
 
 
 @coroutine_with_priority(CoroPriority.CORE)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_global(cover_ns.using)

esphome/components/cover/cover.cpp

@@ -135,6 +135,10 @@ CoverCall &CoverCall::set_stop(bool stop) {
   this->stop_ = stop;
   return *this;
 }
+bool CoverCall::get_stop() const { return this->stop_; }
+
+CoverCall Cover::make_call() { return {this}; }
+
 void Cover::publish_state(bool save) {
   this->position = clamp(this->position, 0.0f, 1.0f);
   this->tilt = clamp(this->tilt, 0.0f, 1.0f);
@@ -180,6 +184,9 @@ optional<CoverRestoreState> Cover::restore_state_() {
   return recovered;
 }
 
+bool Cover::is_fully_open() const { return this->position == COVER_OPEN; }
+bool Cover::is_fully_closed() const { return this->position == COVER_CLOSED; }
+
 CoverCall CoverRestoreState::to_call(Cover *cover) {
   auto call = cover->make_call();
   auto traits = cover->get_traits();

esphome/components/cover/cover.h

@@ -50,7 +50,7 @@ class CoverCall {
   void perform();
 
   const optional<float> &get_position() const;
-  bool get_stop() const { return this->stop_; }
+  bool get_stop() const;
   const optional<float> &get_tilt() const;
   const optional<bool> &get_toggle() const;
 
@@ -123,7 +123,7 @@ class Cover : public EntityBase {
   float tilt{COVER_OPEN};
 
   /// Construct a new cover call used to control the cover.
-  CoverCall make_call() { return {this}; }
+  CoverCall make_call();
 
   template<typename F> void add_on_state_callback(F &&f) { this->state_callback_.add(std::forward<F>(f)); }
 
@@ -139,9 +139,9 @@ class Cover : public EntityBase {
   virtual CoverTraits get_traits() = 0;
 
   /// Helper method to check if the cover is fully open. Equivalent to comparing .position against 1.0
-  bool is_fully_open() const { return this->position == COVER_OPEN; }
+  bool is_fully_open() const;
   /// Helper method to check if the cover is fully closed. Equivalent to comparing .position against 0.0
-  bool is_fully_closed() const { return this->position == COVER_CLOSED; }
+  bool is_fully_closed() const;
 
  protected:
   friend CoverCall;

esphome/components/dashboard_import/__init__.py

@@ -2,7 +2,6 @@ import base64
 from pathlib import Path
 import re
 import secrets
-from typing import Any
 
 import requests
 from ruamel.yaml import YAML
@@ -14,7 +13,6 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ESPHOME, CONF_PROJECT, CONF_REF, CONF_WIFI
 import esphome.final_validate as fv
 from esphome.happy_eyeballs import ensure_happy_eyeballs
-from esphome.types import ConfigType
 from esphome.yaml_util import dump
 
 dashboard_import_ns = cg.esphome_ns.namespace("dashboard_import")
@@ -25,14 +23,14 @@ DEPENDENCIES = ["api"]
 CODEOWNERS = ["@esphome/core"]
 
 
-def validate_import_url(value: Any) -> str:
+def validate_import_url(value):
     value = cv.string_strict(value)
     value = cv.Length(max=255)(value)
     validate_source_shorthand(value)
     return value
 
 
-def validate_full_url(config: ConfigType) -> ConfigType:
+def validate_full_url(config):
     if not config[CONF_IMPORT_FULL_CONFIG]:
         return config
     source = validate_source_shorthand(config[CONF_PACKAGE_IMPORT_URL])
@@ -57,7 +55,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate(config: ConfigType) -> None:
+def _final_validate(config):
     full_config = fv.full_config.get()[CONF_ESPHOME]
     if CONF_PROJECT not in full_config:
         raise cv.Invalid(
@@ -75,7 +73,7 @@ wifi:
 """
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_define("USE_DASHBOARD_IMPORT")
     url = config[CONF_PACKAGE_IMPORT_URL]
     if config[CONF_IMPORT_FULL_CONFIG]:

esphome/components/datetime/date_entity.cpp

@@ -37,6 +37,8 @@ void DateEntity::publish_state() {
 #endif
 }
 
+DateCall DateEntity::make_call() { return DateCall(this); }
+
 void DateCall::validate_() {
   if (this->year_.has_value() && (this->year_ < 1970 || this->year_ > 3000)) {
     ESP_LOGE(TAG, "Year must be between 1970 and 3000");

esphome/components/datetime/date_entity.h

@@ -96,8 +96,6 @@ class DateCall {
   optional<uint8_t> day_;
 };
 
-inline DateCall DateEntity::make_call() { return DateCall(this); }
-
 template<typename... Ts> class DateSetAction final : public Action<Ts...>, public Parented<DateEntity> {
  public:
   TEMPLATABLE_VALUE(ESPTime, date)

esphome/components/datetime/datetime_entity.cpp

@@ -53,6 +53,8 @@ void DateTimeEntity::publish_state() {
 #endif
 }
 
+DateTimeCall DateTimeEntity::make_call() { return DateTimeCall(this); }
+
 ESPTime DateTimeEntity::state_as_esptime() const {
   ESPTime obj;
   obj.year = this->year_;

esphome/components/datetime/datetime_entity.h

@@ -121,8 +121,6 @@ class DateTimeCall {
   optional<uint8_t> second_;
 };
 
-inline DateTimeCall DateTimeEntity::make_call() { return DateTimeCall(this); }
-
 template<typename... Ts> class DateTimeSetAction final : public Action<Ts...>, public Parented<DateTimeEntity> {
  public:
   TEMPLATABLE_VALUE(ESPTime, datetime)

esphome/components/datetime/time_entity.cpp

@@ -33,6 +33,8 @@ void TimeEntity::publish_state() {
 #endif
 }
 
+TimeCall TimeEntity::make_call() { return TimeCall(this); }
+
 void TimeCall::validate_() {
   if (this->hour_.has_value() && this->hour_ > 23) {
     ESP_LOGE(TAG, "Hour must be between 0 and 23");

esphome/components/datetime/time_entity.h

@@ -98,8 +98,6 @@ class TimeCall {
   optional<uint8_t> second_;
 };
 
-inline TimeCall TimeEntity::make_call() { return TimeCall(this); }
-
 template<typename... Ts> class TimeSetAction final : public Action<Ts...>, public Parented<TimeEntity> {
  public:
   TEMPLATABLE_VALUE(ESPTime, time)

esphome/components/debug/__init__.py

@@ -12,7 +12,6 @@ from esphome.const import (
     PlatformFramework,
 )
 from esphome.core import CORE
-from esphome.types import ConfigType
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["logger"]
@@ -46,7 +45,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     if CORE.using_zephyr:
         zephyr_add_prj_conf("HWINFO", True)
         # gdb thread support

esphome/components/debug/sensor.py

@@ -21,7 +21,6 @@ from esphome.const import (
     UNIT_MILLISECOND,
     UNIT_PERCENT,
 )
-from esphome.types import ConfigType
 
 from . import (  # noqa: F401  pylint: disable=unused-import
     CONF_DEBUG_ID,
@@ -112,7 +111,7 @@ CONFIG_SCHEMA = {
 }
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     debug_component = await cg.get_variable(config[CONF_DEBUG_ID])
 
     if free_conf := config.get(CONF_FREE):

esphome/components/debug/text_sensor.py

@@ -7,7 +7,6 @@ from esphome.const import (
     ICON_CHIP,
     ICON_RESTART,
 )
-from esphome.types import ConfigType
 
 from . import (  # noqa: F401  pylint: disable=unused-import
     CONF_DEBUG_ID,
@@ -34,7 +33,7 @@ CONFIG_SCHEMA = cv.Schema(
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     debug_component = await cg.get_variable(config[CONF_DEBUG_ID])
 
     if CONF_DEVICE in config:

esphome/components/deep_sleep/__init__.py

@@ -163,11 +163,6 @@ def validate_config(config: ConfigType) -> ConfigType:
                     "You need to remove the global wakeup_pin_mode and define it per pin"
                 )
             if wakeup_pins:
-                if CONF_WAKEUP_PIN_MODE in wakeup_pins[0]:
-                    raise cv.Invalid(
-                        "Specify wakeup_pin_mode either at the top level under deep_sleep "
-                        "or under the pin entry, not both"
-                    )
                 wakeup_pins[0][CONF_WAKEUP_PIN_MODE] = config.pop(CONF_WAKEUP_PIN_MODE)
     elif (
         isinstance(config.get(CONF_WAKEUP_PIN), list)

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -43,6 +43,10 @@ void DeepSleepComponent::loop() {
     this->begin_sleep();
 }
 
+void DeepSleepComponent::set_sleep_duration(uint32_t time_ms) { this->sleep_duration_ = uint64_t(time_ms) * 1000; }
+
+void DeepSleepComponent::set_run_duration(uint32_t time_ms) { this->run_duration_ = time_ms; }
+
 void DeepSleepComponent::begin_sleep(bool manual) {
   if (this->prevent_ && !manual) {
     this->next_enter_deep_sleep_ = true;
@@ -72,4 +76,8 @@ void DeepSleepComponent::begin_sleep(bool manual) {
 
 float DeepSleepComponent::get_setup_priority() const { return setup_priority::LATE; }
 
+void DeepSleepComponent::prevent_deep_sleep() { this->prevent_ = true; }
+
+void DeepSleepComponent::allow_deep_sleep() { this->prevent_ = false; }
+
 }  // namespace esphome::deep_sleep

esphome/components/deep_sleep/deep_sleep_component.h

@@ -132,7 +132,7 @@ template<typename... Ts> class PreventDeepSleepAction;
 class DeepSleepComponent final : public Component {
  public:
   /// Set the duration in ms the component should sleep once it's in deep sleep mode.
-  void set_sleep_duration(uint32_t time_ms) { this->sleep_duration_ = uint64_t(time_ms) * 1000; }
+  void set_sleep_duration(uint32_t time_ms);
 #if defined(USE_ESP32)
   /** Set the pin to wake up to on the ESP32 once it's in deep sleep mode.
    * Use the inverted property to set the wakeup level.
@@ -157,7 +157,7 @@ class DeepSleepComponent final : public Component {
 #if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3) && \
     !defined(USE_ESP32_VARIANT_ESP32C5) && !defined(USE_ESP32_VARIANT_ESP32C6) && \
     !defined(USE_ESP32_VARIANT_ESP32C61) && !defined(USE_ESP32_VARIANT_ESP32H2)
-  void set_touch_wakeup(bool touch_wakeup) { this->touch_wakeup_ = touch_wakeup; }
+  void set_touch_wakeup(bool touch_wakeup);
 #endif
 
   // Set the duration in ms for how long the code should run before entering
@@ -166,7 +166,7 @@ class DeepSleepComponent final : public Component {
 #endif  // USE_ESP32
 
   /// Set a duration in ms for how long the code should run before entering deep sleep mode.
-  void set_run_duration(uint32_t time_ms) { this->run_duration_ = time_ms; }
+  void set_run_duration(uint32_t time_ms);
 
   void setup() override;
   void dump_config() override;
@@ -176,8 +176,8 @@ class DeepSleepComponent final : public Component {
   /// Helper to enter deep sleep mode
   void begin_sleep(bool manual = false);
 
-  void prevent_deep_sleep() { this->prevent_ = true; }
-  void allow_deep_sleep() { this->prevent_ = false; }
+  void prevent_deep_sleep();
+  void allow_deep_sleep();
 
  protected:
   // Returns nullopt if no run duration is set. Otherwise, returns the run

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -74,6 +74,12 @@ void DeepSleepComponent::set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode) {
 void DeepSleepComponent::set_ext1_wakeup(Ext1Wakeup ext1_wakeup) { this->ext1_wakeup_ = ext1_wakeup; }
 #endif
 
+#if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3) && \
+    !defined(USE_ESP32_VARIANT_ESP32C5) && !defined(USE_ESP32_VARIANT_ESP32C6) && \
+    !defined(USE_ESP32_VARIANT_ESP32C61) && !defined(USE_ESP32_VARIANT_ESP32H2)
+void DeepSleepComponent::set_touch_wakeup(bool touch_wakeup) { this->touch_wakeup_ = touch_wakeup; }
+#endif
+
 void DeepSleepComponent::set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration) {
   wakeup_cause_to_run_duration_ = wakeup_cause_to_run_duration;
 }

esphome/components/display/display.cpp

@@ -685,6 +685,9 @@ void Display::show_page(DisplayPage *page) {
   }
 }
 
+void Display::show_next_page() { this->page_->show_next(); }
+void Display::show_prev_page() { this->page_->show_prev(); }
+
 void Display::do_update_() {
   if (this->auto_clear_enabled_) {
     this->clear();
@@ -889,6 +892,9 @@ void DisplayPage::show_prev() {
   this->prev_->show();
 }
 
+void DisplayPage::set_parent(Display *parent) { this->parent_ = parent; }
+void DisplayPage::set_prev(DisplayPage *prev) { this->prev_ = prev; }
+void DisplayPage::set_next(DisplayPage *next) { this->next_ = next; }
 const display_writer_t &DisplayPage::get_writer() const { return this->writer_; }
 
 const LogString *text_align_to_string(TextAlign textalign) {

esphome/components/display/display.h

@@ -802,9 +802,9 @@ class DisplayPage final {
   void show();
   void show_next();
   void show_prev();
-  void set_parent(Display *parent) { this->parent_ = parent; }
-  void set_prev(DisplayPage *prev) { this->prev_ = prev; }
-  void set_next(DisplayPage *next) { this->next_ = next; }
+  void set_parent(Display *parent);
+  void set_prev(DisplayPage *prev);
+  void set_next(DisplayPage *next);
   const display_writer_t &get_writer() const;
 
  protected:
@@ -814,9 +814,6 @@ class DisplayPage final {
   DisplayPage *next_{nullptr};
 };
 
-inline void Display::show_next_page() { this->page_->show_next(); }
-inline void Display::show_prev_page() { this->page_->show_prev(); }
-
 template<typename... Ts> class DisplayPageShowAction final : public Action<Ts...> {
  public:
   TEMPLATABLE_VALUE(DisplayPage *, page)

esphome/components/esp32/__init__.py

@@ -233,7 +233,6 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
     "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
     "esp_eth",  # Ethernet driver - only needed by ethernet component
-    "esp_gdbstub",  # GDB stub panic handler - unused by ESPHome; bt pulls it back
     "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
     "esp_http_client",  # HTTP client - only needed by http_request component
     "esp_https_ota",  # ESP-IDF HTTPS OTA - ESPHome has its own OTA implementation

esphome/components/esp32_ble/ble.cpp

@@ -643,28 +643,8 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
       App.wake_loop_threadsafe();
       return;
 
-    // Log the result of connection parameter updates: a peer can reject or
-    // never answer an update, and without this the link silently stays on the
-    // old parameters (visible only as unexplained supervision timeouts).
-    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT: {
-      if (param->update_conn_params.status != ESP_BT_STATUS_SUCCESS) {
-        char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-        format_mac_addr_upper(param->update_conn_params.bda, mac_s);
-        ESP_LOGW(TAG, "[%s] Conn param update failed, status=%d", mac_s, param->update_conn_params.status);
-      }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-      else {
-        char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-        format_mac_addr_upper(param->update_conn_params.bda, mac_s);
-        ESP_LOGV(TAG, "[%s] Conn params updated: interval=%u (x1.25ms) latency=%u timeout=%u (x10ms)", mac_s,
-                 param->update_conn_params.conn_int, param->update_conn_params.latency,
-                 param->update_conn_params.timeout);
-      }
-#endif
-      return;
-    }
-
     // Ignore these GAP events as they are not relevant for our use case
+    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
     case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
     case ESP_GAP_BLE_PHY_UPDATE_COMPLETE_EVT:       // BLE 5.0 PHY update complete
     case ESP_GAP_BLE_CHANNEL_SELECT_ALGORITHM_EVT:  // BLE 5.0 channel selection algorithm

esphome/components/esp32_ble_tracker/__init__.py

@@ -7,6 +7,7 @@ import logging
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import ble_device_base, esp32_ble, ota
+from esphome.components.ble_device_base import CONF_CONNECTION_SCAN_WINDOW
 from esphome.components.const import CONF_ON_SCAN_END, CONF_SCAN_PARAMETERS, CONF_WINDOW
 from esphome.components.esp32 import (
     add_idf_sdkconfig_option,
@@ -73,8 +74,9 @@ def _get_required_features() -> set[BLEFeatures]:
 
 # Slot counters sizing the tracker's StaticVector storage; one request per
 # registered listener or client.
+CLIENT_COUNT_DEFINE = "ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT"
 _request_listener_slot = cg.slot_counter("ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT")
-_request_client_slot = cg.slot_counter("ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT")
+_request_client_slot = cg.slot_counter(CLIENT_COUNT_DEFINE)
 
 
 def register_ble_features(features: set[BLEFeatures]) -> None:
@@ -147,6 +149,7 @@ class TrackerData:
     """Per-run validation state, namespaced under DOMAIN in CORE.data."""
 
     scan_window_defaulted: bool = False
+    connection_window_injected: bool = False
 
 
 def _get_data() -> TrackerData:
@@ -175,17 +178,34 @@ def _raise_defaulted_scan_window(config: ConfigType) -> ConfigType:
     honors the window strictly (>= 5.5.5); without the arbiter a full-duty
     scan would starve wifi outright, and a user-set window is never touched.
     Raising to the interval cannot invalidate the already-validated
-    parameters, so no re-validation is needed.
+    parameters, so no re-validation is needed. The connection window is
+    checked against the window here, after the raise.
     """
+    params = config[CONF_SCAN_PARAMETERS]
     if (
         _get_data().scan_window_defaulted
         and config.get(CONF_SOFTWARE_COEXISTENCE)
         and idf_version() >= IDF_SCAN_WINDOW_FIX_VERSION
     ):
-        params = config[CONF_SCAN_PARAMETERS]
         # Copy so the config dump shows a plain value instead of a YAML
         # anchor/alias pair pointing at the interval.
         params[CONF_WINDOW] = copy.copy(params[CONF_INTERVAL])
+        # Arm the connection-time fallback unless the user set one. Injected
+        # after validation; safe because it equals the validated window default.
+        if CONF_CONNECTION_SCAN_WINDOW not in params:
+            params[CONF_CONNECTION_SCAN_WINDOW] = cv.positive_time_period(
+                ble_device_base.DEFAULT_SCAN_WINDOW
+            )
+            _get_data().connection_window_injected = True
+    if (
+        connection_window := params.get(CONF_CONNECTION_SCAN_WINDOW)
+    ) is not None and connection_window > params[CONF_WINDOW]:
+        # A larger value would widen the scan during connections.
+        raise cv.Invalid(
+            f"{CONF_CONNECTION_SCAN_WINDOW} ({connection_window}) needs to be "
+            f"smaller than the scan window ({params[CONF_WINDOW]})",
+            path=[CONF_SCAN_PARAMETERS, CONF_CONNECTION_SCAN_WINDOW],
+        )
     return config
 
 
@@ -194,7 +214,7 @@ def _raise_defaulted_scan_window(config: ConfigType) -> ConfigType:
 # window/interval pairs that collapse to the same 0.625 ms unit count.
 # The window default is conditional (see _scan_window_default above).
 SCAN_PARAMETERS_SCHEMA = ble_device_base.scan_parameters_schema(
-    "320ms", window_default=_scan_window_default
+    "320ms", window_default=_scan_window_default, connection_window=True
 )
 
 # Codegen helpers are owned by ble_device_base; kept under the historical names
@@ -288,6 +308,25 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_scan_duration(params[CONF_DURATION]))
     cg.add(var.set_scan_interval(ble_device_base.to_ble_units(params[CONF_INTERVAL])))
     cg.add(var.set_scan_window(ble_device_base.to_ble_units(params[CONF_WINDOW])))
+    if (connection_window := params.get(CONF_CONNECTION_SCAN_WINDOW)) is not None:
+        # Emitted at FINAL so a scan-only build, where the guarded C++ path
+        # compiles out, skips the call entirely.
+        window_units = ble_device_base.to_ble_units(connection_window)
+
+        @coroutine_with_priority(CoroPriority.FINAL)
+        async def _emit_connection_scan_window() -> None:
+            if cg.get_slot_count(CLIENT_COUNT_DEFINE):
+                cg.add(var.set_connection_scan_window(window_units))
+            elif not _get_data().connection_window_injected:
+                # Warn only for a user-set value; the injected default drops silently.
+                _LOGGER.warning(
+                    "'%s' has no effect because this build has no BLE client "
+                    "components (for example bluetooth_proxy with active "
+                    "connections, or ble_client)",
+                    CONF_CONNECTION_SCAN_WINDOW,
+                )
+
+        CORE.add_job(_emit_connection_scan_window)
     cg.add(var.set_scan_active(params[CONF_ACTIVE]))
     cg.add(var.set_scan_continuous(params[CONF_CONTINUOUS]))
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -122,6 +122,9 @@ void ESP32BLETracker::loop() {
   // - start_scan_(): scanner_state_ becomes IDLE via set_scanner_state_() in cleanup_scan_state_()
   // - try_promote_discovered_clients_(): client enters DISCOVERED via set_state(), or
   //   connecting client finishes (state change), or scanner reaches RUNNING/IDLE
+  // - connection-window restart: scan_params_ is only written in start_scan_()
+  //   (which changes scanner state via set_scanner_state_()), and
+  //   counts.active/disconnecting only change on client state changes
   //
   // All conditions that affect the logic below are tied to state changes that increment
   // state_version_, so the fast path is safe.
@@ -144,6 +147,19 @@ void ESP32BLETracker::loop() {
       (this->scan_set_param_failed_ && this->scanner_state_ == ScannerState::RUNNING)) {
     this->handle_scanner_failure_();
   }
+
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  // The programmed window no longer matches the connection state (typically
+  // the last connection dropped): restart so the right window applies now
+  // instead of at the end of the scan period. Continuous only (a user-started
+  // scan would not restart); !disconnecting matches the restart gate below.
+  if (this->scanner_state_ == ScannerState::RUNNING && this->scan_continuous_ && !counts.disconnecting &&
+      this->scan_params_.scan_window != this->desired_scan_window_(counts.active)) {
+    // Same logical scan period continues: no on_scan_end sweeps for this
+    // restart. Only armed when the stop was issued.
+    this->skip_next_scan_end_ = this->stop_scan_();
+  }
+#endif
   /*
 
     Avoid starting the scanner if:
@@ -195,19 +211,23 @@ void ESP32BLETracker::stop_scan() {
   // reason at D themselves, and the user-facing stop action is deliberate.
   ESP_LOGV(TAG, "Stopping scan.");
   this->scan_continuous_ = false;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  // The window-change restart is abandoned with continuous scanning.
+  this->skip_next_scan_end_ = false;
+#endif
   this->stop_scan_();
 }
 
 void ESP32BLETracker::ble_before_disabled_event_handler() { this->stop_scan_(); }
 
-void ESP32BLETracker::stop_scan_() {
+bool ESP32BLETracker::stop_scan_() {
   if (this->scanner_state_ != ScannerState::RUNNING && this->scanner_state_ != ScannerState::FAILED) {
     // IDLE means there is nothing to stop; STOPPING means a stop is already in
     // flight and will finish on its own. Neither is an error.
     if (this->scanner_state_ != ScannerState::IDLE && this->scanner_state_ != ScannerState::STOPPING) {
       ESP_LOGE(TAG, "Cannot stop scan: %s", this->scanner_state_to_string_(this->scanner_state_));
     }
-    return;
+    return false;
   }
   // Reset timeout state machine when stopping scan
   this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
@@ -215,8 +235,9 @@ void ESP32BLETracker::stop_scan_() {
   esp_err_t err = esp_ble_gap_stop_scanning();
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gap_stop_scanning failed: %d", err);
-    return;
+    return false;
   }
+  return true;
 }
 
 void ESP32BLETracker::start_scan_(bool first) {
@@ -230,16 +251,11 @@ void ESP32BLETracker::start_scan_(bool first) {
   }
   this->set_scanner_state_(ScannerState::STARTING);
   ESP_LOGV(TAG, "Starting scan, set scanner state to STARTING.");
-  if (!first) {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
-    for (auto *listener : this->listeners_)
-      listener->on_scan_end();
+  if (!first)
+    this->notify_scan_end_();
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  this->skip_next_scan_end_ = false;
 #endif
-#ifdef ESPHOME_BLE_DEVICE_BASE_LISTENER_COUNT
-    for (auto *listener : this->neutral_listeners_)
-      listener->on_scan_end();
-#endif
-  }
 #ifdef USE_ESP32_BLE_DEVICE
   this->discovered_log_.clear();
 #endif
@@ -247,7 +263,17 @@ void ESP32BLETracker::start_scan_(bool first) {
   this->scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
   this->scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
   this->scan_params_.scan_interval = this->scan_interval_;
-  this->scan_params_.scan_window = this->scan_window_;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  // Count fresh: an automation can start a scan before loop() refreshes the counts.
+  const uint32_t window = this->desired_scan_window_(this->count_client_states_().active);
+  if (window != this->scan_window_) {
+    // Guarantee the connection airtime instead of scanning wall to wall.
+    ESP_LOGV(TAG, "Connection active, using %" PRIu32 " unit scan window", window);
+  }
+#else
+  const uint32_t window = this->scan_window_;
+#endif
+  this->scan_params_.scan_window = window;
 
   // Start timeout monitoring in loop() instead of using scheduler
   // This prevents false reboots when the loop is blocked
@@ -408,6 +434,11 @@ void ESP32BLETracker::dump_config() {
                 "  Continuous Scanning: %s",
                 this->scan_duration_, this->scan_interval_ * 0.625f, this->scan_window_ * 0.625f,
                 this->scan_active_ ? "ACTIVE" : "PASSIVE", YESNO(this->scan_continuous_));
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  if (this->connection_scan_window_ != 0) {
+    ESP_LOGCONFIG(TAG, "  Connection Scan Window: %.1f ms", this->connection_scan_window_ * 0.625f);
+  }
+#endif
   ESP_LOGCONFIG(TAG,
                 "  Scanner State: %s\n"
                 "  Connecting: %d, discovered: %d, disconnecting: %d, active: %d",
@@ -487,6 +518,18 @@ void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {
   // Reset timeout state machine instead of cancelling scheduler timeout
   this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
 
+  this->notify_scan_end_();
+
+  this->set_scanner_state_(ScannerState::IDLE);
+}
+
+void ESP32BLETracker::notify_scan_end_() {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  // Window-change restart continues the same scan period; the flag stays set
+  // across the stop and is cleared by the restart in start_scan_.
+  if (this->skip_next_scan_end_)
+    return;
+#endif
 #ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   for (auto *listener : this->listeners_)
     listener->on_scan_end();
@@ -495,8 +538,6 @@ void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {
   for (auto *listener : this->neutral_listeners_)
     listener->on_scan_end();
 #endif
-
-  this->set_scanner_state_(ScannerState::IDLE);
 }
 
 void ESP32BLETracker::handle_scanner_failure_() {
@@ -534,6 +575,8 @@ void ESP32BLETracker::try_promote_discovered_clients_() {
     }
 
     ESP_LOGD(TAG, "Promoting client to connect");
+    // A connect ends the scan period a window-change restart was continuing.
+    this->skip_next_scan_end_ = false;
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
     this->update_coex_preference_(true);
 #endif

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -169,6 +169,9 @@ class ESP32BLETracker final : public Component,
   void set_scan_duration(uint32_t scan_duration) { scan_duration_ = scan_duration; }
   void set_scan_interval(uint32_t scan_interval) { scan_interval_ = scan_interval; }
   void set_scan_window(uint32_t scan_window) { scan_window_ = scan_window; }
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  void set_connection_scan_window(uint32_t scan_window) { connection_scan_window_ = scan_window; }
+#endif
   void set_scan_active(bool scan_active) { scan_active_ = scan_active; }
   bool get_scan_active() const { return scan_active_; }
   void set_scan_continuous(bool scan_continuous) { scan_continuous_ = scan_continuous; }
@@ -226,7 +229,10 @@ class ESP32BLETracker final : public Component,
   ScannerState get_scanner_state() const { return this->scanner_state_; }
 
  protected:
-  void stop_scan_();
+  /// Returns true when a stop was issued to the controller.
+  bool stop_scan_();
+  /// Fire on_scan_end on every listener unless a window-change restart suppressed it.
+  void notify_scan_end_();
   /// Start a single scan by setting up the parameters and doing some esp-idf calls.
   void start_scan_(bool first);
   /// Called when a `ESP_GAP_BLE_SCAN_RESULT_EVT` event is received.
@@ -313,6 +319,15 @@ class ESP32BLETracker final : public Component,
   uint32_t scan_duration_;
   uint32_t scan_interval_;
   uint32_t scan_window_;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  /// Window used while a GATT connection is active; set by the user, or
+  /// defaulted when the window was raised to full duty (0 = no fallback).
+  uint32_t connection_scan_window_{0};
+  /// The window to scan at for the given number of active GATT connections.
+  uint32_t desired_scan_window_(uint8_t active) const {
+    return (this->connection_scan_window_ != 0 && active > 0) ? this->connection_scan_window_ : this->scan_window_;
+  }
+#endif
   esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
   esp_bt_status_t scan_set_param_failed_{ESP_BT_STATUS_SUCCESS};
 
@@ -330,15 +345,20 @@ class ESP32BLETracker final : public Component,
   /// state_version_ to detect if any state changed since last iteration.
   uint8_t last_processed_version_{0};
   ScannerState scanner_state_{ScannerState::IDLE};
-  bool scan_continuous_;
-  bool scan_active_;
+  // Packed 1-bit flags.
+  bool scan_continuous_ : 1;
+  bool scan_active_ : 1;
 #ifdef USE_OTA_STATE_LISTENER
-  bool scan_continuous_before_ota_{false};
+  bool scan_continuous_before_ota_ : 1 {false};
+#endif
+  bool ble_was_disabled_ : 1 {true};
+  bool parse_advertisements_ : 1 {false};
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  /// Suppress the window-change restart's on_scan_end sweeps (stop and start).
+  bool skip_next_scan_end_ : 1 {false};
 #endif
-  bool ble_was_disabled_{true};
-  bool parse_advertisements_{false};
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
-  bool coex_prefer_ble_{false};
+  bool coex_prefer_ble_ : 1 {false};
 #endif
   // Scan timeout state machine
   enum class ScanTimeoutState : uint8_t {
@@ -346,10 +366,10 @@ class ESP32BLETracker final : public Component,
     MONITORING,     // Actively monitoring for timeout
     EXCEEDED_WAIT,  // Timeout exceeded, waiting one loop before reboot
   };
+  ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
   uint32_t scan_start_time_{0};
   /// Precomputed timeout value: scan_duration_ * 2000
   uint32_t scan_timeout_ms_{0};
-  ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
 };
 
 // NOLINTNEXTLINE

esphome/components/esp8266/__init__.py

@@ -3,7 +3,6 @@ from pathlib import Path
 import platform
 import re
 import subprocess
-from typing import Any
 
 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -32,7 +31,6 @@ from esphome.core import (
 from esphome.core.config import BOARD_MAX_LENGTH
 from esphome.helpers import IS_MACOS, copy_file_if_changed
 from esphome.platformio.toolchain import copy_ccache_script
-from esphome.storage_json import StorageJSON
 from esphome.types import ConfigType
 
 from .boards import BOARDS, ESP8266_LD_SCRIPTS
@@ -90,7 +88,7 @@ def lambdas_use_scanf_float(config: ConfigType) -> bool:
     return False
 
 
-def set_core_data(config: ConfigType) -> ConfigType:
+def set_core_data(config):
     CORE.data[KEY_ESP8266] = {}
     CORE.data[KEY_CORE][KEY_TARGET_PLATFORM] = PLATFORM_ESP8266
     CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "arduino"
@@ -104,7 +102,7 @@ def set_core_data(config: ConfigType) -> ConfigType:
     return config
 
 
-def get_download_types(storage_json: StorageJSON) -> list[dict[str, str]]:
+def get_download_types(storage_json):
     """Binary-download entries for a built ESP8266 firmware.
 
     Used by device-builder (esphome/device-builder), via
@@ -159,7 +157,7 @@ ARDUINO_3_PLATFORM_VERSION = cv.Version(3, 2, 0)
 ARDUINO_4_PLATFORM_VERSION = cv.Version(4, 2, 1)
 
 
-def _arduino_check_versions(value: ConfigType) -> ConfigType:
+def _arduino_check_versions(value):
     value = value.copy()
     lookups = {
         "dev": (cv.Version(3, 1, 2), "https://github.com/esp8266/Arduino.git"),
@@ -202,7 +200,7 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
     return value
 
 
-def _parse_platform_version(value: Any) -> str:
+def _parse_platform_version(value):
     try:
         # if platform version is a valid version constraint, prefix the default package
         cv.platformio_version_constraint(value)
@@ -277,7 +275,7 @@ def check_rosetta() -> None:
 
 
 @coroutine_with_priority(CoroPriority.PLATFORM)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add(esp8266_ns.setup_preferences())
 
     cg.add_platformio_option("lib_ldf_mode", "off")
@@ -506,7 +504,7 @@ ESP8266_EXCEPTION_CODES = {
 }
 
 
-def _decode_pc(config: ConfigType, addr: str) -> None:
+def _decode_pc(config, addr):
     from esphome.platformio import toolchain
 
     idedata = toolchain.get_idedata(config)
@@ -527,7 +525,7 @@ def _decode_pc(config: ConfigType, addr: str) -> None:
     _LOGGER.warning("Decoded %s", translation)
 
 
-def _parse_register(config: ConfigType, regex: re.Pattern[str], line: str) -> None:
+def _parse_register(config, regex, line):
     match = regex.match(line)
     if match is not None:
         _decode_pc(config, match.group(1))
@@ -551,7 +549,7 @@ STACKTRACE_BAD_ALLOC_RE = re.compile(
 STACKTRACE_ESP8266_BACKTRACE_PC_RE = re.compile(r"4[0-9a-f]{7}")
 
 
-def process_stacktrace(config: ConfigType, line: str, backtrace_state: bool) -> bool:
+def process_stacktrace(config, line, backtrace_state):
     line = line.strip()
     # ESP8266 Exception type
     match = re.match(STACKTRACE_ESP8266_EXCEPTION_TYPE_RE, line)

esphome/components/esp8266/crash_handler.cpp

@@ -118,6 +118,8 @@ static const LogString *get_exception_cause(uint32_t cause) {
 }
 
 static const LogString *get_reset_reason(uint32_t reason) {
+  if (reason == REASON_WDT_RST)
+    return LOG_STR("Hardware WDT");
   if (reason == REASON_EXCEPTION_RST)
     return LOG_STR("Exception");
   if (reason == REASON_SOFT_WDT_RST)
@@ -160,20 +162,13 @@ void crash_handler_log() {
   if (!is_crash_reason(resetInfo.reason))
     return;
 
-  ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
-  if (resetInfo.reason == REASON_WDT_RST) {
-    // A hardware WDT reset happens entirely in hardware: the postmortem hook
-    // never runs, so rst_info epc1/exccause and the RTC backtrace are
-    // leftovers from an earlier crash. Don't misattribute them (#18596).
-    ESP_LOGE(TAG, "  Reason: Hardware WDT (no crash state is recorded for hardware WDT resets)");
-    return;
-  }
-
   // Read and filter backtrace from RTC into stack-local buffer (no persistent RAM cost).
   // Both resetInfo and RTC data survive until the next reset, so this can be
   // called multiple times (logger init + API subscribe) with the same result.
   uint32_t backtrace[MAX_BACKTRACE];
   uint8_t bt_count = read_rtc_backtrace(backtrace, MAX_BACKTRACE);
+
+  ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
   // GCC's ROM divide routine triggers IllegalInstruction (exccause=0) at specific
   // ROM addresses instead of IntegerDivideByZero (exccause=6). Patch to match
   // the Arduino core's postmortem handler behavior.

esphome/components/esp8266/gpio.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 import logging
-from typing import Any
 
 from esphome import pins
 import esphome.codegen as cg
@@ -19,8 +18,6 @@ from esphome.const import (
     PLATFORM_ESP8266,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
 
 from . import boards
 from .const import KEY_BOARD, KEY_ESP8266, KEY_PIN_INITIAL_STATES, esp8266_ns
@@ -30,7 +27,7 @@ _LOGGER = logging.getLogger(__name__)
 ESP8266GPIOPin = esp8266_ns.class_("ESP8266GPIOPin", cg.InternalGPIOPin)
 
 
-def _lookup_pin(value: str) -> int:
+def _lookup_pin(value):
     board = CORE.data[KEY_ESP8266][KEY_BOARD]
     board_pins = boards.ESP8266_BOARD_PINS.get(board, {})
 
@@ -45,7 +42,7 @@ def _lookup_pin(value: str) -> int:
     raise cv.Invalid(f"Cannot resolve pin name '{value}' for board {board}.")
 
 
-def _translate_pin(value: Any) -> int:
+def _translate_pin(value):
     if isinstance(value, dict) or value is None:
         raise cv.Invalid(
             "This variable only supports pin numbers, not full pin schemas "
@@ -72,7 +69,7 @@ _ESP_SDIO_PINS = {
 }
 
 
-def validate_gpio_pin(value: Any) -> int:
+def validate_gpio_pin(value):
     value = _translate_pin(value)
     if value < 0 or value > 17:
         raise cv.Invalid(f"ESP8266: Invalid pin number: {value}")
@@ -89,7 +86,7 @@ def validate_gpio_pin(value: Any) -> int:
     return value
 
 
-def validate_supports(value: ConfigType) -> ConfigType:
+def validate_supports(value):
     num = value[CONF_NUMBER]
     mode = value[CONF_MODE]
     is_input = mode[CONF_INPUT]
@@ -163,7 +160,7 @@ class PinInitialState:
 
 
 @pins.PIN_SCHEMA_REGISTRY.register(PLATFORM_ESP8266, ESP8266_PIN_SCHEMA)
-async def esp8266_pin_to_code(config: ConfigType) -> MockObj:
+async def esp8266_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     mode = config[CONF_MODE]
@@ -195,7 +192,7 @@ async def esp8266_pin_to_code(config: ConfigType) -> MockObj:
 
 
 @coroutine_with_priority(CoroPriority.WORKAROUNDS)
-async def add_pin_initial_states_array() -> None:
+async def add_pin_initial_states_array():
     # Add includes at the very end, so that they override everything
     initial_states: list[PinInitialState] = CORE.data[KEY_ESP8266][
         KEY_PIN_INITIAL_STATES

esphome/components/esphome/ota/ota_esphome.cpp

@@ -588,6 +588,8 @@ bool ESPHomeOTAComponent::writeall_(const uint8_t *buf, size_t len) {
 }
 
 float ESPHomeOTAComponent::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
+uint16_t ESPHomeOTAComponent::get_port() const { return this->port_; }
+void ESPHomeOTAComponent::set_port(uint16_t port) { this->port_ = port; }
 
 void ESPHomeOTAComponent::log_socket_error_(const LogString *msg) {
   ESP_LOGW(TAG, "Socket %s: errno %d", LOG_STR_ARG(msg), errno);

esphome/components/esphome/ota/ota_esphome.h

@@ -39,14 +39,14 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
 #endif  // USE_OTA_PASSWORD
 
   /// Manually set the port OTA should listen on
-  void set_port(uint16_t port) { this->port_ = port; }
+  void set_port(uint16_t port);
 
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override;
   void loop() override;
 
-  uint16_t get_port() const { return this->port_; }
+  uint16_t get_port() const;
 
  protected:
   void handle_handshake_();

esphome/components/ethernet/ethernet_component.cpp

@@ -10,6 +10,14 @@ EthernetComponent *global_eth_component;  // NOLINT(cppcoreguidelines-avoid-non-
 
 EthernetComponent::EthernetComponent() { global_eth_component = this; }
 
+float EthernetComponent::get_setup_priority() const { return setup_priority::WIFI; }
+
+void EthernetComponent::set_type(EthernetType type) { this->type_ = type; }
+
+#ifdef USE_ETHERNET_MANUAL_IP
+void EthernetComponent::set_manual_ip(const ManualIP &manual_ip) { this->manual_ip_ = manual_ip; }
+#endif
+
 #ifdef USE_ETHERNET_IP_STATE_LISTENERS
 void EthernetComponent::notify_ip_state_listeners_() {
   auto ips = this->get_ip_addresses();

esphome/components/ethernet/ethernet_component.h

@@ -125,7 +125,7 @@ class EthernetComponent final : public Component {
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::ETHERNET; }
+  float get_setup_priority() const override;
   void on_powerdown() override { powerdown(); }
   bool is_connected() { return this->state_ == EthernetComponentState::CONNECTED; }
 
@@ -146,9 +146,9 @@ class EthernetComponent final : public Component {
   esp_netif_t *get_esp_netif() { return this->eth_netif_; }
 #endif
 
-  void set_type(EthernetType type) { this->type_ = type; }
+  void set_type(EthernetType type);
 #ifdef USE_ETHERNET_MANUAL_IP
-  void set_manual_ip(const ManualIP &manual_ip) { this->manual_ip_ = manual_ip; }
+  void set_manual_ip(const ManualIP &manual_ip);
 #endif
   void set_fixed_mac(const std::array<uint8_t, MAC_ADDRESS_SIZE> &mac) { this->fixed_mac_ = mac; }
 
@@ -171,35 +171,35 @@ class EthernetComponent final : public Component {
   esp_eth_handle_t get_eth_handle() const { return this->eth_handle_; }
 
 #ifdef USE_ETHERNET_SPI
-  void set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
-  void set_miso_pin(uint8_t miso_pin) { this->miso_pin_ = miso_pin; }
-  void set_mosi_pin(uint8_t mosi_pin) { this->mosi_pin_ = mosi_pin; }
-  void set_cs_pin(uint8_t cs_pin) { this->cs_pin_ = cs_pin; }
-  void set_interrupt_pin(uint8_t interrupt_pin) { this->interrupt_pin_ = interrupt_pin; }
-  void set_reset_pin(uint8_t reset_pin) { this->reset_pin_ = reset_pin; }
-  void set_clock_speed(int clock_speed) { this->clock_speed_ = clock_speed; }
-  void set_interface(spi_host_device_t interface) { this->interface_ = interface; }
+  void set_clk_pin(uint8_t clk_pin);
+  void set_miso_pin(uint8_t miso_pin);
+  void set_mosi_pin(uint8_t mosi_pin);
+  void set_cs_pin(uint8_t cs_pin);
+  void set_interrupt_pin(uint8_t interrupt_pin);
+  void set_reset_pin(uint8_t reset_pin);
+  void set_clock_speed(int clock_speed);
+  void set_interface(spi_host_device_t interface);
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
-  void set_polling_interval(uint32_t polling_interval) { this->polling_interval_ = polling_interval; }
+  void set_polling_interval(uint32_t polling_interval);
 #endif
 #else
-  void set_phy_addr(uint8_t phy_addr) { this->phy_addr_ = phy_addr; }
-  void set_power_pin(int power_pin) { this->power_pin_ = power_pin; }
-  void set_mdc_pin(uint8_t mdc_pin) { this->mdc_pin_ = mdc_pin; }
-  void set_mdio_pin(uint8_t mdio_pin) { this->mdio_pin_ = mdio_pin; }
-  void set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
-  void set_clk_mode(emac_rmii_clock_mode_t clk_mode) { this->clk_mode_ = clk_mode; }
+  void set_phy_addr(uint8_t phy_addr);
+  void set_power_pin(int power_pin);
+  void set_mdc_pin(uint8_t mdc_pin);
+  void set_mdio_pin(uint8_t mdio_pin);
+  void set_clk_pin(uint8_t clk_pin);
+  void set_clk_mode(emac_rmii_clock_mode_t clk_mode);
   void add_phy_register(PHYRegister register_value);
 #endif  // USE_ETHERNET_SPI
 #endif  // USE_ESP32
 
 #ifdef USE_RP2
-  void set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
-  void set_miso_pin(uint8_t miso_pin) { this->miso_pin_ = miso_pin; }
-  void set_mosi_pin(uint8_t mosi_pin) { this->mosi_pin_ = mosi_pin; }
-  void set_cs_pin(uint8_t cs_pin) { this->cs_pin_ = cs_pin; }
-  void set_interrupt_pin(int8_t interrupt_pin) { this->interrupt_pin_ = interrupt_pin; }
-  void set_reset_pin(int8_t reset_pin) { this->reset_pin_ = reset_pin; }
+  void set_clk_pin(uint8_t clk_pin);
+  void set_miso_pin(uint8_t miso_pin);
+  void set_mosi_pin(uint8_t mosi_pin);
+  void set_cs_pin(uint8_t cs_pin);
+  void set_interrupt_pin(int8_t interrupt_pin);
+  void set_reset_pin(int8_t reset_pin);
 #endif  // USE_RP2
 
 #ifdef USE_ETHERNET_IP_STATE_LISTENERS

esphome/components/ethernet/ethernet_component_esp32.cpp

@@ -908,7 +908,25 @@ void EthernetComponent::dump_connect_params_() {
 #endif /* USE_NETWORK_IPV6 */
 }
 
-#ifndef USE_ETHERNET_SPI
+#ifdef USE_ETHERNET_SPI
+void EthernetComponent::set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
+void EthernetComponent::set_miso_pin(uint8_t miso_pin) { this->miso_pin_ = miso_pin; }
+void EthernetComponent::set_mosi_pin(uint8_t mosi_pin) { this->mosi_pin_ = mosi_pin; }
+void EthernetComponent::set_cs_pin(uint8_t cs_pin) { this->cs_pin_ = cs_pin; }
+void EthernetComponent::set_interrupt_pin(uint8_t interrupt_pin) { this->interrupt_pin_ = interrupt_pin; }
+void EthernetComponent::set_reset_pin(uint8_t reset_pin) { this->reset_pin_ = reset_pin; }
+void EthernetComponent::set_clock_speed(int clock_speed) { this->clock_speed_ = clock_speed; }
+void EthernetComponent::set_interface(spi_host_device_t interface) { this->interface_ = interface; }
+#ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
+void EthernetComponent::set_polling_interval(uint32_t polling_interval) { this->polling_interval_ = polling_interval; }
+#endif
+#else
+void EthernetComponent::set_phy_addr(uint8_t phy_addr) { this->phy_addr_ = phy_addr; }
+void EthernetComponent::set_power_pin(int power_pin) { this->power_pin_ = power_pin; }
+void EthernetComponent::set_mdc_pin(uint8_t mdc_pin) { this->mdc_pin_ = mdc_pin; }
+void EthernetComponent::set_mdio_pin(uint8_t mdio_pin) { this->mdio_pin_ = mdio_pin; }
+void EthernetComponent::set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
+void EthernetComponent::set_clk_mode(emac_rmii_clock_mode_t clk_mode) { this->clk_mode_ = clk_mode; }
 void EthernetComponent::add_phy_register(PHYRegister register_value) { this->phy_registers_.push_back(register_value); }
 #endif
 

esphome/components/ethernet/ethernet_component_rp2.cpp

@@ -355,6 +355,13 @@ void EthernetComponent::dump_connect_params_() {
                 this->get_eth_mac_address_pretty_into_buffer(mac_buf));
 }
 
+void EthernetComponent::set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
+void EthernetComponent::set_miso_pin(uint8_t miso_pin) { this->miso_pin_ = miso_pin; }
+void EthernetComponent::set_mosi_pin(uint8_t mosi_pin) { this->mosi_pin_ = mosi_pin; }
+void EthernetComponent::set_cs_pin(uint8_t cs_pin) { this->cs_pin_ = cs_pin; }
+void EthernetComponent::set_interrupt_pin(int8_t interrupt_pin) { this->interrupt_pin_ = interrupt_pin; }
+void EthernetComponent::set_reset_pin(int8_t reset_pin) { this->reset_pin_ = reset_pin; }
+
 void EthernetComponent::enable() {
   // RP2040 uses arduino-pico's LwipIntfDev which manages link state internally;
   // there is no clean enable/disable hook today. The YAML option is accepted on

esphome/components/fan/fan.cpp

@@ -153,6 +153,11 @@ void FanRestoreState::apply(Fan &fan) {
   fan.publish_state();
 }
 
+FanCall Fan::turn_on() { return this->make_call().set_state(true); }
+FanCall Fan::turn_off() { return this->make_call().set_state(false); }
+FanCall Fan::toggle() { return this->make_call().set_state(!this->state); }
+FanCall Fan::make_call() { return FanCall(*this); }
+
 const char *Fan::find_preset_mode_(const char *preset_mode) {
   return this->find_preset_mode_(preset_mode, preset_mode ? strlen(preset_mode) : 0);
 }

esphome/components/fan/fan.h

@@ -115,10 +115,10 @@ class Fan : public EntityBase {
   /// The current direction of the fan
   FanDirection direction{FanDirection::FORWARD};
 
-  FanCall turn_on() { return this->make_call().set_state(true); }
-  FanCall turn_off() { return this->make_call().set_state(false); }
-  FanCall toggle() { return this->make_call().set_state(!this->state); }
-  FanCall make_call() { return FanCall(*this); }
+  FanCall turn_on();
+  FanCall turn_off();
+  FanCall toggle();
+  FanCall make_call();
 
   /// Register a callback that will be called each time the state changes.
   template<typename F> void add_on_state_callback(F &&callback) {

esphome/components/file/image.py

@@ -5,7 +5,6 @@ import io
 import logging
 from pathlib import Path
 import re
-from typing import Any
 
 from PIL import Image, UnidentifiedImageError
 
@@ -76,12 +75,12 @@ def compute_local_image_path(value: str | ConfigType) -> Path:
     return external_files.compute_local_file_path(DOMAIN, url)
 
 
-def local_path(value: str | ConfigType) -> str:
+def local_path(value):
     value = value[CONF_PATH] if isinstance(value, dict) else value
     return str(CORE.relative_config_path(value))
 
 
-def download_file(url: str, path: Path) -> str:
+def download_file(url, path):
     # The shared NETWORK_TIMEOUT applies; a per-caller timeout would be
     # silently ignored on a per-run memo hit anyway (memos key by path).
     external_files.download_content(url, path)
@@ -99,7 +98,7 @@ def download_gh_svg(value: str | ConfigType, source: str) -> str:
     return download_file(url, path)
 
 
-def download_image(value: str | ConfigType) -> str:
+def download_image(value):
     value = value[CONF_URL] if isinstance(value, dict) else value
     return download_file(value, compute_local_image_path(value))
 
@@ -147,7 +146,7 @@ def _extract_entry_ref(entry: ConfigType) -> RemoteFile | None:
 PREFETCH_FILES = external_files.single_stage_prefetch(_extract_entry_ref)
 
 
-def validate_file_shorthand(value: Any) -> str:
+def validate_file_shorthand(value):
     value = cv.string_strict(value)
     if (remote := _parse_remote_shorthand(value)) is not None:
         return download_file(remote.url, remote.path)
@@ -164,8 +163,8 @@ LOCAL_SCHEMA = cv.All(
 )
 
 
-def mdi_schema(source: str) -> cv.All:
-    def validate_mdi(value: ConfigType) -> str:
+def mdi_schema(source):
+    def validate_mdi(value):
         return download_gh_svg(value, source)
 
     return cv.All(
@@ -260,9 +259,7 @@ async def new_image(config: ConfigType) -> MockObj:
     return var
 
 
-async def write_image(
-    config: ConfigType, all_frames: bool = False
-) -> tuple[MockObj, int, int, MockObj, MockObj, int]:
+async def write_image(config, all_frames=False):
     path = Path(config[CONF_FILE])
     if not path.is_file():
         raise core.EsphomeError(f"Could not load image file {path}")

esphome/components/globals/__init__.py

@@ -8,8 +8,7 @@ from esphome.const import (
     CONF_TYPE,
     CONF_VALUE,
 )
-from esphome.core import ID, CoroPriority, coroutine_with_priority
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.core import CoroPriority, coroutine_with_priority
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@esphome/core"]
@@ -63,7 +62,7 @@ CONFIG_SCHEMA = _globals_schema
 
 # Run with low priority so that namespaces are registered first
 @coroutine_with_priority(CoroPriority.LATE)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     type_ = cg.RawExpression(config[CONF_TYPE])
     restore = config[CONF_RESTORE_VALUE]
 
@@ -105,12 +104,7 @@ async def to_code(config: ConfigType) -> None:
     ),
     synchronous=True,
 )
-async def globals_set_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def globals_set_to_code(config, action_id, template_arg, args):
     full_id, paren = await cg.get_variable_with_full_id(config[CONF_ID])
     template_arg = cg.TemplateArguments(full_id.type, *template_arg)
     var = cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/gpio/binary_sensor/__init__.py

@@ -12,7 +12,6 @@ from esphome.const import (
     CONF_PIN,
 )
 from esphome.core import CORE
-from esphome.types import ConfigType
 
 from .. import gpio_ns
 
@@ -69,7 +68,7 @@ def _pin_shared_only_with_deep_sleep(pin_num: int) -> bool:
     return any(path and path[0] == "deep_sleep" for path, _, _ in pin_users)
 
 
-def _final_validate(config: ConfigType) -> None:
+def _final_validate(config) -> None:
     use_interrupt = config[CONF_USE_INTERRUPT]
     if not use_interrupt:
         return
@@ -125,7 +124,7 @@ def _final_validate(config: ConfigType) -> None:
 FINAL_VALIDATE_SCHEMA = _final_validate
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = await binary_sensor.new_binary_sensor(config)
     await cg.register_component(var, config)
 

esphome/components/gpio/one_wire/__init__.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 from esphome.components.one_wire import OneWireBus
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_PIN
-from esphome.types import ConfigType
 
 from .. import gpio_ns
 
@@ -19,7 +18,7 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 

esphome/components/gpio/output/__init__.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 from esphome.components import output
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_PIN
-from esphome.types import ConfigType
 
 from .. import gpio_ns
 
@@ -17,7 +16,7 @@ CONFIG_SCHEMA = output.BINARY_OUTPUT_SCHEMA.extend(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await output.register_output(var, config)
     await cg.register_component(var, config)

esphome/components/gpio/switch/__init__.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import CONF_INTERLOCK, CONF_PIN
-from esphome.types import ConfigType
 
 from .. import gpio_ns
 
@@ -25,7 +24,7 @@ CONFIG_SCHEMA = (
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = await switch.new_switch(config)
     await cg.register_component(var, config)
 

esphome/components/homeassistant/__init__.py

@@ -1,19 +1,13 @@
-from collections.abc import Callable, Iterable
-
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ATTRIBUTE, CONF_ENTITY_ID, CONF_INTERNAL
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
 
 CODEOWNERS = ["@OttoWinter", "@esphome/core"]
 homeassistant_ns = cg.esphome_ns.namespace("homeassistant")
 
 
-def validate_entity_domain(
-    platform: str, supported_domains: Iterable[str]
-) -> Callable[[ConfigType], ConfigType]:
-    def validator(config: ConfigType) -> ConfigType:
+def validate_entity_domain(platform, supported_domains):
+    def validator(config):
         domain = config[CONF_ENTITY_ID].split(".", 1)[0]
         if domain not in supported_domains:
             raise cv.Invalid(
@@ -40,7 +34,7 @@ HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA = cv.Schema(
 )
 
 
-def setup_home_assistant_entity(var: MockObj, config: ConfigType) -> None:
+def setup_home_assistant_entity(var, config):
     cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))
     if CONF_ATTRIBUTE in config:
         cg.add(var.set_attribute(config[CONF_ATTRIBUTE]))

esphome/components/homeassistant/binary_sensor/__init__.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import binary_sensor
-from esphome.types import ConfigType
 
 from .. import (
     HOME_ASSISTANT_IMPORT_SCHEMA,
@@ -19,7 +18,7 @@ CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(HomeassistantBinarySensor).ex
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = await binary_sensor.new_binary_sensor(config)
     await cg.register_component(var, config)
     setup_home_assistant_entity(var, config)

esphome/components/homeassistant/number/__init__.py

@@ -1,7 +1,6 @@
 import esphome.codegen as cg
 from esphome.components import number
 import esphome.config_validation as cv
-from esphome.types import ConfigType
 
 from .. import (
     HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA,
@@ -23,7 +22,7 @@ CONFIG_SCHEMA = (
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     var = await number.new_number(
         config,

esphome/components/homeassistant/sensor/__init__.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import sensor
-from esphome.types import ConfigType
 
 from .. import (
     HOME_ASSISTANT_IMPORT_SCHEMA,
@@ -19,7 +18,7 @@ CONFIG_SCHEMA = sensor.sensor_schema(HomeassistantSensor, accuracy_decimals=1).e
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = await sensor.new_sensor(config)
     await cg.register_component(var, config)
     setup_home_assistant_entity(var, config)

esphome/components/homeassistant/switch/__init__.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
-from esphome.types import ConfigType
 
 from .. import (
     HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA,
@@ -37,7 +36,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/homeassistant/text_sensor/__init__.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import text_sensor
-from esphome.types import ConfigType
 
 from .. import (
     HOME_ASSISTANT_IMPORT_SCHEMA,
@@ -19,7 +18,7 @@ CONFIG_SCHEMA = text_sensor.text_sensor_schema(HomeassistantTextSensor).extend(
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = await text_sensor.new_text_sensor(config)
     await cg.register_component(var, config)
     setup_home_assistant_entity(var, config)

esphome/components/homeassistant/time/__init__.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import time as time_
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_TIMEZONE
-from esphome.types import ConfigType
 
 from .. import homeassistant_ns
 
@@ -17,7 +16,7 @@ CONFIG_SCHEMA = time_.TIME_SCHEMA.extend(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await time_.register_time(var, config)
     await cg.register_component(var, config)

esphome/components/host/__init__.py

@@ -11,7 +11,6 @@ from esphome.const import (
 )
 from esphome.core import CORE
 from esphome.platformio.toolchain import copy_ccache_script
-from esphome.types import ConfigType
 
 from .const import KEY_HOST
 
@@ -23,7 +22,7 @@ AUTO_LOAD = ["network", "preferences"]
 IS_TARGET_PLATFORM = True
 
 
-def set_core_data(config: ConfigType) -> ConfigType:
+def set_core_data(config):
     CORE.data[KEY_HOST] = {}
     CORE.data[KEY_CORE][KEY_TARGET_PLATFORM] = PLATFORM_HOST
     CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "host"
@@ -41,7 +40,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_build_flag("-DUSE_HOST")
     cg.add_define("USE_NATIVE_64BIT_TIME")
     # The prefs file finds stored preferences by key, so key migration is possible

esphome/components/host/gpio.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Any
 
 from esphome import pins
 import esphome.codegen as cg
@@ -15,8 +14,6 @@ from esphome.const import (
     CONF_PULLDOWN,
     CONF_PULLUP,
 )
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
 
 from .const import host_ns
 
@@ -25,7 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 HostGPIOPin = host_ns.class_("HostGPIOPin", cg.InternalGPIOPin)
 
 
-def _translate_pin(value: Any) -> int | str:
+def _translate_pin(value):
     if isinstance(value, dict) or value is None:
         raise cv.Invalid(
             "This variable only supports pin numbers, not full pin schemas "
@@ -44,7 +41,7 @@ def _translate_pin(value: Any) -> int | str:
     return value
 
 
-def validate_gpio_pin(value: Any) -> int | str:
+def validate_gpio_pin(value):
     return _translate_pin(value)
 
 
@@ -56,7 +53,7 @@ HOST_PIN_SCHEMA = pins.gpio_base_schema(
 
 
 @pins.PIN_SCHEMA_REGISTRY.register("host", HOST_PIN_SCHEMA)
-async def host_pin_to_code(config: ConfigType) -> MockObj:
+async def host_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     cg.add(var.set_pin(num))

esphome/components/host/time/__init__.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import time as time_
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
-from esphome.types import ConfigType
 
 CODEOWNERS = ["@clydebarrow"]
 
@@ -15,7 +14,7 @@ CONFIG_SCHEMA = time_.TIME_SCHEMA.extend(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await time_.register_time(var, config)

esphome/components/i2c/__init__.py

@@ -1,7 +1,6 @@
 import logging
 import re
 import sys
-from typing import Any
 
 from esphome import pins
 import esphome.codegen as cg
@@ -53,10 +52,9 @@ from esphome.const import (
     PLATFORM_RP2,
     PlatformFramework,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.cpp_generator import MockObj
 import esphome.final_validate as fv
-from esphome.types import ConfigType
 
 LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@esphome/core"]
@@ -98,13 +96,13 @@ CONF_SCL_PULLUP_ENABLED = "scl_pullup_enabled"
 MULTI_CONF = True
 
 
-def validate_device(value: str) -> str:
+def validate_device(value):
     if not re.match(r"^/(?:[^/]+/)*[^/]+$", value):
         raise cv.Invalid("Device must be an absolute device path (e.g., /dev/i2c-0)")
     return value
 
 
-def _bus_declare_type(value: Any) -> ID:
+def _bus_declare_type(value):
     if CORE.is_esp32:
         return cv.declare_id(IDFI2CBus)(value)
     if CORE.using_arduino:
@@ -116,7 +114,7 @@ def _bus_declare_type(value: Any) -> ID:
     raise NotImplementedError
 
 
-def _rp2040_i2c_controller(pin: int) -> int:
+def _rp2040_i2c_controller(pin):
     """Return the I2C controller number (0 or 1) for a given RP2040/RP2350 GPIO pin.
 
     See RP2040 datasheet Table 2 (section 1.4.3, "GPIO Functions"):
@@ -127,7 +125,7 @@ def _rp2040_i2c_controller(pin: int) -> int:
     return (pin // 2) % 2
 
 
-def validate_config(config: ConfigType) -> ConfigType:
+def validate_config(config):
     if CORE.is_esp32:
         return cv.require_framework_version(
             esp_idf=cv.Version(5, 4, 2), esp32_arduino=cv.Version(3, 2, 1)
@@ -144,7 +142,7 @@ def validate_config(config: ConfigType) -> ConfigType:
     return config
 
 
-def validate_host_config(config: ConfigType) -> ConfigType:
+def validate_host_config(config):
     if CORE.is_host:
         # Host I2C is currently only supported on Linux
         if not sys.platform.lower().startswith("linux"):
@@ -231,7 +229,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate(config: ConfigType) -> None:
+def _final_validate(config):
     full_config = fv.full_config.get()[CONF_I2C]
     if CORE.using_zephyr and len(full_config) > 1:
         raise cv.Invalid("Second i2c is not implemented on Zephyr yet")
@@ -283,7 +281,7 @@ FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 @coroutine_with_priority(CoroPriority.BUS)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_global(i2c_ns.using)
     cg.add_define("USE_I2C")
     if CORE.is_esp32:
@@ -360,7 +358,7 @@ async def to_code(config: ConfigType) -> None:
             cg.add(var.set_lp_mode(bool(config[CONF_LOW_POWER_MODE])))
 
 
-def i2c_device_schema(default_address: int | None) -> cv.Schema:
+def i2c_device_schema(default_address):
     """Create a schema for a i2c device.
 
     :param default_address: The default address of the i2c device, can be None to represent
@@ -377,7 +375,7 @@ def i2c_device_schema(default_address: int | None) -> cv.Schema:
     return cv.Schema(schema)
 
 
-async def register_i2c_device(var: MockObj, config: ConfigType) -> None:
+async def register_i2c_device(var, config):
     """Register an i2c device with the given config.
 
     Sets the i2c bus to use and the i2c address.
@@ -392,11 +390,11 @@ async def register_i2c_device(var: MockObj, config: ConfigType) -> None:
 def final_validate_device_schema(
     name: str,
     *,
-    min_frequency: Any = None,
-    max_frequency: Any = None,
-    min_timeout: Any = None,
-    max_timeout: Any = None,
-) -> cv.Schema:
+    min_frequency: cv.frequency = None,
+    max_frequency: cv.frequency = None,
+    min_timeout: cv.time_period = None,
+    max_timeout: cv.time_period = None,
+):
     hub_schema = {}
     if (min_frequency is not None) and (max_frequency is not None):
         hub_schema[cv.Required(CONF_FREQUENCY)] = cv.Range(

esphome/components/infrared/infrared.cpp

@@ -75,6 +75,8 @@ void Infrared::dump_config() {
                 YESNO(this->traits_.get_supports_receiver()));
 }
 
+InfraredCall Infrared::make_call() { return InfraredCall(this); }
+
 void Infrared::control(const InfraredCall &call) {
   if (this->transmitter_ == nullptr) {
     ESP_LOGW(TAG, "No transmitter configured");

esphome/components/infrared/infrared.h

@@ -134,7 +134,7 @@ class Infrared : public Component, public EntityBase, public remote_base::Remote
   const InfraredTraits &get_traits() const { return this->traits_; }
 
   /// Create a call object for transmitting
-  InfraredCall make_call() { return InfraredCall(this); }
+  InfraredCall make_call();
 
   /// Get capability flags for this infrared instance
   uint32_t get_capability_flags() const;

esphome/components/light/esp_range_view.cpp

@@ -13,6 +13,8 @@ ESPColorView ESPRangeView::operator[](int32_t index) const {
   index = interpret_index(index, this->size()) + this->begin_;
   return (*this->parent_)[index];
 }
+ESPRangeIterator ESPRangeView::begin() { return {*this, this->begin_}; }
+ESPRangeIterator ESPRangeView::end() { return {*this, this->end_}; }
 
 void ESPRangeView::set(const Color &color) {
   for (int32_t i = this->begin_; i < this->end_; i++) {

esphome/components/light/esp_range_view.h

@@ -75,7 +75,4 @@ class ESPRangeIterator {
   int32_t i_;
 };
 
-inline ESPRangeIterator ESPRangeView::begin() { return {*this, this->begin_}; }
-inline ESPRangeIterator ESPRangeView::end() { return {*this, this->end_}; }
-
 }  // namespace esphome::light

esphome/components/light/light_state.cpp

@@ -157,6 +157,8 @@ void LightState::loop() {
   }
 }
 
+float LightState::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
+
 void LightState::publish_state() {
   if (this->remote_values_listeners_) {
     for (auto *listener : *this->remote_values_listeners_) {
@@ -192,11 +194,25 @@ void LightState::add_target_state_reached_listener(LightTargetStateReachedListen
   this->target_state_reached_listeners_->push_back(listener);
 }
 
+void LightState::set_default_transition_length(uint32_t default_transition_length) {
+  this->default_transition_length_ = default_transition_length;
+}
+uint32_t LightState::get_default_transition_length() const { return this->default_transition_length_; }
+void LightState::set_flash_transition_length(uint32_t flash_transition_length) {
+  this->flash_transition_length_ = flash_transition_length;
+}
+uint32_t LightState::get_flash_transition_length() const { return this->flash_transition_length_; }
+void LightState::set_gamma_correct(float gamma_correct) { this->gamma_correct_ = gamma_correct; }
+void LightState::set_restore_mode(LightRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
+void LightState::set_initial_state(void (*callback)(LightStateRTCState &)) { this->initial_state_callback_ = callback; }
+bool LightState::supports_effects() { return !this->effects_.empty(); }
+const FixedVector<LightEffect *> &LightState::get_effects() const { return this->effects_; }
 void LightState::add_effects(const std::initializer_list<LightEffect *> &effects) {
   // Called once from Python codegen during setup with all effects from YAML config
   this->effects_ = effects;
 }
 
+void LightState::current_values_as_binary(bool *binary) { this->current_values.as_binary(binary); }
 void LightState::current_values_as_brightness(float *brightness) {
   this->current_values.as_brightness(brightness);
   *brightness = this->gamma_correct_lut(*brightness);
@@ -317,6 +333,8 @@ float LightState::gamma_uncorrect_lut(float value) const {
 }
 #endif  // USE_LIGHT_GAMMA_LUT
 
+bool LightState::is_transformer_active() { return this->is_transformer_active_; }
+
 void LightState::start_effect_(uint32_t effect_index) {
   this->stop_effect_();
   if (effect_index == 0)

esphome/components/light/light_state.h

@@ -109,7 +109,7 @@ class LightState : public EntityBase, public Component {
   void dump_config() override;
   void loop() override;
   /// Shortly after HARDWARE.
-  float get_setup_priority() const override { return setup_priority::HARDWARE - 1.0f; }
+  float get_setup_priority() const override;
 
   /** The current values of the light as outputted to the light.
    *
@@ -157,19 +157,15 @@ class LightState : public EntityBase, public Component {
   void add_target_state_reached_listener(LightTargetStateReachedListener *listener);
 
   /// Set the default transition length, i.e. the transition length when no transition is provided.
-  void set_default_transition_length(uint32_t default_transition_length) {
-    this->default_transition_length_ = default_transition_length;
-  }
-  uint32_t get_default_transition_length() const { return this->default_transition_length_; }
+  void set_default_transition_length(uint32_t default_transition_length);
+  uint32_t get_default_transition_length() const;
 
   /// Set the flash transition length
-  void set_flash_transition_length(uint32_t flash_transition_length) {
-    this->flash_transition_length_ = flash_transition_length;
-  }
-  uint32_t get_flash_transition_length() const { return this->flash_transition_length_; }
+  void set_flash_transition_length(uint32_t flash_transition_length);
+  uint32_t get_flash_transition_length() const;
 
   /// Set the gamma correction factor
-  void set_gamma_correct(float gamma_correct) { this->gamma_correct_ = gamma_correct; }
+  void set_gamma_correct(float gamma_correct);
   float get_gamma_correct() const { return this->gamma_correct_; }
 
 #ifdef USE_LIGHT_GAMMA_LUT
@@ -190,17 +186,17 @@ class LightState : public EntityBase, public Component {
 #endif  // USE_LIGHT_GAMMA_LUT
 
   /// Set the restore mode of this light
-  void set_restore_mode(LightRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
+  void set_restore_mode(LightRestoreMode restore_mode);
 
   /// Set a callback to populate the initial state defaults during setup.
   /// The callback is called once, then cleared. Values live in flash as code.
-  void set_initial_state(void (*callback)(LightStateRTCState &)) { this->initial_state_callback_ = callback; }
+  void set_initial_state(void (*callback)(LightStateRTCState &));
 
   /// Return whether the light has any effects that meet the trait requirements.
-  bool supports_effects() const { return !this->effects_.empty(); }
+  bool supports_effects();
 
   /// Get all effects for this light state.
-  const FixedVector<LightEffect *> &get_effects() const { return this->effects_; }
+  const FixedVector<LightEffect *> &get_effects() const;
 
   /// Add effects for this light state.
   void add_effects(const std::initializer_list<LightEffect *> &effects);
@@ -258,7 +254,7 @@ class LightState : public EntityBase, public Component {
   }
 
   /// The result of all the current_values_as_* methods have gamma correction applied.
-  void current_values_as_binary(bool *binary) { this->current_values.as_binary(binary); }
+  void current_values_as_binary(bool *binary);
 
   void current_values_as_brightness(float *brightness);
 
@@ -285,7 +281,7 @@ class LightState : public EntityBase, public Component {
    *   return;
    * }
    */
-  bool is_transformer_active() const { return this->is_transformer_active_; }
+  bool is_transformer_active();
 
  protected:
   friend LightOutput;

esphome/components/lock/__init__.py

@@ -12,14 +12,13 @@ from esphome.const import (
     CONF_ON_UNLOCK,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+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.cpp_generator import MockObj, MockObjClass, TemplateArgsType
-from esphome.types import ConfigType, SafeExpType
+from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@esphome/core"]
 IS_PLATFORM_COMPONENT = True
@@ -103,7 +102,7 @@ _CALLBACK_AUTOMATIONS = (
 
 
 @setup_entity("lock")
-async def _setup_lock_core(var: MockObj, config: ConfigType) -> None:
+async def _setup_lock_core(var, config):
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
     if mqtt_id := config.get(CONF_MQTT_ID):
@@ -114,7 +113,7 @@ async def _setup_lock_core(var: MockObj, config: ConfigType) -> None:
         await web_server.add_entity_config(var, web_server_config)
 
 
-async def register_lock(var: MockObj, config: ConfigType) -> None:
+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)
@@ -122,7 +121,7 @@ async def register_lock(var: MockObj, config: ConfigType) -> None:
     await _setup_lock_core(var, config)
 
 
-async def new_lock(config: ConfigType, *args: SafeExpType) -> MockObj:
+async def new_lock(config, *args):
     var = cg.new_Pvariable(config[CONF_ID], *args)
     await register_lock(var, config)
     return var
@@ -144,38 +143,23 @@ LOCK_ACTION_SCHEMA = maybe_simple_id(
 @automation.register_action(
     "lock.open", OpenAction, LOCK_ACTION_SCHEMA, synchronous=True
 )
-async def lock_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def lock_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
 
 
 @automation.register_condition("lock.is_locked", LockCondition, LOCK_ACTION_SCHEMA)
-async def lock_is_on_to_code(
-    config: ConfigType,
-    condition_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def lock_is_on_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(condition_id, template_arg, paren, True)
 
 
 @automation.register_condition("lock.is_unlocked", LockCondition, LOCK_ACTION_SCHEMA)
-async def lock_is_off_to_code(
-    config: ConfigType,
-    condition_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def lock_is_off_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
 @coroutine_with_priority(CoroPriority.CORE)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     cg.add_global(lock_ns.using)

esphome/components/logger/logger.cpp

@@ -201,10 +201,17 @@ void Logger::process_messages_() {
 #endif  // USE_ESPHOME_TASK_LOG_BUFFER
 }
 
+void Logger::set_baud_rate(uint32_t baud_rate) { this->baud_rate_ = baud_rate; }
 #ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
 void Logger::set_log_level(const char *tag, uint8_t log_level) { this->log_levels_[tag] = log_level; }
 #endif
 
+#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
+UARTSelection Logger::get_uart() const { return this->uart_; }
+#endif
+
+float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
+
 // Log level strings - packed into flash on ESP8266, indexed by log level (0-7)
 PROGMEM_STRING_TABLE(LogLevelStrings, "NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE");
 

esphome/components/logger/logger.h

@@ -148,7 +148,7 @@ class Logger final : public Component {
   void loop() override;
 #endif
   /// Manually set the baud rate for serial, set to 0 to disable.
-  void set_baud_rate(uint32_t baud_rate) { this->baud_rate_ = baud_rate; }
+  void set_baud_rate(uint32_t baud_rate);
   uint32_t get_baud_rate() const { return baud_rate_; }
 #if defined(USE_ARDUINO) && !defined(USE_ESP32)
   Stream *get_hw_serial() const { return hw_serial_; }
@@ -163,7 +163,7 @@ class Logger final : public Component {
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
   void set_uart_selection(UARTSelection uart_selection) { uart_ = uart_selection; }
   /// Get the UART used by the logger.
-  UARTSelection get_uart() const { return this->uart_; }
+  UARTSelection get_uart() const;
 #endif
 
   /// Set the default log level for this logger.
@@ -197,7 +197,7 @@ class Logger final : public Component {
   void add_level_listener(LoggerLevelListener *listener) { this->level_listeners_.push_back(listener); }
 #endif
 
-  float get_setup_priority() const override { return setup_priority::BUS + 500.0f; }
+  float get_setup_priority() const override;
 
   void log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args);  // NOLINT
 #ifdef USE_STORE_LOG_STR_IN_FLASH

esphome/components/mitsubishi_cn105/__init__.py

@@ -8,7 +8,6 @@ from esphome.const import (
     CONF_ON_STATE,
     CONF_TEMPERATURE,
     CONF_UPDATE_INTERVAL,
-    CONF_USE_FAHRENHEIT,
 )
 from esphome.core import ID, Lambda
 from esphome.cpp_generator import LambdaExpression, MockObj
@@ -72,7 +71,6 @@ CONFIG_SCHEMA = (
             cv.Optional(
                 CONF_TELEMETRY_REQUEST_MIN_INTERVAL, default="60s"
             ): cv.update_interval,
-            cv.Optional(CONF_USE_FAHRENHEIT, default=False): cv.boolean,
             cv.Optional(CONF_VANE): cv.Schema(
                 {
                     cv.Optional(CONF_ON_STATE): automation.validate_automation({}),
@@ -116,7 +114,6 @@ async def to_code(config: ConfigType) -> None:
             config[CONF_TELEMETRY_REQUEST_MIN_INTERVAL]
         )
     )
-    cg.add(var.set_use_fahrenheit(config[CONF_USE_FAHRENHEIT]))
     if on_state := config.get(CONF_VANE, {}).get(CONF_ON_STATE):
         cg.add_global(mitsubishi_ns.using)
         for conf in on_state:

esphome/components/mitsubishi_cn105/mitsubishi_cn105.h

@@ -83,7 +83,6 @@ class MitsubishiCN105 {
     return this->is_telemetry_polling_enabled() ? !std::isnan(this->status_.room_temperature)
                                                 : !std::isnan(this->status_.target_temperature);
   }
-  bool is_temperature_encoding_b() const { return this->property_context_.use_temperature_encoding_b; }
 
   void set_power(bool power_on);
   void set_target_temperature(float target_temperature);

esphome/components/mitsubishi_cn105/mitsubishi_cn105_climate.cpp

@@ -50,11 +50,7 @@ static constexpr std::optional<Left> reverse_map_lookup(const std::array<std::pa
   return key.has_value() ? reverse_map_lookup(map, *key) : std::nullopt;
 }
 
-void MitsubishiCN105Climate::dump_config() {
-  LOG_CLIMATE("", "Mitsubishi CN105 Climate", this);
-  ESP_LOGCONFIG(TAG, "  Temperature unit: °%c",
-                this->parent_->get_temperature_mapping().get_use_fahrenheit() ? 'F' : 'C');
-}
+void MitsubishiCN105Climate::dump_config() { LOG_CLIMATE("", "Mitsubishi CN105 Climate", this); }
 
 void MitsubishiCN105Climate::setup() {
   this->parent_->add_on_status_callback([this]() { this->apply_values_(); });
@@ -76,15 +72,13 @@ climate::ClimateTraits MitsubishiCN105Climate::traits() {
 
   traits.set_supported_swing_modes(this->supported_swing_modes_);
 
-  const bool use_fahrenheit = this->parent_->get_temperature_mapping().get_use_fahrenheit();
-  traits.set_temperature_unit(use_fahrenheit ? TemperatureUnit::FAHRENHEIT : TemperatureUnit::CELSIUS);
-  traits.set_visual_min_temperature(use_fahrenheit ? 61.0f : 16.0f);
-  traits.set_visual_max_temperature(use_fahrenheit ? 88.0f : 31.0f);
+  traits.set_visual_min_temperature(16.0f);
+  traits.set_visual_max_temperature(31.0f);
   traits.set_visual_temperature_step(1.0f);
 
   if (this->parent_->is_telemetry_polling_enabled()) {
     traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
-    traits.set_visual_current_temperature_step(use_fahrenheit ? 1.0f : 0.5f);
+    traits.set_visual_current_temperature_step(0.5f);
   }
 
   return traits;
@@ -92,7 +86,7 @@ climate::ClimateTraits MitsubishiCN105Climate::traits() {
 
 void MitsubishiCN105Climate::control(const climate::ClimateCall &call) {
   if (const auto target_temperature = call.get_target_temperature()) {
-    this->parent_->set_target_temperature(this->parent_->get_temperature_mapping().to_mitsubishi(*target_temperature));
+    this->parent_->set_target_temperature(*target_temperature);
   }
 
   if (const auto mode = call.get_mode()) {
@@ -145,10 +139,10 @@ void MitsubishiCN105Climate::control(const climate::ClimateCall &call) {
 void MitsubishiCN105Climate::apply_values_() {
   const auto &status = this->parent_->status();
 
-  this->target_temperature = this->parent_->get_temperature_mapping().from_mitsubishi(status.target_temperature);
+  this->target_temperature = status.target_temperature;
 
   if (this->parent_->is_telemetry_polling_enabled()) {
-    this->current_temperature = this->parent_->get_temperature_mapping().from_mitsubishi(status.room_temperature);
+    this->current_temperature = status.room_temperature;
   }
 
   if (status.power_on) {

esphome/components/mitsubishi_cn105/mitsubishi_cn105_component.cpp

@@ -27,13 +27,6 @@ void MitsubishiCN105Component::setup() { this->hp_.initialize(); }
 
 void MitsubishiCN105Component::loop() {
   if (this->hp_.update()) {
-    // Encoding A only supports whole °C values and cannot represent native °F setpoints accurately.
-    // See https://github.com/esphome/esphome/pull/15488#issuecomment-5268304343
-    if (this->temperature_mapping_.get_use_fahrenheit() && !this->hp_.is_temperature_encoding_b()) {
-      ESP_LOGE(TAG, "Unit reports encoding A, which cannot accurately convert °F setpoints; disable 'use_fahrenheit'");
-      this->mark_failed();
-      return;
-    }
     this->notify_status_listeners_();
   }
 }

esphome/components/mitsubishi_cn105/mitsubishi_cn105_component.h

@@ -3,43 +3,13 @@
 #include "mitsubishi_cn105.h"
 
 #include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
 #include "esphome/components/uart/uart.h"
 
-#include <algorithm>
-#include <cmath>
-#include <optional>
 #include <utility>
+#include <optional>
 
 namespace esphome::mitsubishi_cn105 {
 
-struct TemperatureMapping {
-  float to_mitsubishi(float value) const {
-    if (!this->use_fahrenheit_) {
-      return value;
-    }
-    const int fahrenheit = std::clamp(static_cast<int>(std::round(value)), 61, 88);
-    return 0.5f * (fahrenheit - 28 + (fahrenheit > 68) - (fahrenheit < 68));
-  }
-
-  float from_mitsubishi(float value) const {
-    if (!this->use_fahrenheit_) {
-      return value;
-    }
-    if (value < 16.0f || value > 30.5f) {
-      return celsius_to_fahrenheit(value);
-    }
-    const int mitsubishi_half_degrees = static_cast<int>(std::round(value * 2.0f));
-    return mitsubishi_half_degrees + 29 - (mitsubishi_half_degrees >= 40) - (mitsubishi_half_degrees > 40);
-  }
-
-  bool get_use_fahrenheit() const { return this->use_fahrenheit_; }
-  void set_use_fahrenheit(bool value) { this->use_fahrenheit_ = value; }
-
- protected:
-  bool use_fahrenheit_{false};
-};
-
 enum VerticalVaneMode : uint8_t {
   VERTICAL_VANE_MODE_AUTO = static_cast<uint8_t>(MitsubishiCN105::VaneMode::AUTO),
   VERTICAL_VANE_MODE_POSITION_1 = static_cast<uint8_t>(MitsubishiCN105::VaneMode::POSITION_1),
@@ -90,7 +60,6 @@ class MitsubishiCN105Component : public Component, public uart::UARTDevice {
 
   void set_update_interval(uint32_t ms) { this->hp_.set_update_interval(ms); }
   void set_telemetry_request_min_interval(uint32_t ms) { this->hp_.set_telemetry_request_min_interval(ms); }
-  void set_use_fahrenheit(bool value) { this->temperature_mapping_.set_use_fahrenheit(value); }
 
   void set_remote_temperature(float temperature) { this->hp_.set_remote_temperature(temperature); }
   void clear_remote_temperature() { this->hp_.clear_remote_temperature(); }
@@ -106,7 +75,6 @@ class MitsubishiCN105Component : public Component, public uart::UARTDevice {
   const MitsubishiCN105::Status &status() const { return this->hp_.status(); }
   bool is_status_initialized() const { return this->hp_.is_status_initialized(); }
   bool is_telemetry_polling_enabled() const { return this->hp_.is_telemetry_polling_enabled(); }
-  const TemperatureMapping &get_temperature_mapping() const { return this->temperature_mapping_; }
 
   template<typename F> void add_on_status_callback(F &&callback) {
     this->status_callback_.add(std::forward<F>(callback));
@@ -131,7 +99,6 @@ class MitsubishiCN105Component : public Component, public uart::UARTDevice {
   }
 
   MitsubishiCN105 hp_;
-  TemperatureMapping temperature_mapping_;
   CallbackManager<void()> status_callback_;
   LazyCallbackManager<void(const VaneState &)> vane_state_callback_;
 };

esphome/components/mqtt/mqtt_client.cpp

@@ -668,7 +668,9 @@ void MQTTClientComponent::on_message(const std::string &topic, const std::string
 // Setters
 void MQTTClientComponent::disable_log_message() { this->log_message_.topic = ""; }
 bool MQTTClientComponent::is_log_message_enabled() const { return !this->log_message_.topic.empty(); }
+void MQTTClientComponent::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
 void MQTTClientComponent::register_mqtt_component(MQTTComponent *component) { this->children_.push_back(component); }
+void MQTTClientComponent::set_log_level(int level) { this->log_level_ = level; }
 void MQTTClientComponent::set_keep_alive(uint16_t keep_alive_s) { this->mqtt_backend_.set_keep_alive(keep_alive_s); }
 void MQTTClientComponent::set_log_message_template(MQTTMessage &&message) { this->log_message_ = std::move(message); }
 const MQTTDiscoveryInfo &MQTTClientComponent::get_discovery_info() const { return this->discovery_info_; }
@@ -681,6 +683,10 @@ void MQTTClientComponent::set_topic_prefix(const std::string &topic_prefix, cons
   }
 }
 const std::string &MQTTClientComponent::get_topic_prefix() const { return this->topic_prefix_; }
+void MQTTClientComponent::set_publish_nan_as_none(bool publish_nan_as_none) {
+  this->publish_nan_as_none_ = publish_nan_as_none;
+}
+bool MQTTClientComponent::is_publish_nan_as_none() const { return this->publish_nan_as_none_; }
 void MQTTClientComponent::disable_birth_message() {
   this->birth_message_.topic = "";
   this->recalculate_availability_();
@@ -760,6 +766,8 @@ MQTTClientComponent *global_mqtt_client = nullptr;  // NOLINT(cppcoreguidelines-
 
 // MQTTMessageTrigger
 MQTTMessageTrigger::MQTTMessageTrigger(std::string topic) : topic_(std::move(topic)) {}
+void MQTTMessageTrigger::set_qos(uint8_t qos) { this->qos_ = qos; }
+void MQTTMessageTrigger::set_payload(const std::string &payload) { this->payload_ = payload; }
 void MQTTMessageTrigger::setup() {
   global_mqtt_client->subscribe(
       this->topic_,

esphome/components/mqtt/mqtt_client.h

@@ -159,7 +159,7 @@ class MQTTClientComponent final : public Component {
 
   /// Manually set the topic used for logging.
   void set_log_message_template(MQTTMessage &&message);
-  void set_log_level(int level) { this->log_level_ = level; }
+  void set_log_level(int level);
   /// Get the topic used for logging. Defaults to "<topic_prefix>/debug" and the value is cached for speed.
   void disable_log_message();
   bool is_log_message_enabled() const;
@@ -241,7 +241,7 @@ class MQTTClientComponent final : public Component {
 
   void check_connected();
 
-  void set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
+  void set_reboot_timeout(uint32_t reboot_timeout);
 
   void register_mqtt_component(MQTTComponent *component);
 
@@ -262,8 +262,8 @@ class MQTTClientComponent final : public Component {
   void set_on_disconnect(mqtt_on_disconnect_callback_t &&callback);
 
   // Publish None state instead of NaN for Home Assistant
-  void set_publish_nan_as_none(bool publish_nan_as_none) { this->publish_nan_as_none_ = publish_nan_as_none; }
-  bool is_publish_nan_as_none() const { return this->publish_nan_as_none_; }
+  void set_publish_nan_as_none(bool publish_nan_as_none);
+  bool is_publish_nan_as_none() const;
 
   void set_wait_for_connection(bool wait_for_connection) { this->wait_for_connection_ = wait_for_connection; }
 
@@ -344,8 +344,8 @@ class MQTTMessageTrigger final : public Trigger<std::string>, public Component {
  public:
   explicit MQTTMessageTrigger(std::string topic);
 
-  void set_qos(uint8_t qos) { this->qos_ = qos; }
-  void set_payload(const std::string &payload) { this->payload_ = payload; }
+  void set_qos(uint8_t qos);
+  void set_payload(const std::string &payload);
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override;

esphome/components/mqtt/mqtt_climate.cpp

@@ -118,7 +118,8 @@ void MQTTClimateComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryCo
   root[MQTT_TARGET_TEMPERATURE_STEP] = roundf(traits.get_visual_target_temperature_step() * 10) * 0.1f;
   // current_temp_step
   root[MQTT_CURRENT_TEMPERATURE_STEP] = roundf(traits.get_visual_current_temperature_step() * 10) * 0.1f;
-  root[MQTT_TEMPERATURE_UNIT] = traits.get_temperature_unit() == TemperatureUnit::FAHRENHEIT ? "F" : "C";
+  // temperature units are always coerced to Celsius internally
+  root[MQTT_TEMPERATURE_UNIT] = "C";
 
   // min_humidity
   root[MQTT_MIN_HUMIDITY] = traits.get_visual_min_humidity();

esphome/components/mqtt/mqtt_component.cpp

@@ -340,6 +340,10 @@ bool MQTTComponent::send_discovery_() {
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
+uint8_t MQTTComponent::get_qos() const { return this->qos_; }
+
+bool MQTTComponent::get_retain() const { return this->retain_; }
+
 bool MQTTComponent::is_discovery_enabled() const {
   return this->discovery_enabled_ && global_mqtt_client->is_discovery_enabled();
 }

esphome/components/mqtt/mqtt_component.h

@@ -108,11 +108,11 @@ class MQTTComponent : public Component {
 
   /// Set QOS for state messages.
   void set_qos(uint8_t qos);
-  uint8_t get_qos() const { return this->qos_; }
+  uint8_t get_qos() const;
 
   /// Set whether state message should be retained.
   void set_retain(bool retain);
-  bool get_retain() const { return this->retain_; }
+  bool get_retain() const;
 
   /// Disable discovery. Sets friendly name to "".
   void disable_discovery();

esphome/components/mqtt/mqtt_sensor.cpp

@@ -39,6 +39,8 @@ uint32_t MQTTSensorComponent::get_expire_after() const {
     return *this->expire_after_;
   return 0;
 }
+void MQTTSensorComponent::set_expire_after(uint32_t expire_after) { this->expire_after_ = expire_after; }
+void MQTTSensorComponent::disable_expire_after() { this->expire_after_ = 0; }
 
 void MQTTSensorComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson

esphome/components/mqtt/mqtt_sensor.h

@@ -22,9 +22,9 @@ class MQTTSensorComponent final : public mqtt::MQTTComponent {
   explicit MQTTSensorComponent(sensor::Sensor *sensor);
 
   /// Setup an expiry, 0 disables it
-  void set_expire_after(uint32_t expire_after) { this->expire_after_ = expire_after; }
+  void set_expire_after(uint32_t expire_after);
   /// Disable Home Assistant value expiry.
-  void disable_expire_after() { this->expire_after_ = 0; }
+  void disable_expire_after();
 
   void send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) override;
 

esphome/components/radio_frequency/radio_frequency.cpp

@@ -81,6 +81,8 @@ void RadioFrequency::dump_config() {
   }
 }
 
+RadioFrequencyCall RadioFrequency::make_call() { return RadioFrequencyCall(this); }
+
 uint32_t RadioFrequency::get_capability_flags() const {
   uint32_t flags = 0;
   if (this->traits_.get_supports_transmitter())

esphome/components/radio_frequency/radio_frequency.h

@@ -157,7 +157,7 @@ class RadioFrequency : public Component, public EntityBase, public remote_base::
   const RadioFrequencyTraits &get_traits() const { return this->traits_; }
 
   /// Create a call object for transmitting
-  RadioFrequencyCall make_call() { return RadioFrequencyCall(this); }
+  RadioFrequencyCall make_call();
 
   /// Get capability flags for this radio frequency instance
   uint32_t get_capability_flags() const;

esphome/components/remote_transmitter/__init__.py

@@ -185,14 +185,12 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
         },
-        "remote_transmitter_rtl87xx.cpp": {
-            PlatformFramework.RTL87XX_ARDUINO,
-        },
         "remote_transmitter.cpp": {
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
             PlatformFramework.ESP8266_ARDUINO,
             PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
             PlatformFramework.LN882X_ARDUINO,
             PlatformFramework.RP2_ARDUINO,
         },

esphome/components/remote_transmitter/remote_transmitter.cpp

@@ -2,8 +2,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 
-#if (defined(USE_LIBRETINY) && !defined(USE_RTL87XX)) || defined(USE_ESP8266) || defined(USE_RP2) || \
-    (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
+#if defined(USE_LIBRETINY) || defined(USE_ESP8266) || defined(USE_RP2) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
 
 namespace esphome::remote_transmitter {
 
@@ -82,37 +81,25 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   ESP_LOGD(TAG, "Sending remote code");
   uint32_t on_time, off_time;
   this->calculate_on_off_time_(this->temp_.get_carrier_frequency(), &on_time, &off_time);
+  this->target_time_ = 0;
   this->transmit_trigger_.trigger();
   for (uint32_t i = 0; i < send_times; i++) {
-    {
-      InterruptLock lock;
-      // Re-anchor every iteration: timing must never span a lock boundary, as micros() can
-      // jump when interrupts are re-enabled between repeats (e.g. LibreTiny's Beken micros()
-      // discards its interrupt-lock correction, stretching the repeat gap by the lock duration)
-      this->target_time_ = 0;
-      for (int32_t item : this->temp_.get_data()) {
-        if (item > 0) {
-          const auto length = uint32_t(item);
-          this->mark_(on_time, off_time, length);
-        } else {
-          const auto length = uint32_t(-item);
-          this->space_(length);
-        }
-        App.feed_wdt();
+    InterruptLock lock;
+    for (int32_t item : this->temp_.get_data()) {
+      if (item > 0) {
+        const auto length = uint32_t(item);
+        this->mark_(on_time, off_time, length);
+      } else {
+        const auto length = uint32_t(-item);
+        this->space_(length);
       }
-      this->await_target_time_();  // wait for duration of last pulse
-      this->pin_->digital_write(false);
+      App.feed_wdt();
     }
+    this->await_target_time_();  // wait for duration of last pulse
+    this->pin_->digital_write(false);
 
-    if (i + 1 < send_times) {
-      // Wait out the repeat gap with interrupts enabled: wait_time is unbounded user config
-      // (previously this spin ran inside the next iteration's lock, disabling interrupts for
-      // the whole gap). Anchoring after the lock release keeps it exact on all platforms.
-      const uint32_t gap_end = micros() + send_wait;
-      while ((int32_t) (gap_end - micros()) > 0) {
-        App.feed_wdt();
-      }
-    }
+    if (i + 1 < send_times)
+      this->target_time_ += send_wait;
   }
   this->complete_trigger_.trigger();
 }

esphome/components/remote_transmitter/remote_transmitter.h

@@ -65,21 +65,14 @@ class RemoteTransmitterComponent final : public remote_base::RemoteTransmitterBa
  protected:
   void send_internal(uint32_t send_times, uint32_t send_wait) override;
 #if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
-  void await_target_time_();
-  uint32_t target_time_{0};
-#endif
-#if defined(USE_ESP8266) || (defined(USE_LIBRETINY) && !defined(USE_RTL87XX)) || defined(USE_RP2) || \
-    (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
   void calculate_on_off_time_(uint32_t carrier_frequency, uint32_t *on_time_period, uint32_t *off_time_period);
 
   void mark_(uint32_t on_time, uint32_t off_time, uint32_t usec);
 
   void space_(uint32_t usec);
-#endif
-#ifdef USE_RTL87XX
-  // Carrier frequency the PWM is currently configured for; 0 = not yet configured
-  uint32_t current_carrier_frequency_{0};
-  void *pwm_{nullptr};  // pwmout_t*, opaque here to keep the SDK header out of this shared header
+
+  void await_target_time_();
+  uint32_t target_time_;
 #endif
 
 #if defined(USE_ESP32) && SOC_RMT_SUPPORTED

esphome/components/remote_transmitter/remote_transmitter_rtl87xx.cpp

@@ -1,137 +0,0 @@
-#include "remote_transmitter.h"
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-
-// clang-tidy cannot parse the Realtek SDK headers pulled in via ArduinoPrivate.h
-#if defined(USE_RTL87XX) && !defined(CLANG_TIDY)
-
-// ArduinoPrivate.h = Arduino.h + the SDK's mbed HAL (pwmout etc.) with the core's fixes for
-// type-name collisions between the two (e.g. PinMode)
-#include <ArduinoPrivate.h>
-#include <FreeRTOS.h>
-#include <task.h>
-
-namespace esphome::remote_transmitter {
-
-static const char *const TAG = "remote_transmitter";
-
-// The carrier is generated by the PWM peripheral instead of bit-banging the pin: software carrier
-// generation requires disabling interrupts for the whole frame, but this core's micros() is derived
-// from the FreeRTOS tick and freezes while interrupts are off, so the timing loop never advances and
-// the watchdog resets the chip. With hardware PWM, software only times the mark/space envelope and
-// interrupts can stay enabled.
-//
-// The PWM is driven through the SDK's pwmout HAL directly rather than the Arduino wiring layer:
-// changing the carrier frequency via the wiring requires a GPIO/PWM pin mode round-trip, which
-// use-after-frees the core's per-pin state (pinRemoveMode() frees without nulling) and corrupts the
-// heap. pwmout_period_us() changes the frequency with no mode transitions.
-
-void RemoteTransmitterComponent::setup() {
-  // Deliberately no pin_->setup(): registering the pin as GPIO claims it in the SDK's pin
-  // management, and the pad is then never handed over to the PWM peripheral -- pwmout_init()
-  // must own the pin from the start.
-  PinInfo *info = pinInfo(this->pin_->get_pin());
-  if (info == nullptr || !pinSupported(info, PIN_PWM)) {
-    // checked here because the AmebaZ (RTL8710B) SDK does not report PWM init failure
-    ESP_LOGE(TAG, "Pin %u is not PWM-capable", this->pin_->get_pin());
-    this->mark_failed();
-    return;
-  }
-  auto *pwm = new pwmout_t();
-  this->pwm_ = pwm;
-  pwmout_init(pwm, static_cast<PinName>(info->gpio));
-#if LT_RTL8720C
-  // only the AmebaZ2 SDK's pwmout_s reports init success
-  if (!pwm->is_init) {
-    ESP_LOGE(TAG, "PWM init failed on pin %u", this->pin_->get_pin());
-    delete pwm;
-    this->pwm_ = nullptr;
-    this->mark_failed();
-    return;
-  }
-#endif
-  pwmout_period_us(pwm, 26);  // placeholder; the real carrier period is set per transmission
-  pwmout_write(pwm, this->pin_->is_inverted() ? 1.0f : 0.0f);
-}
-
-void RemoteTransmitterComponent::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Remote Transmitter:\n"
-                "  Carrier Duty: %u%%",
-                this->carrier_duty_percent_);
-  LOG_PIN("  Pin: ", this->pin_);
-}
-
-void RemoteTransmitterComponent::await_target_time_() {
-  const uint32_t current_time = micros();
-  if (this->target_time_ == 0) {
-    this->target_time_ = current_time;
-  } else {
-    while ((int32_t) (this->target_time_ - micros()) > 0) {
-    }
-  }
-}
-
-void RemoteTransmitterComponent::digital_write(bool value) {
-  if (this->pwm_ == nullptr)
-    return;
-  pwmout_write(static_cast<pwmout_t *>(this->pwm_), (value != this->pin_->is_inverted()) ? 1.0f : 0.0f);
-}
-
-void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
-  auto *pwm = static_cast<pwmout_t *>(this->pwm_);
-  if (pwm == nullptr) {
-    ESP_LOGW(TAG, "Cannot send: PWM not initialized");
-    return;
-  }
-  ESP_LOGD(TAG, "Sending remote code");
-  const uint32_t carrier_frequency = this->temp_.get_carrier_frequency();
-  // unmodulated protocols (no carrier or 100% duty) drive the pin constantly during marks
-  float mark_duty =
-      (carrier_frequency > 0 && this->carrier_duty_percent_ < 100) ? this->carrier_duty_percent_ / 100.0f : 1.0f;
-  float space_duty = 0.0f;
-  if (this->pin_->is_inverted()) {
-    mark_duty = 1.0f - mark_duty;
-    space_duty = 1.0f;
-  }
-  if (carrier_frequency > 0 && carrier_frequency != this->current_carrier_frequency_) {
-    // round(1000000/freq), clamped like the bit-bang path so a bad lambda can't hand the SDK a zero period
-    const uint32_t period = std::max(uint32_t(1), (1000000UL + carrier_frequency / 2) / carrier_frequency);
-    pwmout_period_us(pwm, period);
-    this->current_carrier_frequency_ = carrier_frequency;
-  }
-  this->transmit_trigger_.trigger();
-  const UBaseType_t saved_priority = uxTaskPriorityGet(nullptr);
-  for (uint32_t i = 0; i < send_times; i++) {
-    // Boost task priority for the frame only, so WiFi/lwIP tasks can't preempt mid-frame and
-    // merge adjacent marks. Interrupts stay enabled: micros() needs the FreeRTOS tick, and
-    // ISR latency is within receiver tolerance.
-    vTaskPrioritySet(nullptr, configMAX_PRIORITIES - 1);
-    // Re-anchor every iteration: a late exit from the normal-priority gap wait must not
-    // leave the schedule behind micros(), which would compress the next frame's leading items
-    this->target_time_ = 0;
-    for (int32_t item : this->temp_.get_data()) {
-      const bool is_mark = item > 0;
-      this->await_target_time_();
-      pwmout_write(pwm, is_mark ? mark_duty : space_duty);
-      this->target_time_ += is_mark ? uint32_t(item) : uint32_t(-item);
-      App.feed_wdt();
-    }
-    this->await_target_time_();  // wait for duration of last pulse
-    pwmout_write(pwm, space_duty);
-    vTaskPrioritySet(nullptr, saved_priority);
-    if (i + 1 < send_times) {
-      // The repeat gap is user-configurable and unbounded, so wait it out at normal
-      // priority, feeding the watchdog
-      const uint32_t gap_end = micros() + send_wait;
-      while ((int32_t) (gap_end - micros()) > 0) {
-        App.feed_wdt();
-      }
-    }
-  }
-  this->complete_trigger_.trigger();
-}
-
-}  // namespace esphome::remote_transmitter
-
-#endif  // USE_RTL87XX && !CLANG_TIDY

esphome/components/safe_mode/button/safe_mode_button.cpp

@@ -7,6 +7,10 @@ namespace esphome::safe_mode {
 
 static const char *const TAG = "safe_mode.button";
 
+void SafeModeButton::set_safe_mode(SafeModeComponent *safe_mode_component) {
+  this->safe_mode_component_ = safe_mode_component;
+}
+
 void SafeModeButton::press_action() {
   ESP_LOGI(TAG, "Restarting in safe mode");
   this->safe_mode_component_->set_safe_mode_pending(true);

esphome/components/safe_mode/button/safe_mode_button.h

@@ -9,7 +9,7 @@ namespace esphome::safe_mode {
 class SafeModeButton final : public button::Button, public Component {
  public:
   void dump_config() override;
-  void set_safe_mode(SafeModeComponent *safe_mode_component) { this->safe_mode_component_ = safe_mode_component; }
+  void set_safe_mode(SafeModeComponent *safe_mode_component);
 
  protected:
   SafeModeComponent *safe_mode_component_;

esphome/components/safe_mode/switch/safe_mode_switch.cpp

@@ -7,6 +7,10 @@ namespace esphome::safe_mode {
 
 static const char *const TAG = "safe_mode.switch";
 
+void SafeModeSwitch::set_safe_mode(SafeModeComponent *safe_mode_component) {
+  this->safe_mode_component_ = safe_mode_component;
+}
+
 void SafeModeSwitch::write_state(bool state) {
   // Acknowledge
   this->publish_state(false);

esphome/components/safe_mode/switch/safe_mode_switch.h

@@ -9,7 +9,7 @@ namespace esphome::safe_mode {
 class SafeModeSwitch final : public switch_::Switch, public Component {
  public:
   void dump_config() override;
-  void set_safe_mode(SafeModeComponent *safe_mode_component) { this->safe_mode_component_ = safe_mode_component; }
+  void set_safe_mode(SafeModeComponent *safe_mode_component);
 
  protected:
   SafeModeComponent *safe_mode_component_;