esphome 2025.9.2__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/zwave_proxy/zwave_proxy.cpp

@@ -0,0 +1,346 @@
+#include "zwave_proxy.h"
+#include "esphome/components/api/api_server.h"
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+#include "esphome/core/util.h"
+
+namespace esphome {
+namespace zwave_proxy {
+
+static const char *const TAG = "zwave_proxy";
+
+static constexpr uint8_t ZWAVE_COMMAND_GET_NETWORK_IDS = 0x20;
+// GET_NETWORK_IDS response: [SOF][LENGTH][TYPE][CMD][HOME_ID(4)][NODE_ID][...]
+static constexpr uint8_t ZWAVE_COMMAND_TYPE_RESPONSE = 0x01;    // Response type field value
+static constexpr uint8_t ZWAVE_MIN_GET_NETWORK_IDS_LENGTH = 9;  // TYPE + CMD + HOME_ID(4) + NODE_ID + checksum
+static constexpr uint32_t HOME_ID_TIMEOUT_MS = 100;             // Timeout for waiting for home ID during setup
+
+static uint8_t calculate_frame_checksum(const uint8_t *data, uint8_t length) {
+  // Calculate Z-Wave frame checksum
+  // XOR all bytes between SOF and checksum position (exclusive)
+  // Initial value is 0xFF per Z-Wave protocol specification
+  uint8_t checksum = 0xFF;
+  for (uint8_t i = 1; i < length - 1; i++) {
+    checksum ^= data[i];
+  }
+  return checksum;
+}
+
+ZWaveProxy::ZWaveProxy() { global_zwave_proxy = this; }
+
+void ZWaveProxy::setup() {
+  this->setup_time_ = App.get_loop_component_start_time();
+  this->send_simple_command_(ZWAVE_COMMAND_GET_NETWORK_IDS);
+}
+
+float ZWaveProxy::get_setup_priority() const {
+  // Set up before API so home ID is ready when API starts
+  return setup_priority::BEFORE_CONNECTION;
+}
+
+bool ZWaveProxy::can_proceed() {
+  // If we already have the home ID, we can proceed
+  if (this->home_id_ready_) {
+    return true;
+  }
+
+  // Handle any pending responses
+  if (this->response_handler_()) {
+    ESP_LOGV(TAG, "Handled response during setup");
+  }
+
+  // Process UART data to check for home ID
+  this->process_uart_();
+
+  // Check if we got the home ID after processing
+  if (this->home_id_ready_) {
+    return true;
+  }
+
+  // Wait up to HOME_ID_TIMEOUT_MS for home ID response
+  const uint32_t now = App.get_loop_component_start_time();
+  if (now - this->setup_time_ > HOME_ID_TIMEOUT_MS) {
+    ESP_LOGW(TAG, "Timeout reading Home ID during setup");
+    return true;  // Proceed anyway after timeout
+  }
+
+  return false;  // Keep waiting
+}
+
+void ZWaveProxy::loop() {
+  if (this->response_handler_()) {
+    ESP_LOGV(TAG, "Handled late response");
+  }
+  if (this->api_connection_ != nullptr && (!this->api_connection_->is_connection_setup() || !api_is_connected())) {
+    ESP_LOGW(TAG, "Subscriber disconnected");
+    this->api_connection_ = nullptr;  // Unsubscribe if disconnected
+  }
+
+  this->process_uart_();
+  this->status_clear_warning();
+}
+
+void ZWaveProxy::process_uart_() {
+  while (this->available()) {
+    uint8_t byte;
+    if (!this->read_byte(&byte)) {
+      this->status_set_warning("UART read failed");
+      return;
+    }
+    if (this->parse_byte_(byte)) {
+      // Check if this is a GET_NETWORK_IDS response frame
+      // Frame format: [SOF][LENGTH][TYPE][CMD][HOME_ID(4)][NODE_ID][...]
+      // We verify:
+      // - buffer_[0]: Start of frame marker (0x01)
+      // - buffer_[1]: Length field must be >= 9 to contain all required data
+      // - buffer_[2]: Command type (0x01 for response)
+      // - buffer_[3]: Command ID (0x20 for GET_NETWORK_IDS)
+      if (this->buffer_[3] == ZWAVE_COMMAND_GET_NETWORK_IDS && this->buffer_[2] == ZWAVE_COMMAND_TYPE_RESPONSE &&
+          this->buffer_[1] >= ZWAVE_MIN_GET_NETWORK_IDS_LENGTH && this->buffer_[0] == ZWAVE_FRAME_TYPE_START) {
+        // Store the 4-byte Home ID, which starts at offset 4, and notify connected clients if it changed
+        // The frame parser has already validated the checksum and ensured all bytes are present
+        if (this->set_home_id(&this->buffer_[4])) {
+          this->send_homeid_changed_msg_();
+        }
+      }
+      ESP_LOGV(TAG, "Sending to client: %s", YESNO(this->api_connection_ != nullptr));
+      if (this->api_connection_ != nullptr) {
+        // Zero-copy: point directly to our buffer
+        this->outgoing_proto_msg_.data = this->buffer_.data();
+        if (this->in_bootloader_) {
+          this->outgoing_proto_msg_.data_len = this->buffer_index_;
+        } else {
+          // If this is a data frame, use frame length indicator + 2 (for SoF + checksum), else assume 1 for ACK/NAK/CAN
+          this->outgoing_proto_msg_.data_len = this->buffer_[0] == ZWAVE_FRAME_TYPE_START ? this->buffer_[1] + 2 : 1;
+        }
+        this->api_connection_->send_message(this->outgoing_proto_msg_, api::ZWaveProxyFrame::MESSAGE_TYPE);
+      }
+    }
+  }
+}
+
+void ZWaveProxy::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Z-Wave Proxy:\n"
+                "  Home ID: %s",
+                format_hex_pretty(this->home_id_.data(), this->home_id_.size(), ':', false).c_str());
+}
+
+void ZWaveProxy::api_connection_authenticated(api::APIConnection *conn) {
+  if (this->home_id_ready_) {
+    // If a client just authenticated & HomeID is ready, send the current HomeID
+    this->send_homeid_changed_msg_(conn);
+  }
+}
+
+void ZWaveProxy::zwave_proxy_request(api::APIConnection *api_connection, api::enums::ZWaveProxyRequestType type) {
+  switch (type) {
+    case api::enums::ZWAVE_PROXY_REQUEST_TYPE_SUBSCRIBE:
+      if (this->api_connection_ != nullptr) {
+        ESP_LOGE(TAG, "Only one API subscription is allowed at a time");
+        return;
+      }
+      this->api_connection_ = api_connection;
+      ESP_LOGV(TAG, "API connection is now subscribed");
+      break;
+    case api::enums::ZWAVE_PROXY_REQUEST_TYPE_UNSUBSCRIBE:
+      if (this->api_connection_ != api_connection) {
+        ESP_LOGV(TAG, "API connection is not subscribed");
+        return;
+      }
+      this->api_connection_ = nullptr;
+      break;
+    default:
+      ESP_LOGW(TAG, "Unknown request type: %d", type);
+      break;
+  }
+}
+
+bool ZWaveProxy::set_home_id(const uint8_t *new_home_id) {
+  if (std::memcmp(this->home_id_.data(), new_home_id, this->home_id_.size()) == 0) {
+    ESP_LOGV(TAG, "Home ID unchanged");
+    return false;  // No change
+  }
+  std::memcpy(this->home_id_.data(), new_home_id, this->home_id_.size());
+  ESP_LOGI(TAG, "Home ID: %s", format_hex_pretty(this->home_id_.data(), this->home_id_.size(), ':', false).c_str());
+  this->home_id_ready_ = true;
+  return true;  // Home ID was changed
+}
+
+void ZWaveProxy::send_frame(const uint8_t *data, size_t length) {
+  if (length == 1 && data[0] == this->last_response_) {
+    ESP_LOGV(TAG, "Skipping sending duplicate response: 0x%02X", data[0]);
+    return;
+  }
+  ESP_LOGVV(TAG, "Sending: %s", format_hex_pretty(data, length).c_str());
+  this->write_array(data, length);
+}
+
+void ZWaveProxy::send_homeid_changed_msg_(api::APIConnection *conn) {
+  api::ZWaveProxyRequest msg;
+  msg.type = api::enums::ZWAVE_PROXY_REQUEST_TYPE_HOME_ID_CHANGE;
+  msg.data = this->home_id_.data();
+  msg.data_len = this->home_id_.size();
+  if (conn != nullptr) {
+    // Send to specific connection
+    conn->send_message(msg, api::ZWaveProxyRequest::MESSAGE_TYPE);
+  } else if (api::global_api_server != nullptr) {
+    // We could add code to manage a second subscription type, but, since this message is
+    //  very infrequent and small, we simply send it to all clients
+    api::global_api_server->on_zwave_proxy_request(msg);
+  }
+}
+
+void ZWaveProxy::send_simple_command_(const uint8_t command_id) {
+  // Send a simple Z-Wave command with no parameters
+  // Frame format: [SOF][LENGTH][TYPE][CMD][CHECKSUM]
+  // Where LENGTH=0x03 (3 bytes: TYPE + CMD + CHECKSUM)
+  uint8_t cmd[] = {0x01, 0x03, 0x00, command_id, 0x00};
+  cmd[4] = calculate_frame_checksum(cmd, sizeof(cmd));
+  this->send_frame(cmd, sizeof(cmd));
+}
+
+bool ZWaveProxy::parse_byte_(uint8_t byte) {
+  bool frame_completed = false;
+  // Basic parsing logic for received frames
+  switch (this->parsing_state_) {
+    case ZWAVE_PARSING_STATE_WAIT_START:
+      this->parse_start_(byte);
+      break;
+    case ZWAVE_PARSING_STATE_WAIT_LENGTH:
+      if (!byte) {
+        ESP_LOGW(TAG, "Invalid LENGTH: %u", byte);
+        this->parsing_state_ = ZWAVE_PARSING_STATE_SEND_NAK;
+        return false;
+      }
+      ESP_LOGVV(TAG, "Received LENGTH: %u", byte);
+      this->end_frame_after_ = this->buffer_index_ + byte;
+      ESP_LOGVV(TAG, "Calculated EOF: %u", this->end_frame_after_);
+      this->buffer_[this->buffer_index_++] = byte;
+      this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_TYPE;
+      break;
+    case ZWAVE_PARSING_STATE_WAIT_TYPE:
+      this->buffer_[this->buffer_index_++] = byte;
+      ESP_LOGVV(TAG, "Received TYPE: 0x%02X", byte);
+      this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_COMMAND_ID;
+      break;
+    case ZWAVE_PARSING_STATE_WAIT_COMMAND_ID:
+      this->buffer_[this->buffer_index_++] = byte;
+      ESP_LOGVV(TAG, "Received COMMAND ID: 0x%02X", byte);
+      this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_PAYLOAD;
+      break;
+    case ZWAVE_PARSING_STATE_WAIT_PAYLOAD:
+      this->buffer_[this->buffer_index_++] = byte;
+      ESP_LOGVV(TAG, "Received PAYLOAD: 0x%02X", byte);
+      if (this->buffer_index_ >= this->end_frame_after_) {
+        this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_CHECKSUM;
+      }
+      break;
+    case ZWAVE_PARSING_STATE_WAIT_CHECKSUM: {
+      this->buffer_[this->buffer_index_++] = byte;
+      auto checksum = calculate_frame_checksum(this->buffer_.data(), this->buffer_index_);
+      ESP_LOGVV(TAG, "CHECKSUM Received: 0x%02X - Calculated: 0x%02X", byte, checksum);
+      if (checksum != byte) {
+        ESP_LOGW(TAG, "Bad checksum: expected 0x%02X, got 0x%02X", checksum, byte);
+        this->parsing_state_ = ZWAVE_PARSING_STATE_SEND_NAK;
+      } else {
+        this->parsing_state_ = ZWAVE_PARSING_STATE_SEND_ACK;
+        ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(this->buffer_.data(), this->buffer_index_).c_str());
+        frame_completed = true;
+      }
+      this->response_handler_();
+      break;
+    }
+    case ZWAVE_PARSING_STATE_READ_BL_MENU:
+      this->buffer_[this->buffer_index_++] = byte;
+      if (!byte) {
+        this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START;
+        frame_completed = true;
+      }
+      break;
+    case ZWAVE_PARSING_STATE_SEND_ACK:
+    case ZWAVE_PARSING_STATE_SEND_NAK:
+      break;  // Should not happen, handled in loop()
+    default:
+      ESP_LOGW(TAG, "Bad parsing state; resetting");
+      this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START;
+      break;
+  }
+  return frame_completed;
+}
+
+void ZWaveProxy::parse_start_(uint8_t byte) {
+  this->buffer_index_ = 0;
+  this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START;
+  switch (byte) {
+    case ZWAVE_FRAME_TYPE_START:
+      ESP_LOGVV(TAG, "Received START");
+      if (this->in_bootloader_) {
+        ESP_LOGD(TAG, "Exited bootloader mode");
+        this->in_bootloader_ = false;
+      }
+      this->buffer_[this->buffer_index_++] = byte;
+      this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_LENGTH;
+      return;
+    case ZWAVE_FRAME_TYPE_BL_MENU:
+      ESP_LOGVV(TAG, "Received BL_MENU");
+      if (!this->in_bootloader_) {
+        ESP_LOGD(TAG, "Entered bootloader mode");
+        this->in_bootloader_ = true;
+      }
+      this->buffer_[this->buffer_index_++] = byte;
+      this->parsing_state_ = ZWAVE_PARSING_STATE_READ_BL_MENU;
+      return;
+    case ZWAVE_FRAME_TYPE_BL_BEGIN_UPLOAD:
+      ESP_LOGVV(TAG, "Received BL_BEGIN_UPLOAD");
+      break;
+    case ZWAVE_FRAME_TYPE_ACK:
+      ESP_LOGVV(TAG, "Received ACK");
+      break;
+    case ZWAVE_FRAME_TYPE_NAK:
+      ESP_LOGW(TAG, "Received NAK");
+      break;
+    case ZWAVE_FRAME_TYPE_CAN:
+      ESP_LOGW(TAG, "Received CAN");
+      break;
+    default:
+      ESP_LOGW(TAG, "Unrecognized START: 0x%02X", byte);
+      return;
+  }
+  // Forward response (ACK/NAK/CAN) back to client for processing
+  if (this->api_connection_ != nullptr) {
+    // Store single byte in buffer and point to it
+    this->buffer_[0] = byte;
+    this->outgoing_proto_msg_.data = this->buffer_.data();
+    this->outgoing_proto_msg_.data_len = 1;
+    this->api_connection_->send_message(this->outgoing_proto_msg_, api::ZWaveProxyFrame::MESSAGE_TYPE);
+  }
+}
+
+bool ZWaveProxy::response_handler_() {
+  switch (this->parsing_state_) {
+    case ZWAVE_PARSING_STATE_SEND_ACK:
+      this->last_response_ = ZWAVE_FRAME_TYPE_ACK;
+      break;
+    case ZWAVE_PARSING_STATE_SEND_CAN:
+      this->last_response_ = ZWAVE_FRAME_TYPE_CAN;
+      break;
+    case ZWAVE_PARSING_STATE_SEND_NAK:
+      this->last_response_ = ZWAVE_FRAME_TYPE_NAK;
+      break;
+    default:
+      return false;  // No response handled
+  }
+
+  ESP_LOGVV(TAG, "Sending %s (0x%02X)", this->last_response_ == ZWAVE_FRAME_TYPE_ACK ? "ACK" : "NAK/CAN",
+            this->last_response_);
+  this->write_byte(this->last_response_);
+  this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START;
+  return true;
+}
+
+ZWaveProxy *global_zwave_proxy = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace zwave_proxy
+}  // namespace esphome

