Point runtime needle callers at the ESP8266 guard in the doc comment

Document the literal-only needle constraint of the ESP8266 macro
Drop the unused non-ESP8266 forward of str_contains_ignore_case_p
2026-08-23 22:56:19 +00:00 · 2026-08-20 18:08:56 -05:00 · 2026-08-20 18:01:57 -05:00 · 2026-08-20 17:59:27 -05:00 · 2026-08-20 17:56:23 -05:00 · 2026-08-20 17:49:02 -05:00
299 changed files with 1913 additions and 4710 deletions
@@ -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.2

 RUN \
    platformio settings set enable_telemetry No \
@@ -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)
@@ -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)
@@ -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)
@@ -17,9 +17,6 @@ from esphome.const import (
    UNIT_OHM,
    UNIT_PARTS_PER_BILLION,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType

 CONF_RESISTANCE = "resistance"

@@ -65,7 +62,7 @@ CONFIG_SCHEMA = (
 FINAL_VALIDATE_SCHEMA = i2c.final_validate_device_schema("ags10", max_frequency="15khz")


-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 i2c.register_i2c_device(var, config)
@@ -97,12 +94,7 @@ AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
    AGS10_NEW_I2C_ADDRESS_SCHEMA,
    synchronous=True,
 )
-async def ags10newi2caddress_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def ags10newi2caddress_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    address = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
@@ -134,12 +126,7 @@ AGS10_SET_ZERO_POINT_SCHEMA = cv.Schema(
    AGS10_SET_ZERO_POINT_SCHEMA,
    synchronous=True,
 )
-async def ags10setzeropoint_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def ags10setzeropoint_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    mode = await cg.templatable(
@@ -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))
@@ -412,15 +412,15 @@ void APIConnection::finalize_iterator_sync_() {
 }

 void APIConnection::process_iterator_batch_(ComponentIterator &iterator) {
-  // Budget by remaining batch capacity so a pass cannot overfill the batch;
-  // stops early on a refused send and resumes next loop pass
-  size_t batch_size = this->deferred_batch_.size();
-  if (batch_size < MAX_INITIAL_BATCH_SIZE)
-    iterator.try_advance(MAX_INITIAL_BATCH_SIZE - batch_size);
+  size_t initial_size = this->deferred_batch_.size();
+  size_t max_batch = MAX_INITIAL_PER_BATCH;
+  while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < max_batch) {
+    iterator.advance();
+  }

-  // Flush immediately once enough is queued (not guaranteed every pass);
-  // partial batches go out via the batch timer or finalize_iterator_sync_()
-  if (this->deferred_batch_.size() >= MAX_INITIAL_BATCH_SIZE) {
+  // If the batch is full, process it immediately
+  // Note: iterator.advance() already calls schedule_batch_() via schedule_message_()
+  if (this->deferred_batch_.size() >= max_batch) {
    this->process_batch_();
  }
 }
@@ -53,11 +53,11 @@ void log_dropped_message(const char *tag, int line, const LogString *what);

 // Keepalive timeout in milliseconds
 static constexpr uint32_t KEEPALIVE_TIMEOUT_MS = 60000;
-// Deferred batch size cap during initial state/info sync
-static constexpr size_t MAX_INITIAL_BATCH_SIZE = 34;
+// Maximum number of entities to process in a single batch during initial state/info sending
+static constexpr size_t MAX_INITIAL_PER_BATCH = 34;
 // Verify MAX_MESSAGES_PER_BATCH (defined in api_frame_helper.h) can hold the initial batch
-static_assert(MAX_MESSAGES_PER_BATCH >= MAX_INITIAL_BATCH_SIZE,
-              "MAX_MESSAGES_PER_BATCH must be >= MAX_INITIAL_BATCH_SIZE");
+static_assert(MAX_MESSAGES_PER_BATCH >= MAX_INITIAL_PER_BATCH,
+              "MAX_MESSAGES_PER_BATCH must be >= MAX_INITIAL_PER_BATCH");

 #ifdef USE_BENCHMARK
 class APIConnection;
@@ -36,7 +36,7 @@ static constexpr uint16_t MAX_MESSAGE_SIZE = 32768;  // 32 KiB for ESP32 and oth
 static constexpr uint16_t RX_BUF_NULL_TERMINATOR = 1;

 // Maximum number of messages to batch in a single write operation
-// Must be >= MAX_INITIAL_BATCH_SIZE in api_connection.h (enforced by static_assert there)
+// Must be >= MAX_INITIAL_PER_BATCH in api_connection.h (enforced by static_assert there)
 static constexpr size_t MAX_MESSAGES_PER_BATCH = 34;

 // Max client name length (e.g., "Home Assistant 2026.1.0.dev0" = 28 chars)
@@ -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) {
@@ -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; }

@@ -95,17 +95,9 @@ bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(
 ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(client) {}

 #ifdef USE_API_USER_DEFINED_ACTIONS
-// Yield after every Nth service; bounds direct (non-batched) writes per loop pass
-static constexpr uint8_t SERVICE_YIELD_INTERVAL = 3;
-
 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
  auto resp = service->encode_list_service_response();
-  if (!this->client_->send_message(resp))
-    return false;
-  // at_ is this service's index
-  if ((this->at_ + 1) % SERVICE_YIELD_INTERVAL == 0)
-    this->yield_after_step_();
-  return true;
+  return this->client_->send_message(resp);
 }
 #endif

@@ -4,9 +4,6 @@ import esphome.codegen as cg
 from esphome.components import i2c
 import esphome.config_validation as cv
 from esphome.const import CONF_FREQUENCY, CONF_ID
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType

 CODEOWNERS = ["@X-Ryl669"]
 DEPENDENCIES = ["i2c"]
@@ -73,7 +70,7 @@ CONFIG_SCHEMA = cv.All(
 )


-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 i2c.register_i2c_device(var, config)
@@ -94,12 +91,7 @@ AT581XSettingsAction = at581x_ns.class_("AT581XSettingsAction", automation.Actio
    ),
    synchronous=True,
 )
-async def at581x_reset_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def at581x_reset_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])

@@ -171,12 +163,7 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
    RADAR_SETTINGS_SCHEMA,
    synchronous=True,
 )
-async def at581x_settings_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def at581x_settings_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import DEVICE_CLASS_SWITCH, ICON_WIFI
-from esphome.types import ConfigType

 from .. import CONF_AT581X_ID, AT581XComponent, at581x_ns

@@ -23,7 +22,7 @@ CONFIG_SCHEMA = switch.switch_schema(
 )


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    at581x_component = await cg.get_variable(config[CONF_AT581X_ID])
    s = await switch.new_switch(config)
    await cg.register_parented(s, config[CONF_AT581X_ID])
@@ -5,7 +5,6 @@ from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import mqtt, web_server, zigbee
 from esphome.components.const import CONF_ON_STATE_CHANGE
-from esphome.config_helpers import filter_source_files_from_defines
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_DELAY,
@@ -561,11 +560,6 @@ _CALLBACK_AUTOMATIONS = (
 async def _build_binary_sensor_automations(var, config):
    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)

-    if config.get(CONF_ON_CLICK) or config.get(CONF_ON_DOUBLE_CLICK):
-        cg.add_define("USE_BINARY_SENSOR_CLICK_TRIGGER")
-    if config.get(CONF_ON_MULTI_CLICK):
-        cg.add_define("USE_BINARY_SENSOR_MULTI_CLICK_TRIGGER")
-
    for conf in config.get(CONF_ON_CLICK, []):
        trigger = cg.new_Pvariable(
            conf[CONF_TRIGGER_ID], var, conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH]
@@ -679,15 +673,3 @@ async def to_code(config):
 async def binary_sensor_invalidate_state_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.cpp only implements the click/double_click/multi_click triggers
-FILTER_SOURCE_FILES = filter_source_files_from_defines(
-    {
-        "automation.cpp": (
-            "USE_BINARY_SENSOR_CLICK_TRIGGER",
-            "USE_BINARY_SENSOR_MULTI_CLICK_TRIGGER",
-        ),
-        "filter.cpp": "USE_BINARY_SENSOR_FILTER",
-    }
-)
@@ -1,13 +1,8 @@
-#include "esphome/core/defines.h"
-#if defined(USE_BINARY_SENSOR_CLICK_TRIGGER) || defined(USE_BINARY_SENSOR_MULTI_CLICK_TRIGGER)
-
 #include "automation.h"
 #include "esphome/core/log.h"

 namespace esphome::binary_sensor {

-#ifdef USE_BINARY_SENSOR_MULTI_CLICK_TRIGGER
-
 static const char *const TAG = "binary_sensor.automation";

 // MultiClickTrigger timeout IDs.
@@ -125,9 +120,6 @@ void MultiClickTriggerBase::trigger_() {
  this->trigger();
 }

-#endif  // USE_BINARY_SENSOR_MULTI_CLICK_TRIGGER
-
-#ifdef USE_BINARY_SENSOR_CLICK_TRIGGER
 bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
  if (max_length == 0) {
    return length >= min_length;
@@ -135,8 +127,4 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
    return length >= min_length && length <= max_length;
  }
 }
-#endif  // USE_BINARY_SENSOR_CLICK_TRIGGER
-
 }  // namespace esphome::binary_sensor
-
-#endif  // USE_BINARY_SENSOR_CLICK_TRIGGER || USE_BINARY_SENSOR_MULTI_CLICK_TRIGGER
@@ -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")
@@ -206,36 +206,32 @@ def validate_scan_parameters(config: ConfigType) -> ConfigType:
    interval = config[CONF_INTERVAL]
    window = config[CONF_WINDOW]