esphome/components/zwave_proxy/zwave_proxy.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "esphome/components/api/api_connection.h"
+#include "esphome/components/api/api_pb2.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/uart/uart.h"
+
+#include <array>
+
+namespace esphome {
+namespace zwave_proxy {
+
+static constexpr size_t MAX_ZWAVE_FRAME_SIZE = 257;  // Maximum Z-Wave frame size
+
+enum ZWaveResponseTypes : uint8_t {
+  ZWAVE_FRAME_TYPE_ACK = 0x06,
+  ZWAVE_FRAME_TYPE_CAN = 0x18,
+  ZWAVE_FRAME_TYPE_NAK = 0x15,
+  ZWAVE_FRAME_TYPE_START = 0x01,
+  ZWAVE_FRAME_TYPE_BL_MENU = 0x0D,
+  ZWAVE_FRAME_TYPE_BL_BEGIN_UPLOAD = 0x43,
+};
+
+enum ZWaveParsingState : uint8_t {
+  ZWAVE_PARSING_STATE_WAIT_START,
+  ZWAVE_PARSING_STATE_WAIT_LENGTH,
+  ZWAVE_PARSING_STATE_WAIT_TYPE,
+  ZWAVE_PARSING_STATE_WAIT_COMMAND_ID,
+  ZWAVE_PARSING_STATE_WAIT_PAYLOAD,
+  ZWAVE_PARSING_STATE_WAIT_CHECKSUM,
+  ZWAVE_PARSING_STATE_SEND_ACK,
+  ZWAVE_PARSING_STATE_SEND_CAN,
+  ZWAVE_PARSING_STATE_SEND_NAK,
+  ZWAVE_PARSING_STATE_READ_BL_MENU,
+};
+
+enum ZWaveProxyFeature : uint32_t {
+  FEATURE_ZWAVE_PROXY_ENABLED = 1 << 0,
+};
+
+class ZWaveProxy : public uart::UARTDevice, public Component {
+ public:
+  ZWaveProxy();
+
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  bool can_proceed() override;
+
+  void api_connection_authenticated(api::APIConnection *conn);
+  void zwave_proxy_request(api::APIConnection *api_connection, api::enums::ZWaveProxyRequestType type);
+  api::APIConnection *get_api_connection() { return this->api_connection_; }
+
+  uint32_t get_feature_flags() const { return ZWaveProxyFeature::FEATURE_ZWAVE_PROXY_ENABLED; }
+  uint32_t get_home_id() {
+    return encode_uint32(this->home_id_[0], this->home_id_[1], this->home_id_[2], this->home_id_[3]);
+  }
+  bool set_home_id(const uint8_t *new_home_id);  // Store a new home ID. Returns true if it changed.
+
+  void send_frame(const uint8_t *data, size_t length);
+
+ protected:
+  void send_homeid_changed_msg_(api::APIConnection *conn = nullptr);
+  void send_simple_command_(uint8_t command_id);
+  bool parse_byte_(uint8_t byte);  // Returns true if frame parsing was completed (a frame is ready in the buffer)
+  void parse_start_(uint8_t byte);
+  bool response_handler_();
+  void process_uart_();  // Process all available UART data
+
+  // Pre-allocated message - always ready to send
+  api::ZWaveProxyFrame outgoing_proto_msg_;
+  std::array<uint8_t, MAX_ZWAVE_FRAME_SIZE> buffer_;  // Fixed buffer for incoming data
+  std::array<uint8_t, 4> home_id_{0, 0, 0, 0};        // Fixed buffer for home ID
+
+  // Pointers and 32-bit values (aligned together)
+  api::APIConnection *api_connection_{nullptr};  // Current subscribed client
+  uint32_t setup_time_{0};                       // Time when setup() was called
+
+  // 8-bit values (grouped together to minimize padding)
+  uint8_t buffer_index_{0};     // Index for populating the data buffer
+  uint8_t end_frame_after_{0};  // Payload reception ends after this index
+  uint8_t last_response_{0};    // Last response type sent
+  ZWaveParsingState parsing_state_{ZWAVE_PARSING_STATE_WAIT_START};
+  bool in_bootloader_{false};  // True if the device is detected to be in bootloader mode
+  bool home_id_ready_{false};  // True when home ID has been received from Z-Wave module
+};
+
+extern ZWaveProxy *global_zwave_proxy;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace zwave_proxy
+}  // namespace esphome

esphome/config.py

@@ -32,7 +32,7 @@ from esphome.log import AnsiFore, color
 from esphome.types import ConfigFragmentType, ConfigType
 from esphome.util import OrderedDict, safe_print
 from esphome.voluptuous_schema import ExtraKeysInvalid
-from esphome.yaml_util import ESPForceValue, ESPHomeDataBase, is_secret
+from esphome.yaml_util import ESPHomeDataBase, ESPLiteralValue, is_secret
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -67,6 +67,31 @@ ConfigPath = list[str | int]
 path_context = contextvars.ContextVar("Config path")
 
 
+def _add_auto_load_steps(result: Config, loads: list[str]) -> None:
+    """Add AutoLoadValidationStep for each component in loads that isn't already loaded."""
+    for load in loads:
+        if load not in result:
+            result.add_validation_step(AutoLoadValidationStep(load))
+
+
+def _process_auto_load(
+    result: Config, platform: ComponentManifest, path: ConfigPath
+) -> None:
+    # Process platform's AUTO_LOAD
+    auto_load = platform.auto_load
+    if isinstance(auto_load, list):
+        _add_auto_load_steps(result, auto_load)
+    elif callable(auto_load):
+        import inspect
+
+        if inspect.signature(auto_load).parameters:
+            result.add_validation_step(
+                AddDynamicAutoLoadsValidationStep(path, platform)
+            )
+        else:
+            _add_auto_load_steps(result, auto_load())
+
+
 def _process_platform_config(
     result: Config,
     component_name: str,
@@ -91,9 +116,7 @@ def _process_platform_config(
     CORE.loaded_platforms.add(f"{component_name}/{platform_name}")
 
     # Process platform's AUTO_LOAD
-    for load in platform.auto_load:
-        if load not in result:
-            result.add_validation_step(AutoLoadValidationStep(load))
+    _process_auto_load(result, platform, path)
 
     # Add validation steps for the platform
     p_domain = f"{component_name}.{platform_name}"
@@ -306,7 +329,7 @@ def recursive_check_replaceme(value):
         return cv.Schema([recursive_check_replaceme])(value)
     if isinstance(value, dict):
         return cv.Schema({cv.valid: recursive_check_replaceme})(value)
-    if isinstance(value, ESPForceValue):
+    if isinstance(value, ESPLiteralValue):
         pass
     if isinstance(value, str) and value == "REPLACEME":
         raise cv.Invalid(
@@ -314,7 +337,7 @@ def recursive_check_replaceme(value):
             "Please make sure you have replaced all fields from the sample "
             "configuration.\n"
             "If you want to use the literal REPLACEME string, "
-            'please use "!force REPLACEME"'
+            'please use "!literal REPLACEME"'
         )
     return value
 
@@ -382,11 +405,15 @@ class LoadValidationStep(ConfigValidationStep):
             result.add_str_error(f"Component not found: {self.domain}", path)
             return
         CORE.loaded_integrations.add(self.domain)
+        # For platform components, normalize conf before creating MetadataValidationStep
+        if component.is_platform_component:
+            if not self.conf:
+                result[self.domain] = self.conf = []
+            elif not isinstance(self.conf, list):
+                result[self.domain] = self.conf = [self.conf]
 
         # Process AUTO_LOAD
-        for load in component.auto_load:
-            if load not in result:
-                result.add_validation_step(AutoLoadValidationStep(load))
+        _process_auto_load(result, component, path)
 
         result.add_validation_step(
             MetadataValidationStep([self.domain], self.domain, self.conf, component)
@@ -399,12 +426,6 @@ class LoadValidationStep(ConfigValidationStep):
         # Remove this is as an output path
         result.remove_output_path([self.domain], self.domain)
 
-        # Ensure conf is a list
-        if not self.conf:
-            result[self.domain] = self.conf = []
-        elif not isinstance(self.conf, list):
-            result[self.domain] = self.conf = [self.conf]
-
         for i, p_config in enumerate(self.conf):
             path = [self.domain, i]
             # Construct temporary unknown output path
@@ -618,6 +639,34 @@ class MetadataValidationStep(ConfigValidationStep):
         result.add_validation_step(FinalValidateValidationStep(self.path, self.comp))
 
 
+class AddDynamicAutoLoadsValidationStep(ConfigValidationStep):
+    """Add dynamic auto loads step.
+
+    This step is used to auto-load components where one component can alter its
+    AUTO_LOAD based on its configuration.
+    """
+
+    # Has to happen after normal schema is validated and before final schema validation
+    priority = -5.0
+
+    def __init__(self, path: ConfigPath, comp: ComponentManifest) -> None:
+        self.path = path
+        self.comp = comp
+
+    def run(self, result: Config) -> None:
+        if result.errors:
+            # If result already has errors, skip this step
+            return
+
+        conf = result.get_nested_item(self.path)
+        with result.catch_error(self.path):
+            auto_load = self.comp.auto_load
+            if not callable(auto_load):
+                return
+            loads = auto_load(conf)
+            _add_auto_load_steps(result, loads)
+
+
 class SchemaValidationStep(ConfigValidationStep):
     """Schema validation step.
 
@@ -846,7 +895,9 @@ class PinUseValidationCheck(ConfigValidationStep):
 
 
 def validate_config(
-    config: dict[str, Any], command_line_substitutions: dict[str, Any]
+    config: dict[str, Any],
+    command_line_substitutions: dict[str, Any],
+    skip_external_update: bool = False,
 ) -> Config:
     result = Config()
 
@@ -859,7 +910,7 @@ def validate_config(
 
         result.add_output_path([CONF_PACKAGES], CONF_PACKAGES)
         try:
-            config = do_packages_pass(config)
+            config = do_packages_pass(config, skip_update=skip_external_update)
         except vol.Invalid as err:
             result.update(config)
             result.add_error(err)
@@ -896,7 +947,7 @@ def validate_config(
 
         result.add_output_path([CONF_EXTERNAL_COMPONENTS], CONF_EXTERNAL_COMPONENTS)
         try:
-            do_external_components_pass(config)
+            do_external_components_pass(config, skip_update=skip_external_update)
         except vol.Invalid as err:
             result.update(config)
             result.add_error(err)
@@ -1020,7 +1071,9 @@ class InvalidYAMLError(EsphomeError):
         self.base_exc = base_exc
 
 
-def _load_config(command_line_substitutions: dict[str, Any]) -> Config:
+def _load_config(
+    command_line_substitutions: dict[str, Any], skip_external_update: bool = False
+) -> Config:
     """Load the configuration file."""
     try:
         config = yaml_util.load_yaml(CORE.config_path)
@@ -1028,7 +1081,7 @@ def _load_config(command_line_substitutions: dict[str, Any]) -> Config:
         raise InvalidYAMLError(e) from e
 
     try:
-        return validate_config(config, command_line_substitutions)
+        return validate_config(config, command_line_substitutions, skip_external_update)
     except EsphomeError:
         raise
     except Exception:
@@ -1036,9 +1089,11 @@ def _load_config(command_line_substitutions: dict[str, Any]) -> Config:
         raise
 
 
-def load_config(command_line_substitutions: dict[str, Any]) -> Config:
+def load_config(
+    command_line_substitutions: dict[str, Any], skip_external_update: bool = False
+) -> Config:
     try:
-        return _load_config(command_line_substitutions)
+        return _load_config(command_line_substitutions, skip_external_update)
     except vol.Invalid as err:
         raise EsphomeError(f"Error while parsing config: {err}") from err
 
@@ -1178,10 +1233,10 @@ def strip_default_ids(config):
     return config
 
 
-def read_config(command_line_substitutions):
+def read_config(command_line_substitutions, skip_external_update=False):
     _LOGGER.info("Reading configuration %s...", CORE.config_path)
     try:
-        res = load_config(command_line_substitutions)
+        res = load_config(command_line_substitutions, skip_external_update)
     except EsphomeError as err:
         _LOGGER.error("Error while reading config: %s", err)
         return None