-    # 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})"
-            )
+    if window > interval:
+        raise cv.Invalid(
+            f"Scan window ({window}) 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 (("Scan interval", interval), *windows):
+    for name, value in (("interval", interval), ("window", window)):
        if value.total_microseconds < 2500 or value.total_microseconds > 10_240_000:
-            raise cv.Invalid(f"{name} ({value}) must be between 2.5 ms and 10240 ms")
+            raise cv.Invalid(
+                f"Scan {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)
-    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."
-            )
+    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."
+        )

    if interval.total_microseconds * 3 > duration.total_microseconds:
        raise cv.Invalid(
@@ -251,14 +247,11 @@ 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.

@@ -270,9 +263,7 @@ 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. 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.
+    tracker must not share this schema.
    """
    schema = {
        cv.Optional(CONF_DURATION, default="5min"): cv.positive_time_period_seconds,
@@ -281,8 +272,6 @@ 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)


@@ -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)
@@ -1,13 +1,10 @@
 import re
-from typing import Any

 from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_TRIGGER_ID
 from esphome.core import CORE, ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType

 CODEOWNERS = ["@mvturnho", "@danielschramm"]
 IS_PLATFORM_COMPONENT = True
@@ -21,7 +18,7 @@ CONF_BIT_RATE = "bit_rate"
 CONF_ON_FRAME = "on_frame"


-def validate_id(config: ConfigType) -> ConfigType:
+def validate_id(config):
    if CONF_CAN_ID in config:
        can_id = config[CONF_CAN_ID]
        id_ext = config[CONF_USE_EXTENDED_ID]
@@ -30,7 +27,7 @@ def validate_id(config: ConfigType) -> ConfigType:
    return config


-def validate_raw_data(value: Any) -> bytes | list:
+def validate_raw_data(value):
    if isinstance(value, str):
        return value.encode("utf-8")
    if isinstance(value, list):
@@ -74,7 +71,7 @@ CAN_SPEEDS = {
 }


-def get_rate(value: str) -> int:
+def get_rate(value):
    match = re.match(r"(\d+)(?:K(\d+)?)?BPS", value, re.IGNORECASE)
    if not match:
        raise ValueError(f"Invalid rate format: {value}")
@@ -106,7 +103,7 @@ CANBUS_SCHEMA = cv.Schema(
 CANBUS_SCHEMA.add_extra(validate_id)


-async def setup_canbus_core_(var: MockObj, config: ConfigType) -> None:
+async def setup_canbus_core_(var, config):
    await cg.register_component(var, config)
    cg.add(var.set_can_id([config[CONF_CAN_ID]]))
    cg.add(var.set_use_extended_id([config[CONF_USE_EXTENDED_ID]]))
@@ -137,7 +134,7 @@ async def setup_canbus_core_(var: MockObj, config: ConfigType) -> None:
        )


-async def register_canbus(var: MockObj, config: ConfigType) -> None:
+async def register_canbus(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.new_Pvariable(config[CONF_ID], var)
    await setup_canbus_core_(var, config)
@@ -160,12 +157,7 @@ async def register_canbus(var: MockObj, config: ConfigType) -> None:
    ),
    synchronous=True,
 )
-async def canbus_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def canbus_action_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_CANBUS_ID])

@@ -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
    }
  }
@@ -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
@@ -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)
@@ -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) {
@@ -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).
@@ -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)
@@ -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();
@@ -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;
@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
 from esphome.const import CONF_ADDRESS, CONF_ID
-from esphome.types import ConfigType

 CODEOWNERS = ["@s1lvi0"]
 MULTI_CONF = True
@@ -27,7 +26,7 @@ CONFIG_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 uart.register_uart_device(var, config)
@@ -1,8 +1,6 @@
 import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType

 from . import CONF_BMS_DALY_ID, DalyBmsComponent

@@ -29,13 +27,13 @@ CONFIG_SCHEMA = cv.All(
 )


-async def setup_conf(config: ConfigType, key: str, hub: MockObj) -> None:
+async def setup_conf(config, key, hub):
    if sensor_config := config.get(key):
        var = await binary_sensor.new_binary_sensor(sensor_config)
        cg.add(getattr(hub, f"set_{key}_binary_sensor")(var))


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    hub = await cg.get_variable(config[CONF_BMS_DALY_ID])
    for key in TYPES:
        await setup_conf(config, key, hub)
@@ -23,8 +23,6 @@ from esphome.const import (
    UNIT_PERCENT,
    UNIT_VOLT,
 )
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType

 from . import CONF_BMS_DALY_ID, DalyBmsComponent

@@ -224,13 +222,13 @@ CONFIG_SCHEMA = cv.All(
 )


-async def setup_conf(config: ConfigType, key: str, hub: MockObj) -> None:
+async def setup_conf(config, key, hub):
    if sensor_config := config.get(key):
        sens = await sensor.new_sensor(sensor_config)
        cg.add(getattr(hub, f"set_{key}_sensor")(sens))


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    hub = await cg.get_variable(config[CONF_BMS_DALY_ID])
    for key in TYPES:
        await setup_conf(config, key, hub)
@@ -2,8 +2,6 @@ import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
 from esphome.const import CONF_STATUS
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType

 from . import CONF_BMS_DALY_ID, DalyBmsComponent

@@ -25,13 +23,13 @@ CONFIG_SCHEMA = cv.All(
 )


-async def setup_conf(config: ConfigType, key: str, hub: MockObj) -> None:
+async def setup_conf(config, key, hub):
    if sensor_config := config.get(key):
        sens = await text_sensor.new_text_sensor(sensor_config)
        cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    hub = await cg.get_variable(config[CONF_BMS_DALY_ID])
    for key in TYPES:
        await setup_conf(config, key, hub)
@@ -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]:
@@ -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");
@@ -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)
@@ -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_;
@@ -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)
@@ -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");
@@ -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)
@@ -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
@@ -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):
@@ -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:
@@ -38,8 +38,7 @@ from esphome.const import (
    PLATFORM_NRF52,
    PlatformFramework,
 )
-from esphome.core import CORE, ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.core import CORE
 from esphome.types import ConfigType

 WAKEUP_PINS = {
@@ -163,11 +162,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)
@@ -180,7 +174,7 @@ def validate_config(config: ConfigType) -> ConfigType:
    return config


-def _validate_ex1_wakeup_mode(value: str) -> str:
+def _validate_ex1_wakeup_mode(value):
    if value == "ALL_LOW":
        esp32.only_on_variant(supported=[VARIANT_ESP32], msg_prefix="ALL_LOW")(value)
    if value == "ANY_LOW":
@@ -351,7 +345,7 @@ CONFIG_SCHEMA = cv.All(
 )


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

@@ -464,12 +458,7 @@ DEEP_SLEEP_ENTER_SCHEMA = cv.All(
    DEEP_SLEEP_ENTER_SCHEMA,
    synchronous=True,
 )
-async def deep_sleep_enter_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, paren)
    if CONF_SLEEP_DURATION in config:
@@ -498,12 +487,7 @@ async def deep_sleep_enter_to_code(
    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
    synchronous=True,
 )
-async def deep_sleep_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def deep_sleep_action_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    return var
@@ -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
@@ -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
@@ -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;
 }
@@ -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) {
@@ -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)
@@ -3,9 +3,6 @@ import esphome.codegen as cg
 from esphome.components import i2c, time
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType

 CODEOWNERS = ["@badbadc0ffee"]
 DEPENDENCIES = ["i2c"]
@@ -32,12 +29,7 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
    ),
    synchronous=True,
 )
-async def ds1307_write_time_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def ds1307_write_time_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    return var
@@ -53,18 +45,13 @@ async def ds1307_write_time_to_code(
    ),
    synchronous=True,
 )
-async def ds1307_read_time_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def ds1307_read_time_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    return var


-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)
@@ -68,7 +68,6 @@ PATTERN_CONFIGS = {
    "PULSE": {
        CONF_UNIT_OF_MEASUREMENT: UNIT_PULSES,
        CONF_DEVICE_CLASS: DEVICE_CLASS_ENERGY,
-        CONF_STATE_CLASS: STATE_CLASS_TOTAL_INCREASING,
        CONF_ACCURACY_DECIMALS: 0,
    },
    "PF": {
@@ -79,13 +78,12 @@ PATTERN_CONFIGS = {
    },
 }

-# BASE_SCHEMA intentionally omits state_class and accuracy_decimals defaults.
-# Passing them to sensor_schema() would register them via cv.Optional(key, default=...),
-# making them always present in the validated config dict and preventing
-# apply_tag_defaults from overriding them with the correct per-prefix values.
-# They are injected by apply_tag_defaults below, after running through
-# sensor.validate_state_class() so the value is code-generation-ready.
-BASE_SCHEMA = sensor.sensor_schema(EmonTxSensor).extend(
+# Create a base schema that's flexible for any tag
+BASE_SCHEMA = sensor.sensor_schema(
+    EmonTxSensor,
+    state_class=STATE_CLASS_MEASUREMENT,
+    accuracy_decimals=0,
+).extend(
    {
        cv.GenerateID(CONF_EMONTX_ID): cv.use_id(EmonTx),
        cv.Required(CONF_TAG_NAME): cv.string,
@@ -93,43 +91,34 @@ BASE_SCHEMA = sensor.sensor_schema(EmonTxSensor).extend(
 )


-def _apply_defaults(config: ConfigType, defaults: dict) -> None:
-    """Inject defaults into config, skipping keys already set by the user.
-    state_class values are run through validate_state_class so they are
-    code-generation-ready, matching what sensor_schema() would normally do."""
-    for key, value in defaults.items():
-        if key not in config:
-            if key == CONF_STATE_CLASS:
-                value = sensor.validate_state_class(value)
-            config[key] = value
-
-
 def apply_tag_defaults(config: ConfigType) -> ConfigType:
    """Apply defaults based on tag prefix if applicable, but don't restrict any tags."""
    tag = config[CONF_TAG_NAME]

-    if len(tag) >= 2:
-        tag_upper = tag.upper()
+    # Skip if tag is too short
+    if len(tag) < 2:
+        return config

-        for pattern, pattern_config in PATTERN_CONFIGS.items():
-            if tag_upper.startswith(pattern):
-                _apply_defaults(config, pattern_config)
-                return config
+    # Check if this tag starts with a known prefix
+    tag_upper = tag.upper()

-        # Only apply defaults for known prefixes with numeric indices (e.g. E1, V2, T3)
-        prefix = tag_upper[0]
-        if prefix in SENSOR_CONFIGS and tag[1:].isdigit():
-            _apply_defaults(config, SENSOR_CONFIGS[prefix])
+    for pattern, pattern_config in PATTERN_CONFIGS.items():
+        if tag_upper.startswith(pattern):
+            # Apply pattern defaults if not overridden by user
+            for key, value in pattern_config.items():
+                if key not in config:
+                    config[key] = value
            return config

-    # Fall back to generic defaults for tags with no known prefix
-    _apply_defaults(
-        config,
-        {
-            CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
-            CONF_ACCURACY_DECIMALS: 0,
-        },
-    )
+    # Only apply defaults for known prefixes with numeric indices
+    prefix = tag_upper[0]
+    if prefix in SENSOR_CONFIGS and len(tag) > 1 and tag[1:].isdigit():
+        # Apply defaults for known tag types, but only if not overridden by user
+        defaults = SENSOR_CONFIGS[prefix]
+        for key, value in defaults.items():
+            if key not in config:
+                config[key] = value
+
    return config


@@ -12,7 +12,6 @@ from typing import Any
 from esphome import yaml_util
 import esphome.codegen as cg
 from esphome.components.const import CONF_ENABLE_OTA_DOWNGRADE_PROTECTION
-from esphome.config_helpers import filter_source_files_from_defines
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ADVANCED,
@@ -234,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
@@ -3452,10 +3450,3 @@ def process_stacktrace(config, line, backtrace_state):
            _decode_pc(config, addr.group())

    return backtrace_state
-
-
-# gpio.cpp only implements ESP32InternalGPIOPin and its ISR helpers, which
-# are instantiated solely by the pin schema codegen (esp32_pin_to_code)
-FILTER_SOURCE_FILES = filter_source_files_from_defines(
-    {"gpio.cpp": "USE_ESP32_INTERNAL_GPIO"}
-)
@@ -124,15 +124,6 @@ static uint8_t IRAM_ATTR capture_riscv_backtrace(RvExcFrame *frame, uint32_t *ou
 // Version is uint32_t because it would be padded to 4 bytes anyway before the next
 // uint32_t field, so we use the full width rather than wasting 3 bytes of padding.
 static constexpr uint32_t CRASH_DATA_VERSION = 4;
-#if CONFIG_IDF_TARGET_ARCH_XTENSA
-// EXCCAUSE is a 6-bit register; larger recorded values mean the frame's
-// cause/vaddr slots were never written (not a real exception frame).
-static constexpr uint32_t XTENSA_EXCCAUSE_COUNT = XCHAL_EXCCAUSE_NUM;
-#elif CONFIG_IDF_TARGET_ARCH_RISCV
-// Synchronous mcause exception codes are small and have no interrupt bit;
-// anything else in a non-pseudo record is a stale slot.
-static constexpr uint32_t RISCV_EXCEPTION_CAUSE_COUNT = 32;
-#endif
 struct RawCrashData {
  uint32_t version;
  uint32_t magic;
@@ -207,28 +198,10 @@ void crash_handler_clear() {
  s_raw_crash_data.magic = 0;
 }

-// Whether the cause slot was written by a real exception frame.
-static bool cause_slot_was_written() {
-#if CONFIG_IDF_TARGET_ARCH_XTENSA
-  return s_raw_crash_data.cause < XTENSA_EXCCAUSE_COUNT;
-#else
-  return s_raw_crash_data.cause < RISCV_EXCEPTION_CAUSE_COUNT;
-#endif
-}
-
 // Look up the exception cause as a human-readable string.
 // Tables mirror ESP-IDF's panic_arch_fill_info() which uses local static arrays
 // not exposed via any public API.
 static const char *get_exception_reason() {
-  uint8_t exception = s_raw_crash_data.exception;
-  if (exception == PANIC_EXCEPTION_ABORT || exception == PANIC_EXCEPTION_TWDT) {
-    // Abort-class panics carry no cause register
-    return nullptr;
-  }
-  if (!cause_slot_was_written()) {
-    // Garbage from old-build or corrupt records; report just the type
-    return nullptr;
-  }
 #if CONFIG_IDF_TARGET_ARCH_XTENSA
  if (s_raw_crash_data.pseudo_excause) {
    // SoC-level panic: watchdog, cache error, etc.
@@ -381,11 +354,10 @@ static const char *const FAULT_ADDR_REG = "MTVAL";
 static const char *const FAULT_ADDR_REG_LOWER = "mtval";
 #endif

-// Whether the fault address is meaningful: real CPU faults with a validly
-// written frame only.
+// Whether the fault address is meaningful — real CPU faults only, not
+// aborts/watchdogs or SoC-level pseudo exceptions.
 static bool has_fault_addr() {
-  return s_raw_crash_data.exception == PANIC_EXCEPTION_FAULT && !s_raw_crash_data.pseudo_excause &&
-         cause_slot_was_written();
+  return s_raw_crash_data.exception == PANIC_EXCEPTION_FAULT && !s_raw_crash_data.pseudo_excause;
 }

 // The record was captured by a different firmware build (it survives soft
@@ -486,10 +458,6 @@ void crash_handler_log() {
 // into NOINIT memory before the normal panic handler runs.
 //
 extern "C" {
-// Set by IDF's task watchdog (task_wdt.c, no header) before it simulates an
-// abort; weak so builds without the task watchdog still link.
-extern bool g_twdt_isr __attribute__((weak));
-
 // NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
 // Names are mandated by the --wrap linker mechanism
 extern void __real_esp_panic_handler(panic_info_t *info);
@@ -502,14 +470,6 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  s_raw_crash_data.exception = (uint8_t) info->exception;
  s_raw_crash_data.pseudo_excause = info->pseudo_excause ? 1 : 0;
  s_raw_crash_data.crashed_core = (uint8_t) info->core;
-  if (g_panic_abort) {
-    // IDF reclassifies to ABORT only inside esp_panic_handler(), after this
-    // wrapper captured info->exception; correct it here. TWDT is our own
-    // distinction (IDF never assigns PANIC_EXCEPTION_TWDT). The abort text is
-    // not stored; the symbolized backtrace already identifies the site.
-    bool is_twdt = &g_twdt_isr != nullptr && g_twdt_isr;
-    s_raw_crash_data.exception = (uint8_t) (is_twdt ? PANIC_EXCEPTION_TWDT : PANIC_EXCEPTION_ABORT);
-  }
  // Zero unconditionally so a null frame doesn't leave stale .noinit data from a previous boot
  s_raw_crash_data.cause = 0;
  s_raw_crash_data.fault_addr = 0;
@@ -527,12 +487,8 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  // Xtensa: walk the backtrace using the public API
  if (info->frame != nullptr) {
    auto *xt_frame = (XtExcFrame *) info->frame;
-    if (!g_panic_abort) {
-      // Abort-class frames carry no useful cause/vaddr: TWDT task snapshots
-      // never wrote them and abort() traps describe only the synthetic trap.
-      s_raw_crash_data.cause = xt_frame->exccause;
-      s_raw_crash_data.fault_addr = xt_frame->excvaddr;
-    }
+    s_raw_crash_data.cause = xt_frame->exccause;
+    s_raw_crash_data.fault_addr = xt_frame->excvaddr;
    s_raw_crash_data.backtrace_count = walk_xtensa_backtrace(xt_frame, s_raw_crash_data.backtrace, MAX_BACKTRACE);
  }

@@ -554,11 +510,8 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  // RISC-V: capture MEPC + RA, then scan stack for code addresses
  if (info->frame != nullptr) {
    auto *rv_frame = (RvExcFrame *) info->frame;
-    if (!g_panic_abort) {
-      // See the Xtensa branch: abort-class frames carry no valid cause/vaddr.
-      s_raw_crash_data.cause = rv_frame->mcause;
-      s_raw_crash_data.fault_addr = rv_frame->mtval;
-    }
+    s_raw_crash_data.cause = rv_frame->mcause;
+    s_raw_crash_data.fault_addr = rv_frame->mtval;
    s_raw_crash_data.backtrace_count =
        capture_riscv_backtrace(rv_frame, s_raw_crash_data.backtrace, MAX_BACKTRACE, &s_raw_crash_data.reg_frame_count);
  }
@@ -1,7 +1,4 @@
-#include "esphome/core/defines.h"
-// Also defines the core ISRInternalGPIOPin methods; those are only reachable
-// via ESP32InternalGPIOPin::to_isr(), so the same define gates both safely.
-#if defined(USE_ESP32) && defined(USE_ESP32_INTERNAL_GPIO)
+#ifdef USE_ESP32

 #include "gpio.h"
 #include "esphome/core/log.h"
@@ -207,4 +204,4 @@ void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {

 }  // namespace esphome

-#endif  // USE_ESP32 && USE_ESP32_INTERNAL_GPIO
+#endif  // USE_ESP32
@@ -257,7 +257,6 @@ ESP32_PIN_SCHEMA = cv.All(

@pins.PIN_SCHEMA_REGISTRY.register(PLATFORM_ESP32, ESP32_PIN_SCHEMA)
 async def esp32_pin_to_code(config):
-    cg.add_define("USE_ESP32_INTERNAL_GPIO")
    var = cg.new_Pvariable(config[CONF_ID])
    num = config[CONF_NUMBER]
    cg.add(var.set_pin(getattr(gpio_num_t, f"GPIO_NUM_{num}")))
@@ -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
@@ -7,7 +7,6 @@ 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,
@@ -39,8 +38,7 @@ from esphome.const import (
    CONF_SERVICE_UUID,
    CONF_TRIGGER_ID,
 )
-from esphome.core import CORE, ID, CoroPriority, TimePeriod, coroutine_with_priority
-from esphome.cpp_generator import MockObj, TemplateArgsType
+from esphome.core import CORE, CoroPriority, TimePeriod, coroutine_with_priority
 from esphome.enum import StrEnum
 from esphome.types import ConfigType

@@ -74,9 +72,8 @@ 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(CLIENT_COUNT_DEFINE)
+_request_client_slot = cg.slot_counter("ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT")


 def register_ble_features(features: set[BLEFeatures]) -> None:
@@ -149,7 +146,6 @@ 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:
@@ -178,34 +174,17 @@ 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. The connection window is
-    checked against the window here, after the raise.
+    parameters, so no re-validation is needed.
    """
-    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


@@ -214,7 +193,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, connection_window=True
+    "320ms", window_default=_scan_window_default
 )

 # Codegen helpers are owned by ble_device_base; kept under the historical names
@@ -283,7 +262,7 @@ ESP_BLE_DEVICE_SCHEMA = cv.Schema(
 )


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    # Register the loggers this component needs
    esp32_ble.register_bt_logger(BTLoggers.BLE_SCAN)

@@ -308,25 +287,6 @@ 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]))

@@ -400,7 +360,7 @@ async def to_code(config: ConfigType) -> None:
 # chance to call register_ble_tracker and register_client before the list is checked
 # and added to the global defines list.
@coroutine_with_priority(CoroPriority.FINAL)
-async def _add_ble_features() -> None:
+async def _add_ble_features():
    # Add feature-specific defines based on what's needed
    required_features = _get_required_features()
    # Sensors registered through the neutral ble_device_base path (BLEHub) need
@@ -429,11 +389,8 @@ ESP32_BLE_START_SCAN_ACTION_SCHEMA = cv.Schema(
    synchronous=True,
 )
 async def esp32_ble_tracker_start_scan_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+    config, action_id, template_arg, args
+):
    paren = await cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, paren)
    template_ = await cg.templatable(config[CONF_CONTINUOUS], args, cg.bool_)
@@ -457,11 +414,8 @@ ESP32_BLE_STOP_SCAN_ACTION_SCHEMA = automation.maybe_simple_id(
    synchronous=True,
 )
 async def esp32_ble_tracker_stop_scan_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+    config, action_id, template_arg, args
+):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    return var
@@ -122,9 +122,6 @@ 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.
@@ -147,19 +144,6 @@ 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:
@@ -211,23 +195,19 @@ 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_(); }

-bool ESP32BLETracker::stop_scan_() {
+void 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 false;
+    return;
  }
  // Reset timeout state machine when stopping scan
  this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
@@ -235,9 +215,8 @@ bool 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 false;
+    return;
  }
-  return true;
 }

 void ESP32BLETracker::start_scan_(bool first) {
@@ -251,11 +230,16 @@ void ESP32BLETracker::start_scan_(bool first) {
  }
  this->set_scanner_state_(ScannerState::STARTING);
  ESP_LOGV(TAG, "Starting scan, set scanner state to STARTING.");
-  if (!first)
-    this->notify_scan_end_();
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  this->skip_next_scan_end_ = false;
+  if (!first) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
+    for (auto *listener : this->listeners_)
+      listener->on_scan_end();
 #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
@@ -263,17 +247,7 @@ 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_;
-#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;
+  this->scan_params_.scan_window = this->scan_window_;

  // Start timeout monitoring in loop() instead of using scheduler
  // This prevents false reboots when the loop is blocked
@@ -434,11 +408,6 @@ 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",
@@ -518,18 +487,6 @@ 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();
@@ -538,6 +495,8 @@ void ESP32BLETracker::notify_scan_end_() {
  for (auto *listener : this->neutral_listeners_)
    listener->on_scan_end();
 #endif
+
+  this->set_scanner_state_(ScannerState::IDLE);
 }

 void ESP32BLETracker::handle_scanner_failure_() {
@@ -575,8 +534,6 @@ 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
@@ -169,9 +169,6 @@ 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; }
@@ -229,10 +226,7 @@ class ESP32BLETracker final : public Component,
  ScannerState get_scanner_state() const { return this->scanner_state_; }

 protected:
-  /// 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_();
+  void stop_scan_();
  /// 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.
@@ -319,15 +313,6 @@ 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};

@@ -345,20 +330,15 @@ 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};
-  // Packed 1-bit flags.
-  bool scan_continuous_ : 1;
-  bool scan_active_ : 1;
+  bool scan_continuous_;
+  bool scan_active_;
 #ifdef USE_OTA_STATE_LISTENER
-  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};
+  bool scan_continuous_before_ota_{false};
 #endif
+  bool ble_was_disabled_{true};
+  bool parse_advertisements_{false};
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
-  bool coex_prefer_ble_ : 1 {false};
+  bool coex_prefer_ble_{false};
 #endif
  // Scan timeout state machine
  enum class ScanTimeoutState : uint8_t {
@@ -366,10 +346,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
@@ -135,10 +135,6 @@ void Esp32HostedUpdate::setup() {
  // Publish state
  this->status_clear_error();
  this->publish_state();
-  // Defer so the automation runs on the main loop after setup, not during App.setup()
-  if (this->state_ == update::UPDATE_STATE_AVAILABLE && this->update_available_trigger_) {
-    this->defer([this]() { this->update_available_trigger_->trigger(this->update_info_); });
-  }
 #else
  // HTTP mode: check every 10s until network is ready (max 6 attempts)
  // Only if update interval is > 1 minute to avoid redundant checks
@@ -189,8 +185,6 @@ void Esp32HostedUpdate::check() {
    return;
  }

-  const bool was_available = this->state_ == update::UPDATE_STATE_AVAILABLE;
-
  // Compare versions
  if (this->update_info_.latest_version.empty() ||
      this->update_info_.latest_version == this->update_info_.current_version) {
@@ -203,9 +197,6 @@ void Esp32HostedUpdate::check() {
  this->update_info_.progress = 0.0f;
  this->status_clear_error();
  this->publish_state();
-  if (this->state_ == update::UPDATE_STATE_AVAILABLE && !was_available && this->update_available_trigger_) {
-    this->update_available_trigger_->trigger(this->update_info_);
-  }
 #endif
 }

@@ -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)
@@ -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.
@@ -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
@@ -398,7 +398,7 @@ void ESPHomeOTAComponent::handle_data_() {
  this->notify_state_(ota::OTA_STARTED, 0.0f, 0);
 #endif

-  // begin() returns quickly; flash sectors are erased incrementally during write().
+  // begin() may block for a few seconds while it locks flash.
  error_code = this->backend_->begin(ota_size, ota_type);
  if (error_code != ota::OTA_RESPONSE_OK)
    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
@@ -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);
@@ -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_();
@@ -129,17 +129,14 @@ void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int
 ESPNowComponent::ESPNowComponent() { global_esp_now = this; }

 void ESPNowComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "espnow:");
-  // Only report driver details once enabled; with enable_on_boot: false the
-  // Wi-Fi driver is not initialized yet and esp_now_get_version() would crash,
-  // and after a failed enable_() the values would be meaningless.
-  if (this->state_ != ESPNOW_STATE_ENABLED) {
-    // OFF here means enable_() failed; the core logs the FAILED marker separately
-    ESP_LOGCONFIG(TAG, "  %s", this->is_disabled() ? LOG_STR_LITERAL("Disabled") : LOG_STR_LITERAL("Not enabled"));
-    return;
-  }
  uint32_t version = 0;
  esp_now_get_version(&version);
+
+  ESP_LOGCONFIG(TAG, "espnow:");
+  if (this->is_disabled()) {
+    ESP_LOGCONFIG(TAG, "  Disabled");
+    return;
+  }
  char own_addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
  format_mac_addr_upper(this->own_address_, own_addr_buf);
  ESP_LOGCONFIG(TAG,
@@ -48,12 +48,10 @@ from esphome.const import (
 )
 from esphome.core import (
    CORE,
-    ID,
    CoroPriority,
    TimePeriodMilliseconds,
    coroutine_with_priority,
 )
-from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
 from esphome.types import ConfigType

@@ -278,7 +276,7 @@ def _validate_spi_interface(config: ConfigType) -> ConfigType:
    return config


-def _validate(config: ConfigType) -> ConfigType:
+def _validate(config):
    if CONF_USE_ADDRESS not in config:
        if CONF_MANUAL_IP in config:
            use_address = str(config[CONF_MANUAL_IP][CONF_STATIC_IP])
@@ -443,7 +441,7 @@ GENERIC_SCHEMA = cv.All(
 )


-def _spi_schema(default_clock: str = "26.67MHz", max_clock: int = int(80e6)) -> cv.All:
+def _spi_schema(default_clock: str = "26.67MHz", max_clock: int = int(80e6)):
    return cv.All(
        BASE_SCHEMA.extend(
            cv.Schema(
@@ -519,7 +517,7 @@ CONFIG_SCHEMA = cv.All(
 )


-def _final_validate_spi(config: ConfigType) -> None:
+def _final_validate_spi(config):
    if not CORE.is_esp32:
        return  # SPI interface validation is ESP32-only
    if config[CONF_TYPE] not in SPI_ETHERNET_TYPES:
@@ -539,7 +537,7 @@ def _final_validate_spi(config: ConfigType) -> None:
                    )


-def manual_ip(config: ConfigType) -> cg.StructInitializer:
+def manual_ip(config):
    return cg.StructInitializer(
        ManualIP,
        ("static_ip", ip_address_literal(config[CONF_STATIC_IP])),
@@ -550,7 +548,7 @@ def manual_ip(config: ConfigType) -> cg.StructInitializer:
    )


-def phy_register(address: int, value: int, page: int) -> cg.StructInitializer:
+def phy_register(address: int, value: int, page: int):
    return cg.StructInitializer(
        PHYRegister,
        ("address", address),
@@ -560,7 +558,7 @@ def phy_register(address: int, value: int, page: int) -> cg.StructInitializer:


@coroutine_with_priority(CoroPriority.COMMUNICATION)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])

    # Apply network priority before register_component (which emits the user's
@@ -612,7 +610,7 @@ async def to_code(config: ConfigType) -> None:
    CORE.add_job(final_step)


-async def _to_code_esp32(var: cg.MockObj, config: ConfigType) -> None:
+async def _to_code_esp32(var: cg.Pvariable, config: ConfigType) -> None:
    from esphome.components.esp32 import (
        add_idf_component,
        add_idf_sdkconfig_option,
@@ -700,7 +698,7 @@ async def _to_code_esp32(var: cg.MockObj, config: ConfigType) -> None:
        add_idf_component(name=component.name, ref=component.version)


-async def _to_code_rp2040(var: cg.MockObj, config: ConfigType) -> None:
+async def _to_code_rp2040(var: cg.Pvariable, config: ConfigType) -> None:
    cg.add(var.set_clk_pin(config[CONF_CLK_PIN]))
    cg.add(var.set_miso_pin(config[CONF_MISO_PIN]))
    cg.add(var.set_mosi_pin(config[CONF_MOSI_PIN]))
@@ -795,7 +793,7 @@ FINAL_VALIDATE_SCHEMA = _final_validate


@coroutine_with_priority(CoroPriority.FINAL)
-async def final_step() -> None:
+async def final_step():
    """Final code generation step to configure optional Ethernet features."""
    if ip_state_count := CORE.data.get(ETHERNET_IP_STATE_LISTENERS_KEY, 0):
        cg.add_define("USE_ETHERNET_IP_STATE_LISTENERS")
@@ -847,12 +845,7 @@ def _filter_source_files() -> list[str]:
 FILTER_SOURCE_FILES = _filter_source_files


-async def _new_pvariable_to_code(
-    config: ConfigType,
-    id_: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def _new_pvariable_to_code(config, id_, template_arg, args):
    return cg.new_Pvariable(id_, template_arg)


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

@@ -159,6 +159,9 @@ class EthernetComponent final : public Component {
  const char *get_use_address() const { return this->use_address_; }
  void set_use_address(const char *use_address) { this->use_address_ = use_address; }
  void get_eth_mac_address_raw(uint8_t *mac);
+  // Remove before 2026.9.0
+  ESPDEPRECATED("Use get_eth_mac_address_pretty_into_buffer() instead. Removed in 2026.9.0", "2026.3.0")
+  std::string get_eth_mac_address_pretty();
  const char *get_eth_mac_address_pretty_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
  eth_duplex_t get_duplex_mode();
  eth_speed_t get_link_speed();
@@ -168,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
@@ -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

@@ -928,6 +946,11 @@ void EthernetComponent::get_eth_mac_address_raw(uint8_t *mac) {
  ESPHL_ERROR_CHECK(err, "ETH_CMD_G_MAC error");
 }

+std::string EthernetComponent::get_eth_mac_address_pretty() {
+  char buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
+  return std::string(this->get_eth_mac_address_pretty_into_buffer(buf));
+}
+
 const char *EthernetComponent::get_eth_mac_address_pretty_into_buffer(
    std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf) {
  uint8_t mac[MAC_ADDRESS_SIZE];
@@ -249,6 +249,11 @@ void EthernetComponent::get_eth_mac_address_raw(uint8_t *mac) {
  }
 }

+std::string EthernetComponent::get_eth_mac_address_pretty() {
+  char buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
+  return std::string(this->get_eth_mac_address_pretty_into_buffer(buf));
+}
+
 const char *EthernetComponent::get_eth_mac_address_pretty_into_buffer(
    std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf) {
  uint8_t mac[MAC_ADDRESS_SIZE];
@@ -350,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
@@ -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);
 }
@@ -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) {
@@ -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}")
@@ -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)
@@ -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)

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

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

@@ -1,5 +1,3 @@
-from typing import Any
-
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
@@ -18,9 +16,6 @@ from esphome.const import (
    UNIT_CELSIUS,
    UNIT_PERCENT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType

 DEPENDENCIES = ["i2c"]

@@ -67,7 +62,7 @@ CONFIG_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 i2c.register_i2c_device(var, config)
@@ -91,7 +86,7 @@ HDC302X_HEATER_POWER_MAP = {
 }


-def heater_power_value(value: Any) -> cv.Lambda | int:
+def heater_power_value(value):
    """Accept enum names or raw uint16 values"""
    if isinstance(value, cv.Lambda):
        return value
@@ -124,12 +119,7 @@ HDC302X_HEATER_ON_ACTION_SCHEMA = maybe_simple_id(
    HDC302X_HEATER_ON_ACTION_SCHEMA,
    synchronous=True,
 )
-async def hdc302x_heater_on_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def hdc302x_heater_on_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    template_ = await cg.templatable(config[CONF_POWER], args, cg.uint16)
@@ -145,12 +135,7 @@ async def hdc302x_heater_on_to_code(
    HDC302X_ACTION_SCHEMA,
    synchronous=True,
 )
-async def hdc302x_heater_off_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def hdc302x_heater_off_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    return var
@@ -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]))
@@ -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)
@@ -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,
@@ -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)
@@ -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)
@@ -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)
@@ -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)
@@ -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
@@ -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))
@@ -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)
@@ -196,9 +196,6 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
      }

      container->feed_wdt();
-      // IDF is the only backend reusing the container across redirect hops;
-      // drop the previous hop's headers (Arduino/host collect only the final response)
-      container->response_headers_.clear();
      container->content_length = esp_http_client_fetch_headers(client);
      container->set_chunked(esp_http_client_is_chunked_response(client));
      container->feed_wdt();
@@ -64,9 +64,8 @@ void OtaHttpRequestComponent::flash() {
  }
 }

-void OtaHttpRequestComponent::cleanup_(ota::OTABackendPtr backend, const std::shared_ptr<HttpContainer> &container,
-                                       bool abort_backend) {
-  if (abort_backend) {
+void OtaHttpRequestComponent::cleanup_(ota::OTABackendPtr backend, const std::shared_ptr<HttpContainer> &container) {
+  if (this->update_started_) {
    ESP_LOGV(TAG, "Aborting OTA backend");
    backend->abort();
  }
@@ -107,8 +106,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
  auto error_code = backend->begin(container->content_length);
  if (error_code != ota::OTA_RESPONSE_OK) {
    ESP_LOGW(TAG, "backend->begin error: %d", error_code);
-    // Nothing to abort: begin() failed, so no OTA handle was opened
-    this->cleanup_(std::move(backend), container, /*abort_backend=*/false);
+    this->cleanup_(std::move(backend), container);
    return error_code;
  }

@@ -142,7 +140,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
      } else {
        ESP_LOGE(TAG, "Error reading data: %d", bufsize_or_error);
      }
-      this->cleanup_(std::move(backend), container, /*abort_backend=*/true);
+      this->cleanup_(std::move(backend), container);
      return OTA_CONNECTION_ERROR;
    }

@@ -152,13 +150,14 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
      md5_receive.add(buf, bufsize_or_error);

      // write bytes to OTA backend
+      this->update_started_ = true;
      error_code = backend->write(buf, bufsize_or_error);
      if (error_code != ota::OTA_RESPONSE_OK) {
        // error code explanation available at
        // https://github.com/esphome/esphome/blob/dev/esphome/components/ota/ota_backend.h
        ESP_LOGE(TAG, "Error code (%02X) writing binary data to flash at offset %d and size %d", error_code,
                 container->get_bytes_read() - bufsize_or_error, container->content_length);
-        this->cleanup_(std::move(backend), container, /*abort_backend=*/true);
+        this->cleanup_(std::move(backend), container);
        return error_code;
      }
    }
@@ -182,7 +181,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
  this->md5_computed_ = md5_receive_str;
  if (strncmp(this->md5_computed_.c_str(), this->md5_expected_.c_str(), MD5_SIZE) != 0) {
    ESP_LOGE(TAG, "MD5 computed: %s - Aborting due to MD5 mismatch", this->md5_computed_.c_str());
-    this->cleanup_(std::move(backend), container, /*abort_backend=*/true);
+    this->cleanup_(std::move(backend), container);
    return ota::OTA_RESPONSE_ERROR_MD5_MISMATCH;
  } else {
    backend->set_update_md5(md5_receive_str);
@@ -198,7 +197,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
  error_code = backend->end();
  if (error_code != ota::OTA_RESPONSE_OK) {
    ESP_LOGW(TAG, "Error ending update! error_code: %d", error_code);
-    this->cleanup_(std::move(backend), container, /*abort_backend=*/true);
+    this->cleanup_(std::move(backend), container);
    return error_code;
  }

@@ -38,7 +38,7 @@ class OtaHttpRequestComponent final : public ota::OTAComponent, public Parented<
  void flash();

 protected:
-  void cleanup_(ota::OTABackendPtr backend, const std::shared_ptr<HttpContainer> &container, bool abort_backend);
+  void cleanup_(ota::OTABackendPtr backend, const std::shared_ptr<HttpContainer> &container);
  uint8_t do_ota_();
  std::string get_url_with_auth_(const std::string &url);
  bool http_get_md5_();
@@ -51,6 +51,7 @@ class OtaHttpRequestComponent final : public ota::OTAComponent, public Parented<
  std::string username_{};
  std::string url_{};
  int status_ = -1;
+  bool update_started_ = false;
  static const uint16_t HTTP_RECV_BUFFER = 256;  // the firmware GET chunk size
 };

@@ -17,9 +17,6 @@ from esphome.const import (
    UNIT_EMPTY,
    UNIT_PERCENT,
 )
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType

 DEPENDENCIES = ["i2c"]

@@ -66,7 +63,7 @@ CONFIG_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 i2c.register_i2c_device(var, config)
@@ -98,12 +95,7 @@ async def to_code(config: ConfigType) -> None:
    ),
    synchronous=True,
 )
-async def set_heater_level_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def set_heater_level_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    level_ = await cg.templatable(config[CONF_LEVEL], args, cg.uint8)
@@ -123,12 +115,7 @@ async def set_heater_level_to_code(
    ),
    synchronous=True,
 )
-async def set_heater_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
+async def set_heater_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    status_ = await cg.templatable(config[CONF_STATUS], args, cg.bool_)
@@ -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(
@@ -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");
@@ -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;
@@ -60,7 +60,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_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 uart.register_uart_device(var, config)
@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
 from esphome.const import CONF_TARGET, DEVICE_CLASS_OCCUPANCY
-from esphome.types import ConfigType

 from . import LD6002BComponent
 from .const import AREA_COUNT, CONF_LD6002B_ID, MAX_TARGETS
@@ -37,7 +36,7 @@ CONFIG_SCHEMA = (
 )


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    hub = await cg.get_variable(config[CONF_LD6002B_ID])

    if target_config := config.get(CONF_TARGET):
@@ -129,7 +129,7 @@ BUTTON_MAP = {
 }


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    for key, button_type in BUTTON_MAP.items():
        if button_config := config.get(key):
            b = cg.new_Pvariable(button_config[CONF_ID], button_type)
@@ -136,7 +136,7 @@ def final_validate(config: ConfigType) -> None:
 FINAL_VALIDATE_SCHEMA = final_validate


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    hub = await cg.get_variable(config[CONF_LD6002B_ID])

    for key, number_type, setter, min_value, max_value, step in (
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	4448cf61e9	Point runtime needle callers at the ESP8266 guard in the doc comment	2026-08-20 18:08:56 -05:00
J. Nick Koston	b1464d594b	Document the literal-only needle constraint of the ESP8266 macro	2026-08-20 18:01:57 -05:00
J. Nick Koston	daaaa13318	Drop the unused non-ESP8266 forward of str_contains_ignore_case_p	2026-08-20 17:59:27 -05:00
J. Nick Koston	cc5916ecca	Use the auto-wrapping macro at the audio call site	2026-08-20 17:56:23 -05:00
J. Nick Koston	3d946596e9	Simplify PROGMEM variant to strncasecmp_P and compile it only on ESP8266	2026-08-20 17:49:02 -05:00
J. Nick Koston	2399a0bb83	Select PSTR needle wrapping per platform like buf_append_str	2026-08-20 17:41:07 -05:00
J. Nick Koston	f3a7b4795b	[core] Add str_contains_ignore_case_p for PROGMEM needle strings	2026-08-20 17:34:39 -05:00