wifi fixed vector

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/ci.yml

@@ -433,7 +433,7 @@ jobs:
     if: github.event_name == 'pull_request' && fromJSON(needs.determine-jobs.outputs.component-test-count) >= 100
     strategy:
       fail-fast: false
-      max-parallel: ${{ (github.base_ref == 'beta' || github.base_ref == 'release') && 8 || 4 }}
+      max-parallel: 5
       matrix:
         components: ${{ fromJson(needs.test-build-components-splitter.outputs.matrix) }}
     steps:

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
+        uses: github/codeql-action/init@f443b600d91635bebf5b0d9ebc620189c0d6fba5 # v4.30.8
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
+        uses: github/codeql-action/analyze@f443b600d91635bebf5b0d9ebc620189c0d6fba5 # v4.30.8
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/stale.yml

@@ -23,7 +23,7 @@ jobs:
         with:
           debug-only: ${{ github.ref != 'refs/heads/dev' }} # Dry-run when not run on dev branch
           remove-stale-when-updated: true
-          operations-per-run: 150
+          operations-per-run: 400
 
           # The 90 day stale policy for PRs
           # - PRs

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.10.2
+PROJECT_NUMBER         = 2025.11.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/__main__.py

@@ -117,17 +117,6 @@ class Purpose(StrEnum):
     LOGGING = "logging"
 
 
-class PortType(StrEnum):
-    SERIAL = "SERIAL"
-    NETWORK = "NETWORK"
-    MQTT = "MQTT"
-    MQTTIP = "MQTTIP"
-
-
-# Magic MQTT port types that require special handling
-_MQTT_PORT_TYPES = frozenset({PortType.MQTT, PortType.MQTTIP})
-
-
 def _resolve_with_cache(address: str, purpose: Purpose) -> list[str]:
     """Resolve an address using cache if available, otherwise return the address itself."""
     if CORE.address_cache and (cached := CORE.address_cache.get_addresses(address)):
@@ -185,9 +174,7 @@ def choose_upload_log_host(
             else:
                 resolved.append(device)
         if not resolved:
-            raise EsphomeError(
-                f"All specified devices {defaults} could not be resolved. Is the device connected to the network?"
-            )
+            _LOGGER.error("All specified devices: %s could not be resolved.", defaults)
         return resolved
 
     # No devices specified, show interactive chooser
@@ -281,10 +268,8 @@ def has_ip_address() -> bool:
 
 
 def has_resolvable_address() -> bool:
-    """Check if CORE.address is resolvable (via mDNS, DNS, or is an IP address)."""
-    # Any address (IP, mDNS hostname, or regular DNS hostname) is resolvable
-    # The resolve_ip_address() function in helpers.py handles all types via AsyncResolver
-    return CORE.address is not None
+    """Check if CORE.address is resolvable (via mDNS or is an IP address)."""
+    return has_mdns() or has_ip_address()
 
 
 def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str):
@@ -293,67 +278,16 @@ def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str
     return mqtt.get_esphome_device_ip(config, username, password, client_id)
 
 
-def _resolve_network_devices(
-    devices: list[str], config: ConfigType, args: ArgsProtocol
-) -> list[str]:
-    """Resolve device list, converting MQTT magic strings to actual IP addresses.
-
-    This function filters the devices list to:
-    - Replace MQTT/MQTTIP magic strings with actual IP addresses via MQTT lookup
-    - Deduplicate addresses while preserving order
-    - Only resolve MQTT once even if multiple MQTT strings are present
-    - If MQTT resolution fails, log a warning and continue with other devices
-
-    Args:
-        devices: List of device identifiers (IPs, hostnames, or magic strings)
-        config: ESPHome configuration
-        args: Command-line arguments containing MQTT credentials
-
-    Returns:
-        List of network addresses suitable for connection attempts
-    """
-    network_devices: list[str] = []
-    mqtt_resolved: bool = False
-
-    for device in devices:
-        port_type = get_port_type(device)
-        if port_type in _MQTT_PORT_TYPES:
-            # Only resolve MQTT once, even if multiple MQTT entries
-            if not mqtt_resolved:
-                try:
-                    mqtt_ips = mqtt_get_ip(
-                        config, args.username, args.password, args.client_id
-                    )
-                    network_devices.extend(mqtt_ips)
-                except EsphomeError as err:
-                    _LOGGER.warning(
-                        "MQTT IP discovery failed (%s), will try other devices if available",
-                        err,
-                    )
-                mqtt_resolved = True
-        elif device not in network_devices:
-            # Regular network address or IP - add if not already present
-            network_devices.append(device)
-
-    return network_devices
+_PORT_TO_PORT_TYPE = {
+    "MQTT": "MQTT",
+    "MQTTIP": "MQTTIP",
+}
 
 
-def get_port_type(port: str) -> PortType:
-    """Determine the type of port/device identifier.
-
-    Returns:
-        PortType.SERIAL for serial ports (/dev/ttyUSB0, COM1, etc.)
-        PortType.MQTT for MQTT logging
-        PortType.MQTTIP for MQTT IP lookup
-        PortType.NETWORK for IP addresses, hostnames, or mDNS names
-    """
+def get_port_type(port: str) -> str:
     if port.startswith("/") or port.startswith("COM"):
-        return PortType.SERIAL
-    if port == "MQTT":
-        return PortType.MQTT
-    if port == "MQTTIP":
-        return PortType.MQTTIP
-    return PortType.NETWORK
+        return "SERIAL"
+    return _PORT_TO_PORT_TYPE.get(port, "NETWORK")
 
 
 def run_miniterm(config: ConfigType, port: str, args) -> int:
@@ -553,7 +487,7 @@ def upload_using_platformio(config: ConfigType, port: str):
 
 
 def check_permissions(port: str):
-    if os.name == "posix" and get_port_type(port) == PortType.SERIAL:
+    if os.name == "posix" and get_port_type(port) == "SERIAL":
         # Check if we can open selected serial port
         if not os.access(port, os.F_OK):
             raise EsphomeError(
@@ -581,7 +515,7 @@ def upload_program(
     except AttributeError:
         pass
 
-    if get_port_type(host) == PortType.SERIAL:
+    if get_port_type(host) == "SERIAL":
         check_permissions(host)
 
         exit_code = 1
@@ -608,16 +542,17 @@ def upload_program(
     from esphome import espota2
 
     remote_port = int(ota_conf[CONF_PORT])
-    password = ota_conf.get(CONF_PASSWORD)
+    password = ota_conf.get(CONF_PASSWORD, "")
     if getattr(args, "file", None) is not None:
         binary = Path(args.file)
     else:
         binary = CORE.firmware_bin
 
-    # Resolve MQTT magic strings to actual IP addresses
-    network_devices = _resolve_network_devices(devices, config, args)
+    # MQTT address resolution
+    if get_port_type(host) in ("MQTT", "MQTTIP"):
+        devices = mqtt_get_ip(config, args.username, args.password, args.client_id)
 
-    return espota2.run_ota(network_devices, remote_port, password, binary)
+    return espota2.run_ota(devices, remote_port, password, binary)
 
 
 def show_logs(config: ConfigType, args: ArgsProtocol, devices: list[str]) -> int | None:
@@ -632,22 +567,32 @@ def show_logs(config: ConfigType, args: ArgsProtocol, devices: list[str]) -> int
         raise EsphomeError("Logger is not configured!")
 
     port = devices[0]
-    port_type = get_port_type(port)
 
-    if port_type == PortType.SERIAL:
+    if get_port_type(port) == "SERIAL":
         check_permissions(port)
         return run_miniterm(config, port, args)
 
+    port_type = get_port_type(port)
+
     # Check if we should use API for logging
-    # Resolve MQTT magic strings to actual IP addresses
-    if has_api() and (
-        network_devices := _resolve_network_devices(devices, config, args)
-    ):
-        from esphome.components.api.client import run_logs
+    if has_api():
+        addresses_to_use: list[str] | None = None
 
-        return run_logs(config, network_devices)
+        if port_type == "NETWORK" and (has_mdns() or is_ip_address(port)):
+            addresses_to_use = devices
+        elif port_type in ("NETWORK", "MQTT", "MQTTIP") and has_mqtt_ip_lookup():
+            # Only use MQTT IP lookup if the first condition didn't match
+            # (for MQTT/MQTTIP types, or for NETWORK when mdns/ip check fails)
+            addresses_to_use = mqtt_get_ip(
+                config, args.username, args.password, args.client_id
+            )
 
-    if port_type in (PortType.NETWORK, PortType.MQTT) and has_mqtt_logging():
+        if addresses_to_use is not None:
+            from esphome.components.api.client import run_logs
+
+            return run_logs(config, addresses_to_use)
+
+    if port_type in ("NETWORK", "MQTT") and has_mqtt_logging():
         from esphome import mqtt
 
         return mqtt.show_logs(

esphome/components/bme680_bsec/__init__.py

@@ -41,7 +41,7 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(BME680BSECComponent),
-            cv.Optional(CONF_TEMPERATURE_OFFSET, default=0): cv.temperature_delta,
+            cv.Optional(CONF_TEMPERATURE_OFFSET, default=0): cv.temperature,
             cv.Optional(CONF_IAQ_MODE, default="STATIC"): cv.enum(
                 IAQ_MODE_OPTIONS, upper=True
             ),

esphome/components/bme68x_bsec2/__init__.py

@@ -139,7 +139,7 @@ CONFIG_SCHEMA_BASE = (
             cv.Optional(CONF_SUPPLY_VOLTAGE, default="3.3V"): cv.enum(
                 VOLTAGE_OPTIONS, upper=True
             ),
-            cv.Optional(CONF_TEMPERATURE_OFFSET, default=0): cv.temperature_delta,
+            cv.Optional(CONF_TEMPERATURE_OFFSET, default=0): cv.temperature,
             cv.Optional(
                 CONF_STATE_SAVE_INTERVAL, default="6hours"
             ): cv.positive_time_period_minutes,

esphome/components/datetime/datetime_base.h

@@ -30,12 +30,14 @@ class DateTimeBase : public EntityBase {
 #endif
 };
 
+#ifdef USE_TIME
 class DateTimeStateTrigger : public Trigger<ESPTime> {
  public:
   explicit DateTimeStateTrigger(DateTimeBase *parent) {
     parent->add_on_state_callback([this, parent]() { this->trigger(parent->state_as_esptime()); });
   }
 };
+#endif
 
 }  // namespace datetime
 }  // namespace esphome

esphome/components/display/display.cpp

@@ -775,7 +775,7 @@ void Display::test_card() {
     int shift_y = (h - image_h) / 2;
     int line_w = (image_w - 6) / 6;
     int image_c = image_w / 2;
-    for (auto i = 0; i != image_h; i++) {
+    for (auto i = 0; i <= image_h; i++) {
       int c = esp_scale(i, image_h);
       this->horizontal_line(shift_x + 0, shift_y + i, line_w, r.fade_to_white(c));
       this->horizontal_line(shift_x + line_w, shift_y + i, line_w, r.fade_to_black(c));  //
@@ -809,11 +809,8 @@ void Display::test_card() {
       }
     }
   }
+  this->rectangle(0, 0, w, h, Color(127, 0, 127));
   this->filled_rectangle(0, 0, 10, 10, Color(255, 0, 255));
-  this->filled_rectangle(w - 10, 0, 10, 10, Color(255, 0, 255));
-  this->filled_rectangle(0, h - 10, 10, 10, Color(255, 0, 255));
-  this->filled_rectangle(w - 10, h - 10, 10, 10, Color(255, 0, 255));
-  this->rectangle(0, 0, w, h, Color(255, 255, 255));
   this->stop_poller();
 }
 

esphome/components/esp32/__init__.py

@@ -304,6 +304,17 @@ def _format_framework_espidf_version(ver: cv.Version, release: str) -> str:
     return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}/esp-idf-v{str(ver)}.zip"
 
 
+def _is_framework_url(source: str) -> str:
+    # platformio accepts many URL schemes for framework repositories and archives including http, https, git, file, and symlink
+    import urllib.parse
+
+    try:
+        parsed = urllib.parse.urlparse(source)
+    except ValueError:
+        return False
+    return bool(parsed.scheme)
+
+
 # NOTE: Keep this in mind when updating the recommended version:
 #  * New framework historically have had some regressions, especially for WiFi.
 #    The new version needs to be thoroughly validated before changing the
@@ -387,7 +398,7 @@ def _check_versions(value):
         value[CONF_SOURCE] = value.get(
             CONF_SOURCE, _format_framework_arduino_version(version)
         )
-        if value[CONF_SOURCE].startswith("http"):
+        if _is_framework_url(value[CONF_SOURCE]):
             value[CONF_SOURCE] = (
                 f"pioarduino/framework-arduinoespressif32@{value[CONF_SOURCE]}"
             )
@@ -400,7 +411,7 @@ def _check_versions(value):
             CONF_SOURCE,
             _format_framework_espidf_version(version, value.get(CONF_RELEASE, None)),
         )
-        if value[CONF_SOURCE].startswith("http"):
+        if _is_framework_url(value[CONF_SOURCE]):
             value[CONF_SOURCE] = f"pioarduino/framework-espidf@{value[CONF_SOURCE]}"
 
     if CONF_PLATFORM_VERSION not in value:
@@ -790,7 +801,6 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_AUTOSTART_ARDUINO", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
-        add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
 
     cg.add_build_flag("-Wno-nonnull-compare")
 

esphome/components/esp32/core.cpp

@@ -6,7 +6,6 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <esp_idf_version.h>
-#include <esp_ota_ops.h>
 #include <esp_task_wdt.h>
 #include <esp_timer.h>
 #include <soc/rtc.h>
@@ -53,16 +52,6 @@ void arch_init() {
   disableCore1WDT();
 #endif
 #endif
-
-  // If the bootloader was compiled with CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE the current
-  // partition will get rolled back unless it is marked as valid.
-  esp_ota_img_states_t state;
-  const esp_partition_t *running = esp_ota_get_running_partition();
-  if (esp_ota_get_state_partition(running, &state) == ESP_OK) {
-    if (state == ESP_OTA_IMG_PENDING_VERIFY) {
-      esp_ota_mark_app_valid_cancel_rollback();
-    }
-  }
 }
 void IRAM_ATTR HOT arch_feed_wdt() { esp_task_wdt_reset(); }
 

esphome/components/esp32_ble_tracker/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 import logging
 
 from esphome import automation
@@ -52,9 +53,19 @@ class BLEFeatures(StrEnum):
     ESP_BT_DEVICE = "ESP_BT_DEVICE"
 
 
+# Dataclass for registration counts
+@dataclass
+class RegistrationCounts:
+    listeners: int = 0
+    clients: int = 0
+
+
 # Set to track which features are needed by components
 _required_features: set[BLEFeatures] = set()
 
+# Track registration counts for StaticVector sizing
+_registration_counts = RegistrationCounts()
+
 
 def register_ble_features(features: set[BLEFeatures]) -> None:
     """Register BLE features that a component needs.
@@ -257,12 +268,14 @@ async def to_code(config):
         register_ble_features({BLEFeatures.ESP_BT_DEVICE})
 
     for conf in config.get(CONF_ON_BLE_ADVERTISE, []):
+        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if CONF_MAC_ADDRESS in conf:
             addr_list = [it.as_hex for it in conf[CONF_MAC_ADDRESS]]
             cg.add(trigger.set_addresses(addr_list))
         await automation.build_automation(trigger, [(ESPBTDeviceConstRef, "x")], conf)
     for conf in config.get(CONF_ON_BLE_SERVICE_DATA_ADVERTISE, []):
+        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if len(conf[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
             cg.add(trigger.set_service_uuid16(as_hex(conf[CONF_SERVICE_UUID])))
@@ -275,6 +288,7 @@ async def to_code(config):
             cg.add(trigger.set_address(conf[CONF_MAC_ADDRESS].as_hex))
         await automation.build_automation(trigger, [(adv_data_t_const_ref, "x")], conf)
     for conf in config.get(CONF_ON_BLE_MANUFACTURER_DATA_ADVERTISE, []):
+        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if len(conf[CONF_MANUFACTURER_ID]) == len(bt_uuid16_format):
             cg.add(trigger.set_manufacturer_uuid16(as_hex(conf[CONF_MANUFACTURER_ID])))
@@ -287,6 +301,7 @@ async def to_code(config):
             cg.add(trigger.set_address(conf[CONF_MAC_ADDRESS].as_hex))
         await automation.build_automation(trigger, [(adv_data_t_const_ref, "x")], conf)
     for conf in config.get(CONF_ON_SCAN_END, []):
+        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
 
@@ -320,6 +335,17 @@ async def _add_ble_features():
         cg.add_define("USE_ESP32_BLE_DEVICE")
         cg.add_define("USE_ESP32_BLE_UUID")
 
+    # Add defines for StaticVector sizing based on registration counts
+    # Only define if count > 0 to avoid allocating unnecessary memory
+    if _registration_counts.listeners > 0:
+        cg.add_define(
+            "ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT", _registration_counts.listeners
+        )
+    if _registration_counts.clients > 0:
+        cg.add_define(
+            "ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT", _registration_counts.clients
+        )
+
 
 ESP32_BLE_START_SCAN_ACTION_SCHEMA = cv.Schema(
     {
@@ -369,6 +395,7 @@ async def register_ble_device(
     var: cg.SafeExpType, config: ConfigType
 ) -> cg.SafeExpType:
     register_ble_features({BLEFeatures.ESP_BT_DEVICE})
+    _registration_counts.listeners += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_listener(var))
     return var
@@ -376,6 +403,7 @@ async def register_ble_device(
 
 async def register_client(var: cg.SafeExpType, config: ConfigType) -> cg.SafeExpType:
     register_ble_features({BLEFeatures.ESP_BT_DEVICE})
+    _registration_counts.clients += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_client(var))
     return var
@@ -389,6 +417,7 @@ async def register_raw_ble_device(
     This does NOT register the ESP_BT_DEVICE feature, meaning ESPBTDevice
     will not be compiled in if this is the only registration method used.
     """
+    _registration_counts.listeners += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_listener(var))
     return var
@@ -402,6 +431,7 @@ async def register_raw_client(
     This does NOT register the ESP_BT_DEVICE feature, meaning ESPBTDevice
     will not be compiled in if this is the only registration method used.
     """
+    _registration_counts.clients += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_client(var))
     return var

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -74,9 +74,11 @@ void ESP32BLETracker::setup() {
       [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
         if (state == ota::OTA_STARTED) {
           this->stop_scan();
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
           for (auto *client : this->clients_) {
             client->disconnect();
           }
+#endif
         }
       });
 #endif
@@ -206,8 +208,10 @@ void ESP32BLETracker::start_scan_(bool first) {
   this->set_scanner_state_(ScannerState::STARTING);
   ESP_LOGD(TAG, "Starting scan, set scanner state to STARTING.");
   if (!first) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
     for (auto *listener : this->listeners_)
       listener->on_scan_end();
+#endif
   }
 #ifdef USE_ESP32_BLE_DEVICE
   this->already_discovered_.clear();
@@ -236,20 +240,25 @@ void ESP32BLETracker::start_scan_(bool first) {
 }
 
 void ESP32BLETracker::register_client(ESPBTClient *client) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   client->app_id = ++this->app_id_;
   this->clients_.push_back(client);
   this->recalculate_advertisement_parser_types();
+#endif
 }
 
 void ESP32BLETracker::register_listener(ESPBTDeviceListener *listener) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   listener->set_parent(this);
   this->listeners_.push_back(listener);
   this->recalculate_advertisement_parser_types();
+#endif
 }
 
 void ESP32BLETracker::recalculate_advertisement_parser_types() {
   this->raw_advertisements_ = false;
   this->parse_advertisements_ = false;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   for (auto *listener : this->listeners_) {
     if (listener->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
       this->parse_advertisements_ = true;
@@ -257,6 +266,8 @@ void ESP32BLETracker::recalculate_advertisement_parser_types() {
       this->raw_advertisements_ = true;
     }
   }
+#endif
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     if (client->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
       this->parse_advertisements_ = true;
@@ -264,6 +275,7 @@ void ESP32BLETracker::recalculate_advertisement_parser_types() {
       this->raw_advertisements_ = true;
     }
   }
+#endif
 }
 
 void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
@@ -282,10 +294,12 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
     default:
       break;
   }
-  // Forward all events to clients (scan results are handled separately via gap_scan_event_handler)
+    // Forward all events to clients (scan results are handled separately via gap_scan_event_handler)
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     client->gap_event_handler(event, param);
   }
+#endif
 }
 
 void ESP32BLETracker::gap_scan_event_handler(const BLEScanResult &scan_result) {
@@ -348,9 +362,11 @@ void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_
 
 void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                           esp_ble_gattc_cb_param_t *param) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     client->gattc_event_handler(event, gattc_if, param);
   }
+#endif
 }
 
 void ESP32BLETracker::set_scanner_state_(ScannerState state) {
@@ -704,12 +720,16 @@ bool ESPBTDevice::resolve_irk(const uint8_t *irk) const {
 void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
   // Process raw advertisements
   if (this->raw_advertisements_) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
     for (auto *listener : this->listeners_) {
       listener->parse_devices(&scan_result, 1);
     }
+#endif
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
     for (auto *client : this->clients_) {
       client->parse_devices(&scan_result, 1);
     }
+#endif
   }
 
   // Process parsed advertisements
@@ -719,16 +739,20 @@ void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
     device.parse_scan_rst(scan_result);
 
     bool found = false;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
     for (auto *listener : this->listeners_) {
       if (listener->parse_device(device))
         found = true;
     }
+#endif
 
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
     for (auto *client : this->clients_) {
       if (client->parse_device(device)) {
         found = true;
       }
     }
+#endif
 
     if (!found && !this->scan_continuous_) {
       this->print_bt_device_info(device);
@@ -745,8 +769,10 @@ void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {
   // Reset timeout state machine instead of cancelling scheduler timeout
   this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
 
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   for (auto *listener : this->listeners_)
     listener->on_scan_end();
+#endif
 
   this->set_scanner_state_(ScannerState::IDLE);
 }
@@ -770,6 +796,7 @@ void ESP32BLETracker::handle_scanner_failure_() {
 
 void ESP32BLETracker::try_promote_discovered_clients_() {
   // Only promote the first discovered client to avoid multiple simultaneous connections
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     if (client->state() != ClientState::DISCOVERED) {
       continue;
@@ -791,6 +818,7 @@ void ESP32BLETracker::try_promote_discovered_clients_() {
     client->connect();
     break;
   }
+#endif
 }
 
 const char *ESP32BLETracker::scanner_state_to_string_(ScannerState state) const {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -302,6 +302,7 @@ class ESP32BLETracker : public Component,
   /// Count clients in each state
   ClientStateCounts count_client_states_() const {
     ClientStateCounts counts;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
     for (auto *client : this->clients_) {
       switch (client->state()) {
         case ClientState::DISCONNECTING:
@@ -317,12 +318,17 @@ class ESP32BLETracker : public Component,
           break;
       }
     }
+#endif
     return counts;
   }
 
   // Group 1: Large objects (12+ bytes) - vectors and callback manager
-  std::vector<ESPBTDeviceListener *> listeners_;
-  std::vector<ESPBTClient *> clients_;
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
+  StaticVector<ESPBTDeviceListener *, ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT> listeners_;
+#endif
+#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  StaticVector<ESPBTClient *, ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT> clients_;
+#endif
   CallbackManager<void(ScannerState)> scanner_state_callbacks_;
 #ifdef USE_ESP32_BLE_DEVICE
   /// Vector of addresses that have already been printed in print_bt_device_info

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -143,7 +143,6 @@ void ESP32ImprovComponent::loop() {
 #else
       this->set_state_(improv::STATE_AUTHORIZED);
 #endif
-      this->check_wifi_connection_();
       break;
     }
     case improv::STATE_AUTHORIZED: {
@@ -157,12 +156,31 @@ void ESP32ImprovComponent::loop() {
       if (!this->check_identify_()) {
         this->set_status_indicator_state_((now % 1000) < 500);
       }
-      this->check_wifi_connection_();
       break;
     }
     case improv::STATE_PROVISIONING: {
       this->set_status_indicator_state_((now % 200) < 100);
-      this->check_wifi_connection_();
+      if (wifi::global_wifi_component->is_connected()) {
+        wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(),
+                                                   this->connecting_sta_.get_password());
+        this->connecting_sta_ = {};
+        this->cancel_timeout("wifi-connect-timeout");
+        this->set_state_(improv::STATE_PROVISIONED);
+
+        std::vector<std::string> urls = {ESPHOME_MY_LINK};
+#ifdef USE_WEBSERVER
+        for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
+          if (ip.is_ip4()) {
+            std::string webserver_url = "http://" + ip.str() + ":" + to_string(USE_WEBSERVER_PORT);
+            urls.push_back(webserver_url);
+            break;
+          }
+        }
+#endif
+        std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, urls);
+        this->send_response_(data);
+        this->stop();
+      }
       break;
     }
     case improv::STATE_PROVISIONED: {
@@ -374,36 +392,6 @@ void ESP32ImprovComponent::on_wifi_connect_timeout_() {
   wifi::global_wifi_component->clear_sta();
 }
 
-void ESP32ImprovComponent::check_wifi_connection_() {
-  if (!wifi::global_wifi_component->is_connected()) {
-    return;
-  }
-
-  if (this->state_ == improv::STATE_PROVISIONING) {
-    wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(), this->connecting_sta_.get_password());
-    this->connecting_sta_ = {};
-    this->cancel_timeout("wifi-connect-timeout");
-
-    std::vector<std::string> urls = {ESPHOME_MY_LINK};
-#ifdef USE_WEBSERVER
-    for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
-      if (ip.is_ip4()) {
-        std::string webserver_url = "http://" + ip.str() + ":" + to_string(USE_WEBSERVER_PORT);
-        urls.push_back(webserver_url);
-        break;
-      }
-    }
-#endif
-    std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, urls);
-    this->send_response_(data);
-  } else if (this->is_active() && this->state_ != improv::STATE_PROVISIONED) {
-    ESP_LOGD(TAG, "WiFi provisioned externally");
-  }
-
-  this->set_state_(improv::STATE_PROVISIONED);
-  this->stop();
-}
-
 void ESP32ImprovComponent::advertise_service_data_() {
   uint8_t service_data[IMPROV_SERVICE_DATA_SIZE] = {};
   service_data[0] = IMPROV_PROTOCOL_ID_1;  // PR

esphome/components/esp32_improv/esp32_improv_component.h

@@ -111,7 +111,6 @@ class ESP32ImprovComponent : public Component {
   void send_response_(std::vector<uint8_t> &response);
   void process_incoming_data_();
   void on_wifi_connect_timeout_();
-  void check_wifi_connection_();
   bool check_identify_();
   void advertise_service_data_();
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG

esphome/components/esphome/ota/__init__.py

@@ -19,7 +19,6 @@ from esphome.const import (
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
 import esphome.final_validate as fv
-from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -137,12 +136,11 @@ FINAL_VALIDATE_SCHEMA = ota_esphome_final_validate
 
 
 @coroutine_with_priority(CoroPriority.OTA_UPDATES)
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     cg.add(var.set_port(config[CONF_PORT]))
 
-    # Password could be set to an empty string and we can assume that means no password
-    if config.get(CONF_PASSWORD):
+    if CONF_PASSWORD in config:
         cg.add(var.set_auth_password(config[CONF_PASSWORD]))
         cg.add_define("USE_OTA_PASSWORD")
         # Only include hash algorithms when password is configured

esphome/components/esphome/ota/ota_esphome.cpp

@@ -29,7 +29,7 @@ namespace esphome {
 static const char *const TAG = "esphome.ota";
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
 static constexpr size_t OTA_BUFFER_SIZE = 1024;                  // buffer size for OTA data transfer
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
+static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 10000;  // milliseconds for initial handshake
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer
 
 #ifdef USE_OTA_PASSWORD

esphome/components/htu21d/htu21d.cpp

@@ -9,8 +9,8 @@ static const char *const TAG = "htu21d";
 
 static const uint8_t HTU21D_ADDRESS = 0x40;
 static const uint8_t HTU21D_REGISTER_RESET = 0xFE;
-static const uint8_t HTU21D_REGISTER_TEMPERATURE = 0xF3;
-static const uint8_t HTU21D_REGISTER_HUMIDITY = 0xF5;
+static const uint8_t HTU21D_REGISTER_TEMPERATURE = 0xE3;
+static const uint8_t HTU21D_REGISTER_HUMIDITY = 0xE5;
 static const uint8_t HTU21D_WRITERHT_REG_CMD = 0xE6; /**< Write RH/T User Register 1 */
 static const uint8_t HTU21D_REGISTER_STATUS = 0xE7;
 static const uint8_t HTU21D_WRITEHEATER_REG_CMD = 0x51; /**< Write Heater Control Register */

esphome/components/mipi/__init__.py

@@ -11,7 +11,6 @@ from esphome.const import (
     CONF_BRIGHTNESS,
     CONF_COLOR_ORDER,
     CONF_DIMENSIONS,
-    CONF_DISABLED,
     CONF_HEIGHT,
     CONF_INIT_SEQUENCE,
     CONF_INVERT_COLORS,
@@ -302,8 +301,6 @@ class DriverChip:
         Check if a rotation can be implemented in hardware using the MADCTL register.
         A rotation of 180 is always possible if x and y mirroring are supported, 90 and 270 are possible if the model supports swapping X and Y.
         """
-        if config.get(CONF_TRANSFORM) == CONF_DISABLED:
-            return False
         transforms = self.transforms
         rotation = config.get(CONF_ROTATION, 0)
         if rotation == 0 or not transforms:
@@ -361,26 +358,26 @@ class DriverChip:
                 CONF_SWAP_XY: self.get_default(CONF_SWAP_XY),
             },
         )
-        if not isinstance(transform, dict):
-            # Presumably disabled
-            return {
-                CONF_MIRROR_X: False,
-                CONF_MIRROR_Y: False,
-                CONF_SWAP_XY: False,
-                CONF_TRANSFORM: False,
-            }
+        # fill in defaults if not provided
+        mirror_x = transform.get(CONF_MIRROR_X, self.get_default(CONF_MIRROR_X))
+        mirror_y = transform.get(CONF_MIRROR_Y, self.get_default(CONF_MIRROR_Y))
+        swap_xy = transform.get(CONF_SWAP_XY, self.get_default(CONF_SWAP_XY))
+        transform[CONF_MIRROR_X] = mirror_x
+        transform[CONF_MIRROR_Y] = mirror_y
+        transform[CONF_SWAP_XY] = swap_xy
+
         # Can we use the MADCTL register to set the rotation?
         if can_transform and CONF_TRANSFORM not in config:
             rotation = config[CONF_ROTATION]
             if rotation == 180:
-                transform[CONF_MIRROR_X] = not transform[CONF_MIRROR_X]
-                transform[CONF_MIRROR_Y] = not transform[CONF_MIRROR_Y]
+                transform[CONF_MIRROR_X] = not mirror_x
+                transform[CONF_MIRROR_Y] = not mirror_y
             elif rotation == 90:
-                transform[CONF_SWAP_XY] = not transform[CONF_SWAP_XY]
-                transform[CONF_MIRROR_X] = not transform[CONF_MIRROR_X]
+                transform[CONF_SWAP_XY] = not swap_xy
+                transform[CONF_MIRROR_X] = not mirror_x
             else:
-                transform[CONF_SWAP_XY] = not transform[CONF_SWAP_XY]
-                transform[CONF_MIRROR_Y] = not transform[CONF_MIRROR_Y]
+                transform[CONF_SWAP_XY] = not swap_xy
+                transform[CONF_MIRROR_Y] = not mirror_y
             transform[CONF_TRANSFORM] = True
         return transform
 

esphome/components/mipi_dsi/models/waveshare.py

@@ -56,41 +56,50 @@ DriverChip(
     "WAVESHARE-P4-86-PANEL",
     height=720,
     width=720,
-    hsync_back_porch=50,
+    hsync_back_porch=80,
     hsync_pulse_width=20,
-    hsync_front_porch=50,
-    vsync_back_porch=20,
+    hsync_front_porch=80,
+    vsync_back_porch=12,
     vsync_pulse_width=4,
-    vsync_front_porch=20,
-    pclk_frequency="38MHz",
-    lane_bit_rate="480Mbps",
+    vsync_front_porch=30,
+    pclk_frequency="46MHz",
+    lane_bit_rate="1Gbps",
     swap_xy=cv.UNDEFINED,
     color_order="RGB",
     reset_pin=27,
     initsequence=[
         (0xB9, 0xF1, 0x12, 0x83),
-        (0xB1, 0x00, 0x00, 0x00, 0xDA, 0x80),
-        (0xB2, 0x3C, 0x12, 0x30),
-        (0xB3, 0x10, 0x10, 0x28, 0x28, 0x03, 0xFF, 0x00, 0x00, 0x00, 0x00),
-        (0xB4, 0x80),
-        (0xB5, 0x0A, 0x0A),
-        (0xB6, 0x97, 0x97),
-        (0xB8, 0x26, 0x22, 0xF0, 0x13),
-        (0xBA, 0x31, 0x81, 0x0F, 0xF9, 0x0E, 0x06, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x25, 0x00, 0x90, 0x0A, 0x00, 0x00, 0x01, 0x4F, 0x01, 0x00, 0x00, 0x37),
-        (0xBC, 0x47),
+        (
+            0xBA, 0x31, 0x81, 0x05, 0xF9, 0x0E, 0x0E, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x25, 0x00,
+            0x90, 0x0A, 0x00, 0x00, 0x01, 0x4F, 0x01, 0x00, 0x00, 0x37,
+        ),
+        (0xB8, 0x25, 0x22, 0xF0, 0x63),
         (0xBF, 0x02, 0x11, 0x00),
+        (0xB3, 0x10, 0x10, 0x28, 0x28, 0x03, 0xFF, 0x00, 0x00, 0x00, 0x00),
         (0xC0, 0x73, 0x73, 0x50, 0x50, 0x00, 0x00, 0x12, 0x70, 0x00),
-        (0xC1, 0x25, 0x00, 0x32, 0x32, 0x77, 0xE4, 0xFF, 0xFF, 0xCC, 0xCC, 0x77, 0x77),
-        (0xC6, 0x82, 0x00, 0xBF, 0xFF, 0x00, 0xFF),
-        (0xC7, 0xB8, 0x00, 0x0A, 0x10, 0x01, 0x09),
-        (0xC8, 0x10, 0x40, 0x1E, 0x02),
-        (0xCC, 0x0B),
-        (0xE0, 0x00, 0x0B, 0x10, 0x2C, 0x3D, 0x3F, 0x42, 0x3A, 0x07, 0x0D, 0x0F, 0x13, 0x15, 0x13, 0x14, 0x0F, 0x16, 0x00, 0x0B, 0x10, 0x2C, 0x3D, 0x3F, 0x42, 0x3A, 0x07, 0x0D, 0x0F, 0x13, 0x15, 0x13, 0x14, 0x0F, 0x16),
-        (0xE3, 0x07, 0x07, 0x0B, 0x0B, 0x0B, 0x0B, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0x10),
-        (0xE9, 0xC8, 0x10, 0x0A, 0x00, 0x00, 0x80, 0x81, 0x12, 0x31, 0x23, 0x4F, 0x86, 0xA0, 0x00, 0x47, 0x08, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x98, 0x02, 0x8B, 0xAF, 0x46, 0x02, 0x88, 0x88, 0x88, 0x88, 0x88, 0x98, 0x13, 0x8B, 0xAF, 0x57, 0x13, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-        (0xEA, 0x97, 0x0C, 0x09, 0x09, 0x09, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9F, 0x31, 0x8B, 0xA8, 0x31, 0x75, 0x88, 0x88, 0x88, 0x88, 0x88, 0x9F, 0x20, 0x8B, 0xA8, 0x20, 0x64, 0x88, 0x88, 0x88, 0x88, 0x88, 0x23, 0x00, 0x00, 0x02, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0x81, 0x00, 0x00, 0x00, 0x00),
-        (0xEF, 0xFF, 0xFF, 0x01),
-        (0x11, 0x00),
-        (0x29, 0x00),
+        (0xBC, 0x46), (0xCC, 0x0B), (0xB4, 0x80), (0xB2, 0x3C, 0x12, 0x30),
+        (0xE3, 0x07, 0x07, 0x0B, 0x0B, 0x03, 0x0B, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0x10,),
+        (0xC1, 0x36, 0x00, 0x32, 0x32, 0x77, 0xF1, 0xCC, 0xCC, 0x77, 0x77, 0x33, 0x33),
+        (0xB5, 0x0A, 0x0A),
+        (0xB6, 0xB2, 0xB2),
+        (
+            0xE9, 0xC8, 0x10, 0x0A, 0x10, 0x0F, 0xA1, 0x80, 0x12, 0x31, 0x23, 0x47, 0x86, 0xA1, 0x80,
+            0x47, 0x08, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x48,
+            0x02, 0x8B, 0xAF, 0x46, 0x02, 0x88, 0x88, 0x88, 0x88, 0x88, 0x48, 0x13, 0x8B, 0xAF, 0x57,
+            0x13, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ),
+        (
+            0xEA, 0x96, 0x12, 0x01, 0x01, 0x01, 0x78, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, 0x31,
+            0x8B, 0xA8, 0x31, 0x75, 0x88, 0x88, 0x88, 0x88, 0x88, 0x4F, 0x20, 0x8B, 0xA8, 0x20, 0x64,
+            0x88, 0x88, 0x88, 0x88, 0x88, 0x23, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xA1, 0x80, 0x00, 0x00,
+            0x00, 0x00,
+        ),
+        (
+            0xE0, 0x00, 0x0A, 0x0F, 0x29, 0x3B, 0x3F, 0x42, 0x39, 0x06, 0x0D, 0x10, 0x13, 0x15, 0x14,
+            0x15, 0x10, 0x17, 0x00, 0x0A, 0x0F, 0x29, 0x3B, 0x3F, 0x42, 0x39, 0x06, 0x0D, 0x10, 0x13,
+            0x15, 0x14, 0x15, 0x10, 0x17,
+        ),
     ],
 )

esphome/components/mipi_spi/display.py

@@ -37,7 +37,6 @@ from esphome.const import (
     CONF_DATA_RATE,
     CONF_DC_PIN,
     CONF_DIMENSIONS,
-    CONF_DISABLED,
     CONF_ENABLE_PIN,
     CONF_ID,
     CONF_INIT_SEQUENCE,
@@ -147,15 +146,12 @@ def swap_xy_schema(model):
 def model_schema(config):
     model = MODELS[config[CONF_MODEL]]
     bus_mode = config[CONF_BUS_MODE]
-    transform = cv.Any(
-        cv.Schema(
-            {
-                cv.Required(CONF_MIRROR_X): cv.boolean,
-                cv.Required(CONF_MIRROR_Y): cv.boolean,
-                **swap_xy_schema(model),
-            }
-        ),
-        cv.one_of(CONF_DISABLED, lower=True),
+    transform = cv.Schema(
+        {
+            cv.Required(CONF_MIRROR_X): cv.boolean,
+            cv.Required(CONF_MIRROR_Y): cv.boolean,
+            **swap_xy_schema(model),
+        }
     )
     # CUSTOM model will need to provide a custom init sequence
     iseqconf = (
@@ -164,11 +160,7 @@ def model_schema(config):
         else cv.Optional(CONF_INIT_SEQUENCE)
     )
     # Dimensions are optional if the model has a default width and the x-y transform is not overridden
-    transform_config = config.get(CONF_TRANSFORM, {})
-    is_swapped = (
-        isinstance(transform_config, dict)
-        and transform_config.get(CONF_SWAP_XY, False) is True
-    )
+    is_swapped = config.get(CONF_TRANSFORM, {}).get(CONF_SWAP_XY) is True
     cv_dimensions = (
         cv.Optional if model.get_default(CONF_WIDTH) and not is_swapped else cv.Required
     )
@@ -200,7 +192,9 @@ def model_schema(config):
         .extend(
             {
                 cv.GenerateID(): cv.declare_id(MipiSpi),
-                cv_dimensions(CONF_DIMENSIONS): dimension_schema(1),
+                cv_dimensions(CONF_DIMENSIONS): dimension_schema(
+                    model.get_default(CONF_DRAW_ROUNDING, 1)
+                ),
                 model.option(CONF_ENABLE_PIN, cv.UNDEFINED): cv.ensure_list(
                     pins.gpio_output_pin_schema
                 ),
@@ -406,7 +400,6 @@ def get_instance(config):
                 offset_height,
                 DISPLAY_ROTATIONS[rotation],
                 frac,
-                config[CONF_DRAW_ROUNDING],
             ]
         )
         return MipiSpiBuffer, templateargs
@@ -438,6 +431,7 @@ async def to_code(config):
         else:
             config[CONF_ROTATION] = 0
     cg.add(var.set_model(config[CONF_MODEL]))
+    cg.add(var.set_draw_rounding(config[CONF_DRAW_ROUNDING]))
     if enable_pin := config.get(CONF_ENABLE_PIN):
         enable = [await cg.gpio_pin_expression(pin) for pin in enable_pin]
         cg.add(var.set_enable_pins(enable))

esphome/components/mipi_spi/mipi_spi.h

@@ -38,7 +38,7 @@ static constexpr uint8_t MADCTL_BGR = 0x08;    // Bit 3 Blue-Green-Red pixel ord
 static constexpr uint8_t MADCTL_XFLIP = 0x02;  // Mirror the display horizontally
 static constexpr uint8_t MADCTL_YFLIP = 0x01;  // Mirror the display vertically
 
-static constexpr uint8_t DELAY_FLAG = 0xFF;
+static const uint8_t DELAY_FLAG = 0xFF;
 // store a 16 bit value in a buffer, big endian.
 static inline void put16_be(uint8_t *buf, uint16_t value) {
   buf[0] = value >> 8;
@@ -79,7 +79,7 @@ class MipiSpi : public display::Display,
                 public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
                                       spi::DATA_RATE_1MHZ> {
  public:
-  MipiSpi() = default;
+  MipiSpi() {}
   void update() override { this->stop_poller(); }
   void draw_pixel_at(int x, int y, Color color) override {}
   void set_model(const char *model) { this->model_ = model; }
@@ -99,6 +99,7 @@ class MipiSpi : public display::Display,
   int get_width_internal() override { return WIDTH; }
   int get_height_internal() override { return HEIGHT; }
   void set_init_sequence(const std::vector<uint8_t> &sequence) { this->init_sequence_ = sequence; }
+  void set_draw_rounding(unsigned rounding) { this->draw_rounding_ = rounding; }
 
   // reset the display, and write the init sequence
   void setup() override {
@@ -325,7 +326,6 @@ class MipiSpi : public display::Display,
 
   /**
    * Writes a buffer to the display.
-   * @param ptr The pointer to the pixel data
    * @param w Width of each line in bytes
    * @param h Height of the buffer in rows
    * @param pad Padding in bytes after each line
@@ -424,6 +424,7 @@ class MipiSpi : public display::Display,
 
   // other properties set by configuration
   bool invert_colors_{};
+  unsigned draw_rounding_{2};
   optional<uint8_t> brightness_{};
   const char *model_{"Unknown"};
   std::vector<uint8_t> init_sequence_{};
@@ -443,20 +444,12 @@ class MipiSpi : public display::Display,
  * @tparam OFFSET_WIDTH The x-offset of the display in pixels
  * @tparam OFFSET_HEIGHT The y-offset of the display in pixels
  * @tparam FRACTION The fraction of the display size to use for the buffer (e.g. 4 means a 1/4 buffer).
- * @tparam ROUNDING The alignment requirement for drawing operations (e.g. 2 means that x coordinates must be even)
  */
 template<typename BUFFERTYPE, PixelMode BUFFERPIXEL, bool IS_BIG_ENDIAN, PixelMode DISPLAYPIXEL, BusType BUS_TYPE,
-         uint16_t WIDTH, uint16_t HEIGHT, int OFFSET_WIDTH, int OFFSET_HEIGHT, display::DisplayRotation ROTATION,
-         int FRACTION, unsigned ROUNDING>
+         int WIDTH, int HEIGHT, int OFFSET_WIDTH, int OFFSET_HEIGHT, display::DisplayRotation ROTATION, int FRACTION>
 class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DISPLAYPIXEL, BUS_TYPE, WIDTH, HEIGHT,
                                      OFFSET_WIDTH, OFFSET_HEIGHT> {
  public:
-  // these values define the buffer size needed to write in accordance with the chip pixel alignment
-  // requirements. If the required rounding does not divide the width and height, we round up to the next multiple and
-  // ignore the extra columns and rows when drawing, but use them to write to the display.
-  static constexpr unsigned BUFFER_WIDTH = (WIDTH + ROUNDING - 1) / ROUNDING * ROUNDING;
-  static constexpr unsigned BUFFER_HEIGHT = (HEIGHT + ROUNDING - 1) / ROUNDING * ROUNDING;
-
   MipiSpiBuffer() { this->rotation_ = ROTATION; }
 
   void dump_config() override {
@@ -468,15 +461,15 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
                     "  Buffer fraction: 1/%d\n"
                     "  Buffer bytes: %zu\n"
                     "  Draw rounding: %u",
-                    this->rotation_, BUFFERPIXEL * 8, FRACTION,
-                    sizeof(BUFFERTYPE) * BUFFER_WIDTH * BUFFER_HEIGHT / FRACTION, ROUNDING);
+                    this->rotation_, BUFFERPIXEL * 8, FRACTION, sizeof(BUFFERTYPE) * WIDTH * HEIGHT / FRACTION,
+                    this->draw_rounding_);
   }
 
   void setup() override {
     MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DISPLAYPIXEL, BUS_TYPE, WIDTH, HEIGHT, OFFSET_WIDTH,
             OFFSET_HEIGHT>::setup();
     RAMAllocator<BUFFERTYPE> allocator{};
-    this->buffer_ = allocator.allocate(BUFFER_WIDTH * BUFFER_HEIGHT / FRACTION);
+    this->buffer_ = allocator.allocate(WIDTH * HEIGHT / FRACTION);
     if (this->buffer_ == nullptr) {
       this->mark_failed("Buffer allocation failed");
     }
@@ -515,14 +508,15 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
       esph_log_v(TAG, "x_low %d, y_low %d, x_high %d, y_high %d", this->x_low_, this->y_low_, this->x_high_,
                  this->y_high_);
       // Some chips require that the drawing window be aligned on certain boundaries
-      this->x_low_ = this->x_low_ / ROUNDING * ROUNDING;
-      this->y_low_ = this->y_low_ / ROUNDING * ROUNDING;
-      this->x_high_ = (this->x_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
-      this->y_high_ = (this->y_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
+      auto dr = this->draw_rounding_;
+      this->x_low_ = this->x_low_ / dr * dr;
+      this->y_low_ = this->y_low_ / dr * dr;
+      this->x_high_ = (this->x_high_ + dr) / dr * dr - 1;
+      this->y_high_ = (this->y_high_ + dr) / dr * dr - 1;
       int w = this->x_high_ - this->x_low_ + 1;
       int h = this->y_high_ - this->y_low_ + 1;
       this->write_to_display_(this->x_low_, this->y_low_, w, h, this->buffer_, this->x_low_,
-                              this->y_low_ - this->start_line_, BUFFER_WIDTH - w);
+                              this->y_low_ - this->start_line_, WIDTH - w);
       // invalidate watermarks
       this->x_low_ = WIDTH;
       this->y_low_ = HEIGHT;
@@ -542,10 +536,10 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
   void draw_pixel_at(int x, int y, Color color) override {
     if (!this->get_clipping().inside(x, y))
       return;
-    rotate_coordinates(x, y);
+    rotate_coordinates_(x, y);
     if (x < 0 || x >= WIDTH || y < this->start_line_ || y >= this->end_line_)
       return;
-    this->buffer_[(y - this->start_line_) * BUFFER_WIDTH + x] = convert_color(color);
+    this->buffer_[(y - this->start_line_) * WIDTH + x] = convert_color_(color);
     if (x < this->x_low_) {
       this->x_low_ = x;
     }
@@ -566,7 +560,7 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
     this->y_low_ = this->start_line_;
     this->x_high_ = WIDTH - 1;
     this->y_high_ = this->end_line_ - 1;
-    std::fill_n(this->buffer_, HEIGHT * BUFFER_WIDTH / FRACTION, convert_color(color));
+    std::fill_n(this->buffer_, HEIGHT * WIDTH / FRACTION, convert_color_(color));
   }
 
   int get_width() override {
@@ -583,7 +577,7 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
 
  protected:
   // Rotate the coordinates to match the display orientation.
-  static void rotate_coordinates(int &x, int &y) {
+  void rotate_coordinates_(int &x, int &y) const {
     if constexpr (ROTATION == display::DISPLAY_ROTATION_180_DEGREES) {
       x = WIDTH - x - 1;
       y = HEIGHT - y - 1;
@@ -599,7 +593,7 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
   }
 
   // Convert a color to the buffer pixel format.
-  static BUFFERTYPE convert_color(const Color &color) {
+  BUFFERTYPE convert_color_(Color &color) const {
     if constexpr (BUFFERPIXEL == PIXEL_MODE_8) {
       return (color.red & 0xE0) | (color.g & 0xE0) >> 3 | color.b >> 6;
     } else if constexpr (BUFFERPIXEL == PIXEL_MODE_16) {

esphome/components/mipi_spi/models/waveshare.py

@@ -3,7 +3,6 @@ import esphome.config_validation as cv
 
 from .amoled import CO5300
 from .ili import ILI9488_A
-from .jc import AXS15231
 
 DriverChip(
     "WAVESHARE-4-TFT",
@@ -153,12 +152,3 @@ CO5300.extend(
     cs_pin=12,
     reset_pin=39,
 )
-
-AXS15231.extend(
-    "WAVESHARE-ESP32-S3-TOUCH-LCD-3.49",
-    width=172,
-    height=640,
-    data_rate="80MHz",
-    cs_pin=9,
-    reset_pin=21,
-)

esphome/components/psram/__init__.py

@@ -63,8 +63,6 @@ SPIRAM_SPEEDS = {
 
 
 def supported() -> bool:
-    if not CORE.is_esp32:
-        return False
     variant = get_esp32_variant()
     return variant in SPIRAM_MODES
 

esphome/components/scd4x/sensor.py

@@ -81,7 +81,7 @@ CONFIG_SCHEMA = (
                 cv.int_range(min=0, max=0xFFFF, max_included=False),
             ),
             cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION): cv.pressure,
-            cv.Optional(CONF_TEMPERATURE_OFFSET, default="4°C"): cv.temperature_delta,
+            cv.Optional(CONF_TEMPERATURE_OFFSET, default="4°C"): cv.temperature,
             cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE): cv.use_id(
                 sensor.Sensor
             ),

esphome/components/speaker/media_player/__init__.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from esphome import automation, external_files
 import esphome.codegen as cg
-from esphome.components import audio, esp32, media_player, psram, speaker
+from esphome.components import audio, esp32, media_player, speaker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUFFER_SIZE,
@@ -26,21 +26,10 @@ from esphome.const import (
 from esphome.core import CORE, HexInt
 from esphome.core.entity_helpers import inherit_property_from
 from esphome.external_files import download_content
-from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
 
-
-def AUTO_LOAD(config: ConfigType) -> list[str]:
-    load = ["audio"]
-    if (
-        not config
-        or config.get(CONF_TASK_STACK_IN_PSRAM)
-        or config.get(CONF_CODEC_SUPPORT_ENABLED)
-    ):
-        return load + ["psram"]
-    return load
-
+AUTO_LOAD = ["audio", "psram"]
 
 CODEOWNERS = ["@kahrendt", "@synesthesiam"]
 DOMAIN = "media_player"
@@ -290,9 +279,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_BUFFER_SIZE, default=1000000): cv.int_range(
                 min=4000, max=4000000
             ),
-            cv.Optional(
-                CONF_CODEC_SUPPORT_ENABLED, default=psram.supported()
-            ): cv.boolean,
+            cv.Optional(CONF_CODEC_SUPPORT_ENABLED, default=True): cv.boolean,
             cv.Optional(CONF_FILES): cv.ensure_list(MEDIA_FILE_TYPE_SCHEMA),
             cv.Optional(CONF_TASK_STACK_IN_PSRAM, default=False): cv.boolean,
             cv.Optional(CONF_VOLUME_INCREMENT, default=0.05): cv.percentage,

esphome/components/substitutions/__init__.py

@@ -1,7 +1,7 @@
 import logging
 
 from esphome import core
-from esphome.config_helpers import Extend, Remove, merge_config, merge_dicts_ordered
+from esphome.config_helpers import Extend, Remove, merge_config
 import esphome.config_validation as cv
 from esphome.const import CONF_SUBSTITUTIONS, VALID_SUBSTITUTIONS_CHARACTERS
 from esphome.yaml_util import ESPHomeDataBase, ESPLiteralValue, make_data_base
@@ -170,10 +170,10 @@ def do_substitution_pass(config, command_line_substitutions, ignore_missing=Fals
         return
 
     # Merge substitutions in config, overriding with substitutions coming from command line:
-    # Use merge_dicts_ordered to preserve OrderedDict type for move_to_end()
-    substitutions = merge_dicts_ordered(
-        config.get(CONF_SUBSTITUTIONS, {}), command_line_substitutions or {}
-    )
+    substitutions = {
+        **config.get(CONF_SUBSTITUTIONS, {}),
+        **(command_line_substitutions or {}),
+    }
     with cv.prepend_path("substitutions"):
         if not isinstance(substitutions, dict):
             raise cv.Invalid(

esphome/components/usb_host/__init__.py

@@ -9,7 +9,6 @@ from esphome.components.esp32 import (
 import esphome.config_validation as cv
 from esphome.const import CONF_DEVICES, CONF_ID
 from esphome.cpp_types import Component
-from esphome.types import ConfigType
 
 AUTO_LOAD = ["bytebuffer"]
 CODEOWNERS = ["@clydebarrow"]
@@ -21,7 +20,6 @@ USBClient = usb_host_ns.class_("USBClient", Component)
 CONF_VID = "vid"
 CONF_PID = "pid"
 CONF_ENABLE_HUBS = "enable_hubs"
-CONF_MAX_TRANSFER_REQUESTS = "max_transfer_requests"
 
 
 def usb_device_schema(cls=USBClient, vid: int = None, pid: [int] = None) -> cv.Schema:
@@ -46,9 +44,6 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(USBHost),
             cv.Optional(CONF_ENABLE_HUBS, default=False): cv.boolean,
-            cv.Optional(CONF_MAX_TRANSFER_REQUESTS, default=16): cv.int_range(
-                min=1, max=32
-            ),
             cv.Optional(CONF_DEVICES): cv.ensure_list(usb_device_schema()),
         }
     ),
@@ -63,14 +58,10 @@ async def register_usb_client(config):
     return var
 
 
-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
     add_idf_sdkconfig_option("CONFIG_USB_HOST_CONTROL_TRANSFER_MAX_SIZE", 1024)
     if config.get(CONF_ENABLE_HUBS):
         add_idf_sdkconfig_option("CONFIG_USB_HOST_HUBS_SUPPORTED", True)
-
-    max_requests = config[CONF_MAX_TRANSFER_REQUESTS]
-    cg.add_define("USB_HOST_MAX_REQUESTS", max_requests)
-
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     for device in config.get(CONF_DEVICES) or ():

esphome/components/usb_host/usb_host.h

@@ -2,7 +2,6 @@
 
 // Should not be needed, but it's required to pass CI clang-tidy checks
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
-#include "esphome/core/defines.h"
 #include "esphome/core/component.h"
 #include <vector>
 #include "usb/usb_host.h"
@@ -17,25 +16,23 @@ namespace usb_host {
 
 // THREADING MODEL:
 // This component uses a dedicated USB task for event processing to prevent data loss.
-// - USB Task (high priority): Handles USB events, executes transfer callbacks, releases transfer slots
-// - Main Loop Task: Initiates transfers, processes device connect/disconnect events
+// - USB Task (high priority): Handles USB events, executes transfer callbacks
+// - Main Loop Task: Initiates transfers, processes completion events
 //
 // Thread-safe communication:
 // - Lock-free queues for USB task -> main loop events (SPSC pattern)
-// - Lock-free TransferRequest pool using atomic bitmask (MCMP pattern - multi-consumer, multi-producer)
+// - Lock-free TransferRequest pool using atomic bitmask (MCSP pattern)
 //
 // TransferRequest pool access pattern:
 // - get_trq_() [allocate]: Called from BOTH USB task and main loop threads
 //   * USB task: via USB UART input callbacks that restart transfers immediately
 //   * Main loop: for output transfers and flow-controlled input restarts
-// - release_trq() [deallocate]: Called from BOTH USB task and main loop threads
-//   * USB task: immediately after transfer callback completes (critical for preventing slot exhaustion)
-//   * Main loop: when transfer submission fails
+// - release_trq() [deallocate]: Called from main loop thread only
 //
-// The multi-threaded allocation/deallocation is intentional for performance:
-// - USB task can immediately restart input transfers and release slots without context switching
+// The multi-threaded allocation is intentional for performance:
+// - USB task can immediately restart input transfers without context switching
 // - Main loop controls backpressure by deciding when to restart after consuming data
-// The atomic bitmask ensures thread-safe allocation/deallocation without mutex blocking.
+// The atomic bitmask ensures thread-safe allocation without mutex blocking.
 
 static const char *const TAG = "usb_host";
 
@@ -55,17 +52,8 @@ static const uint8_t USB_DIR_IN = 1 << 7;
 static const uint8_t USB_DIR_OUT = 0;
 static const size_t SETUP_PACKET_SIZE = 8;
 
-static const size_t MAX_REQUESTS = USB_HOST_MAX_REQUESTS;  // maximum number of outstanding requests possible.
-static_assert(MAX_REQUESTS >= 1 && MAX_REQUESTS <= 32, "MAX_REQUESTS must be between 1 and 32");
-
-// Select appropriate bitmask type for tracking allocation of TransferRequest slots.
-// The bitmask must have at least as many bits as MAX_REQUESTS, so:
-// - Use uint16_t for up to 16 requests (MAX_REQUESTS <= 16)
-// - Use uint32_t for 17-32 requests (MAX_REQUESTS > 16)
-// This is tied to the static_assert above, which enforces MAX_REQUESTS is between 1 and 32.
-// If MAX_REQUESTS is increased above 32, this logic and the static_assert must be updated.
-using trq_bitmask_t = std::conditional<(MAX_REQUESTS <= 16), uint16_t, uint32_t>::type;
-
+static const size_t MAX_REQUESTS = 16;  // maximum number of outstanding requests possible.
+static_assert(MAX_REQUESTS <= 16, "MAX_REQUESTS must be <= 16 to fit in uint16_t bitmask");
 static constexpr size_t USB_EVENT_QUEUE_SIZE = 32;   // Size of event queue between USB task and main loop
 static constexpr size_t USB_TASK_STACK_SIZE = 4096;  // Stack size for USB task (same as ESP-IDF USB examples)
 static constexpr UBaseType_t USB_TASK_PRIORITY = 5;  // Higher priority than main loop (tskIDLE_PRIORITY + 5)
@@ -95,6 +83,8 @@ struct TransferRequest {
 enum EventType : uint8_t {
   EVENT_DEVICE_NEW,
   EVENT_DEVICE_GONE,
+  EVENT_TRANSFER_COMPLETE,
+  EVENT_CONTROL_COMPLETE,
 };
 
 struct UsbEvent {
@@ -106,6 +96,9 @@ struct UsbEvent {
     struct {
       usb_device_handle_t handle;
     } device_gone;
+    struct {
+      TransferRequest *trq;
+    } transfer;
   } data;
 
   // Required for EventPool - no cleanup needed for POD types
@@ -170,9 +163,10 @@ class USBClient : public Component {
   uint16_t pid_{};
   // Lock-free pool management using atomic bitmask (no dynamic allocation)
   // Bit i = 1: requests_[i] is in use, Bit i = 0: requests_[i] is available
-  // Supports multiple concurrent consumers and producers (both threads can allocate/deallocate)
-  // Bitmask type automatically selected: uint16_t for <= 16 slots, uint32_t for 17-32 slots
-  std::atomic<trq_bitmask_t> trq_in_use_;
+  // Supports multiple concurrent consumers (both threads can allocate)
+  // Single producer for deallocation (main loop only)
+  // Limited to 16 slots by uint16_t size (enforced by static_assert)
+  std::atomic<uint16_t> trq_in_use_;
   TransferRequest requests_[MAX_REQUESTS]{};
 };
 class USBHost : public Component {

esphome/components/usb_host/usb_host_client.cpp

@@ -228,6 +228,12 @@ void USBClient::loop() {
       case EVENT_DEVICE_GONE:
         this->on_removed(event->data.device_gone.handle);
         break;
+      case EVENT_TRANSFER_COMPLETE:
+      case EVENT_CONTROL_COMPLETE: {
+        auto *trq = event->data.transfer.trq;
+        this->release_trq(trq);
+        break;
+      }
     }
     // Return event to pool for reuse
     this->event_pool.release(event);
@@ -307,6 +313,25 @@ void USBClient::on_removed(usb_device_handle_t handle) {
   }
 }
 
+// Helper to queue transfer cleanup to main loop
+static void queue_transfer_cleanup(TransferRequest *trq, EventType type) {
+  auto *client = trq->client;
+
+  // Allocate event from pool
+  UsbEvent *event = client->event_pool.allocate();
+  if (event == nullptr) {
+    // No events available - increment counter for periodic logging
+    client->event_queue.increment_dropped_count();
+    return;
+  }
+
+  event->type = type;
+  event->data.transfer.trq = trq;
+
+  // Push to lock-free queue (always succeeds since pool size == queue size)
+  client->event_queue.push(event);
+}
+
 // CALLBACK CONTEXT: USB task (called from usb_host_client_handle_events in USB task)
 static void control_callback(const usb_transfer_t *xfer) {
   auto *trq = static_cast<TransferRequest *>(xfer->context);
@@ -321,9 +346,8 @@ static void control_callback(const usb_transfer_t *xfer) {
     trq->callback(trq->status);
   }
 
-  // Release transfer slot immediately in USB task
-  // The release_trq() uses thread-safe atomic operations
-  trq->client->release_trq(trq);
+  // Queue cleanup to main loop
+  queue_transfer_cleanup(trq, EVENT_CONTROL_COMPLETE);
 }
 
 // THREAD CONTEXT: Called from both USB task and main loop threads (multi-consumer)
@@ -334,20 +358,20 @@ static void control_callback(const usb_transfer_t *xfer) {
 // This multi-threaded access is intentional for performance - USB task can
 // immediately restart transfers without waiting for main loop scheduling.
 TransferRequest *USBClient::get_trq_() {
-  trq_bitmask_t mask = this->trq_in_use_.load(std::memory_order_relaxed);
+  uint16_t mask = this->trq_in_use_.load(std::memory_order_relaxed);
 
   // Find first available slot (bit = 0) and try to claim it atomically
   // We use a while loop to allow retrying the same slot after CAS failure
   size_t i = 0;
   while (i != MAX_REQUESTS) {
-    if (mask & (static_cast<trq_bitmask_t>(1) << i)) {
+    if (mask & (1U << i)) {
       // Slot is in use, move to next slot
       i++;
       continue;
     }
 
     // Slot i appears available, try to claim it atomically
-    trq_bitmask_t desired = mask | (static_cast<trq_bitmask_t>(1) << i);  // Set bit i to mark as in-use
+    uint16_t desired = mask | (1U << i);  // Set bit i to mark as in-use
 
     if (this->trq_in_use_.compare_exchange_weak(mask, desired, std::memory_order_acquire, std::memory_order_relaxed)) {
       // Successfully claimed slot i - prepare the TransferRequest
@@ -362,7 +386,7 @@ TransferRequest *USBClient::get_trq_() {
     i = 0;
   }
 
-  ESP_LOGE(TAG, "All %zu transfer slots in use", MAX_REQUESTS);
+  ESP_LOGE(TAG, "All %d transfer slots in use", MAX_REQUESTS);
   return nullptr;
 }
 void USBClient::disconnect() {
@@ -428,11 +452,8 @@ static void transfer_callback(usb_transfer_t *xfer) {
     trq->callback(trq->status);
   }
 
-  // Release transfer slot AFTER callback completes to prevent slot exhaustion
-  // This is critical for high-throughput transfers (e.g., USB UART at 115200 baud)
-  // The callback has finished accessing xfer->data_buffer, so it's safe to release
-  // The release_trq() uses thread-safe atomic operations
-  trq->client->release_trq(trq);
+  // Queue cleanup to main loop
+  queue_transfer_cleanup(trq, EVENT_TRANSFER_COMPLETE);
 }
 /**
  * Performs a transfer input operation.
@@ -500,12 +521,12 @@ void USBClient::dump_config() {
                 "  Product id %04X",
                 this->vid_, this->pid_);
 }
-// THREAD CONTEXT: Called from both USB task and main loop threads
-// - USB task: Immediately after transfer callback completes
-// - Main loop: When transfer submission fails
+// THREAD CONTEXT: Only called from main loop thread (single producer for deallocation)
+// - Via event processing when handling EVENT_TRANSFER_COMPLETE/EVENT_CONTROL_COMPLETE
+// - Directly when transfer submission fails
 //
 // THREAD SAFETY: Lock-free using atomic AND to clear bit
-// Thread-safe atomic operation allows multi-threaded deallocation
+// Single-producer pattern makes this simpler than allocation
 void USBClient::release_trq(TransferRequest *trq) {
   if (trq == nullptr)
     return;
@@ -519,8 +540,8 @@ void USBClient::release_trq(TransferRequest *trq) {
 
   // Atomically clear bit i to mark slot as available
   // fetch_and with inverted bitmask clears the bit atomically
-  trq_bitmask_t bit = static_cast<trq_bitmask_t>(1) << index;
-  this->trq_in_use_.fetch_and(static_cast<trq_bitmask_t>(~bit), std::memory_order_release);
+  uint16_t bit = 1U << index;
+  this->trq_in_use_.fetch_and(static_cast<uint16_t>(~bit), std::memory_order_release);
 }
 
 }  // namespace usb_host

esphome/components/wifi/__init__.py

@@ -402,8 +402,8 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
 
     # Disable Enterprise WiFi support if no EAP is configured
-    if CORE.is_esp32:
-        add_idf_sdkconfig_option("CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT", has_eap)
+    if CORE.is_esp32 and not has_eap:
+        add_idf_sdkconfig_option("CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT", False)
 
     cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
     cg.add(var.set_power_save_mode(config[CONF_POWER_SAVE_MODE]))

esphome/components/wifi/wifi_component.cpp

@@ -552,7 +552,7 @@ void WiFiComponent::start_scanning() {
 // Using insertion sort instead of std::stable_sort saves flash memory
 // by avoiding template instantiations (std::rotate, std::stable_sort, lambdas)
 // IMPORTANT: This sort is stable (preserves relative order of equal elements)
-static void insertion_sort_scan_results(std::vector<WiFiScanResult> &results) {
+static void insertion_sort_scan_results(FixedVector<WiFiScanResult> &results) {
   const size_t size = results.size();
   for (size_t i = 1; i < size; i++) {
     // Make a copy to avoid issues with move semantics during comparison
@@ -576,9 +576,8 @@ __attribute__((noinline)) static void log_scan_result(const WiFiScanResult &res)
   format_mac_addr_upper(bssid.data(), bssid_s);
 
   if (res.get_matches()) {
-    ESP_LOGI(TAG, "- '%s' %s" LOG_SECRET("(%s) ") "%s", res.get_ssid().c_str(),
-             res.get_is_hidden() ? LOG_STR_LITERAL("(HIDDEN) ") : LOG_STR_LITERAL(""), bssid_s,
-             LOG_STR_ARG(get_signal_bars(res.get_rssi())));
+    ESP_LOGI(TAG, "- '%s' %s" LOG_SECRET("(%s) ") "%s", res.get_ssid().c_str(), res.get_is_hidden() ? "(HIDDEN) " : "",
+             bssid_s, LOG_STR_ARG(get_signal_bars(res.get_rssi())));
     ESP_LOGD(TAG,
              "    Channel: %u\n"
              "    RSSI: %d dB",

esphome/components/wifi/wifi_component.h

@@ -278,7 +278,7 @@ class WiFiComponent : public Component {
   std::string get_use_address() const;
   void set_use_address(const std::string &use_address);
 
-  const std::vector<WiFiScanResult> &get_scan_result() const { return scan_result_; }
+  const FixedVector<WiFiScanResult> &get_scan_result() const { return scan_result_; }
 
   network::IPAddress wifi_soft_ap_ip();
 
@@ -385,7 +385,7 @@ class WiFiComponent : public Component {
   std::string use_address_;
   std::vector<WiFiAP> sta_;
   std::vector<WiFiSTAPriority> sta_priorities_;
-  std::vector<WiFiScanResult> scan_result_;
+  FixedVector<WiFiScanResult> scan_result_;
   WiFiAP selected_ap_;
   WiFiAP ap_;
   optional<float> output_power_;

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -696,7 +696,15 @@ void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
     this->retry_connect();
     return;
   }
+
+  // Count the number of results first
   auto *head = reinterpret_cast<bss_info *>(arg);
+  size_t count = 0;
+  for (bss_info *it = head; it != nullptr; it = STAILQ_NEXT(it, next)) {
+    count++;
+  }
+
+  this->scan_result_.init(count);
   for (bss_info *it = head; it != nullptr; it = STAILQ_NEXT(it, next)) {
     WiFiScanResult res({it->bssid[0], it->bssid[1], it->bssid[2], it->bssid[3], it->bssid[4], it->bssid[5]},
                        std::string(reinterpret_cast<char *>(it->ssid), it->ssid_len), it->channel, it->rssi,

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -763,8 +763,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     const auto &it = data->data.sta_scan_done;
     ESP_LOGV(TAG, "Scan done: status=%" PRIu32 " number=%u scan_id=%u", it.status, it.number, it.scan_id);
 
-    scan_result_.clear();
     this->scan_done_ = true;
+    scan_result_.clear();
+
     if (it.status != 0) {
       // scan error
       return;
@@ -784,7 +785,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     }
     records.resize(number);
 
-    scan_result_.reserve(number);
+    scan_result_.init(number);
     for (int i = 0; i < number; i++) {
       auto &record = records[i];
       bssid_t bssid;

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -411,7 +411,7 @@ void WiFiComponent::wifi_scan_done_callback_() {
   if (num < 0)
     return;
 
-  this->scan_result_.reserve(static_cast<unsigned int>(num));
+  this->scan_result_.init(static_cast<unsigned int>(num));
   for (int i = 0; i < num; i++) {
     String ssid = WiFi.SSID(i);
     wifi_auth_mode_t authmode = WiFi.encryptionType(i);

esphome/config.py

@@ -12,7 +12,7 @@ from typing import Any
 import voluptuous as vol
 
 from esphome import core, loader, pins, yaml_util
-from esphome.config_helpers import Extend, Remove, merge_dicts_ordered
+from esphome.config_helpers import Extend, Remove
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ESPHOME,
@@ -922,9 +922,10 @@ def validate_config(
     if CONF_SUBSTITUTIONS in config or command_line_substitutions:
         from esphome.components import substitutions
 
-        result[CONF_SUBSTITUTIONS] = merge_dicts_ordered(
-            config.get(CONF_SUBSTITUTIONS) or {}, command_line_substitutions
-        )
+        result[CONF_SUBSTITUTIONS] = {
+            **(config.get(CONF_SUBSTITUTIONS) or {}),
+            **command_line_substitutions,
+        }
         result.add_output_path([CONF_SUBSTITUTIONS], CONF_SUBSTITUTIONS)
         try:
             substitutions.do_substitution_pass(config, command_line_substitutions)

esphome/config_helpers.py

@@ -10,7 +10,6 @@ from esphome.const import (
     PlatformFramework,
 )
 from esphome.core import CORE
-from esphome.util import OrderedDict
 
 # Pre-build lookup map from (platform, framework) tuples to PlatformFramework enum
 _PLATFORM_FRAMEWORK_LOOKUP = {
@@ -18,25 +17,6 @@ _PLATFORM_FRAMEWORK_LOOKUP = {
 }
 
 
-def merge_dicts_ordered(*dicts: dict) -> OrderedDict:
-    """Merge multiple dicts into an OrderedDict, preserving key order.
-
-    This is a helper to ensure that dictionary merging preserves OrderedDict type,
-    which is important for operations like move_to_end().
-
-    Args:
-        *dicts: Variable number of dictionaries to merge (later dicts override earlier ones)
-
-    Returns:
-        OrderedDict with merged contents
-    """
-    result = OrderedDict()
-    for d in dicts:
-        if d:
-            result.update(d)
-    return result
-
-
 class Extend:
     def __init__(self, value):
         self.value = value
@@ -80,11 +60,7 @@ def merge_config(full_old, full_new):
         if isinstance(new, dict):
             if not isinstance(old, dict):
                 return new
-            # Preserve OrderedDict type by copying to OrderedDict if either input is OrderedDict
-            if isinstance(old, OrderedDict) or isinstance(new, OrderedDict):
-                res = OrderedDict(old)
-            else:
-                res = old.copy()
+            res = old.copy()
             for k, v in new.items():
                 if isinstance(v, Remove) and k in old:
                     del res[k]

esphome/config_validation.py

@@ -244,20 +244,6 @@ RESERVED_IDS = [
     "uart0",
     "uart1",
     "uart2",
-    # ESP32 ROM functions
-    "crc16_be",
-    "crc16_le",
-    "crc32_be",
-    "crc32_le",
-    "crc8_be",
-    "crc8_le",
-    "dbg_state",
-    "debug_timer",
-    "one_bits",
-    "recv_packet",
-    "send_packet",
-    "check_pos",
-    "software_reset",
 ]
 
 

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2025.10.2"
+__version__ = "2025.11.0-dev"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -696,7 +696,6 @@ CONF_OPEN_DRAIN = "open_drain"
 CONF_OPEN_DRAIN_INTERRUPT = "open_drain_interrupt"
 CONF_OPEN_DURATION = "open_duration"
 CONF_OPEN_ENDSTOP = "open_endstop"
-CONF_OPENTHREAD = "openthread"
 CONF_OPERATION = "operation"
 CONF_OPTIMISTIC = "optimistic"
 CONF_OPTION = "option"

esphome/core/__init__.py

@@ -11,7 +11,6 @@ from esphome.const import (
     CONF_COMMENT,
     CONF_ESPHOME,
     CONF_ETHERNET,
-    CONF_OPENTHREAD,
     CONF_PORT,
     CONF_USE_ADDRESS,
     CONF_WEB_SERVER,
@@ -642,9 +641,6 @@ class EsphomeCore:
         if CONF_ETHERNET in self.config:
             return self.config[CONF_ETHERNET][CONF_USE_ADDRESS]
 
-        if CONF_OPENTHREAD in self.config:
-            return f"{self.name}.local"
-
         return None
 
     @property

esphome/core/application.cpp

@@ -340,8 +340,8 @@ void Application::calculate_looping_components_() {
     }
   }
 
-  // Pre-reserve vector to avoid reallocations
-  this->looping_components_.reserve(total_looping);
+  // Initialize FixedVector with exact size - no reallocation possible
+  this->looping_components_.init(total_looping);
 
   // Add all components with loop override that aren't already LOOP_DONE
   // Some components (like logger) may call disable_loop() during initialization

esphome/core/application.h

@@ -472,7 +472,7 @@ class Application {
   // - When a component is enabled, it's swapped with the first inactive component
   //   and active_end_ is incremented
   // - This eliminates branch mispredictions from flag checking in the hot loop
-  std::vector<Component *> looping_components_{};
+  FixedVector<Component *> looping_components_{};
 #ifdef USE_SOCKET_SELECT_SUPPORT
   std::vector<int> socket_fds_;  // Vector of all monitored socket file descriptors
 #endif

esphome/core/defines.h

@@ -175,6 +175,8 @@
 #define USE_ESP32_BLE_SERVER_DESCRIPTOR_ON_WRITE
 #define USE_ESP32_BLE_SERVER_ON_CONNECT
 #define USE_ESP32_BLE_SERVER_ON_DISCONNECT
+#define ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT 1
+#define ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT 1
 #define USE_ESP32_CAMERA_JPEG_ENCODER
 #define USE_I2C
 #define USE_IMPROV
@@ -191,7 +193,6 @@
 #define USE_WEBSERVER_PORT 80  // NOLINT
 #define USE_WEBSERVER_SORTING
 #define USE_WIFI_11KV_SUPPORT
-#define USB_HOST_MAX_REQUESTS 16
 
 #ifdef USE_ARDUINO
 #define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 2, 1)

esphome/core/helpers.h

@@ -159,6 +159,80 @@ template<typename T, size_t N> class StaticVector {
   const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 };
 
+/// Fixed-capacity vector - allocates once at runtime, never reallocates
+/// This avoids std::vector template overhead (_M_realloc_insert, _M_default_append)
+/// when size is known at initialization but not at compile time
+template<typename T> class FixedVector {
+ private:
+  T *data_{nullptr};
+  size_t size_{0};
+  size_t capacity_{0};
+
+  // Helper to destroy elements and free memory
+  void cleanup_() {
+    if (data_ != nullptr) {
+      // Manually destroy all elements
+      for (size_t i = 0; i < size_; i++) {
+        data_[i].~T();
+      }
+      // Free raw memory
+      ::operator delete(data_);
+    }
+  }
+
+ public:
+  FixedVector() = default;
+
+  ~FixedVector() { cleanup_(); }
+
+  // Disable copy to avoid accidental copies
+  FixedVector(const FixedVector &) = delete;
+  FixedVector &operator=(const FixedVector &) = delete;
+
+  // Allocate capacity - can be called multiple times to reinit
+  void init(size_t n) {
+    cleanup_();
+    data_ = nullptr;
+    capacity_ = 0;
+    size_ = 0;
+    if (n > 0) {
+      // Allocate raw memory without calling constructors
+      data_ = static_cast<T *>(::operator new(n * sizeof(T)));
+      capacity_ = n;
+    }
+  }
+
+  // Clear the vector (reset size to 0, keep capacity)
+  void clear() { size_ = 0; }
+
+  // Check if vector is empty
+  bool empty() const { return size_ == 0; }
+
+  /// Add element without bounds checking
+  /// Caller must ensure sufficient capacity was allocated via init()
+  /// Silently ignores pushes beyond capacity (no exception or assertion)
+  void push_back(const T &value) {
+    if (size_ < capacity_) {
+      // Use placement new to construct the object in pre-allocated memory
+      new (&data_[size_]) T(value);
+      size_++;
+    }
+  }
+
+  size_t size() const { return size_; }
+
+  /// Access element without bounds checking (matches std::vector behavior)
+  /// Caller must ensure index is valid (i < size())
+  T &operator[](size_t i) { return data_[i]; }
+  const T &operator[](size_t i) const { return data_[i]; }
+
+  // Iterator support for range-based for loops
+  T *begin() { return data_; }
+  T *end() { return data_ + size_; }
+  const T *begin() const { return data_; }
+  const T *end() const { return data_ + size_; }
+};
+
 ///@}
 
 /// @name Mathematics

esphome/dashboard/settings.py

@@ -10,10 +10,6 @@ from esphome.helpers import get_bool_env
 
 from .util.password import password_hash
 
-# Sentinel file name used for CORE.config_path when dashboard initializes.
-# This ensures .parent returns the config directory instead of root.
-_DASHBOARD_SENTINEL_FILE = "___DASHBOARD_SENTINEL___.yaml"
-
 
 class DashboardSettings:
     """Settings for the dashboard."""
@@ -52,12 +48,7 @@ class DashboardSettings:
         self.config_dir = Path(args.configuration)
         self.absolute_config_dir = self.config_dir.resolve()
         self.verbose = args.verbose
-        # Set to a sentinel file so .parent gives us the config directory.
-        # Previously this was `os.path.join(self.config_dir, ".")` which worked because
-        # os.path.dirname("/config/.") returns "/config", but Path("/config/.").parent
-        # normalizes to Path("/config") first, then .parent returns Path("/"), breaking
-        # secret resolution. Using a sentinel file ensures .parent gives the correct directory.
-        CORE.config_path = self.config_dir / _DASHBOARD_SENTINEL_FILE
+        CORE.config_path = self.config_dir / "."
 
     @property
     def relative_url(self) -> str:

esphome/dashboard/web_server.py

@@ -1058,8 +1058,7 @@ class DownloadBinaryRequestHandler(BaseHandler):
             "download",
             f"{storage_json.name}-{file_name}",
         )
-
-        path = storage_json.firmware_bin_path.parent.joinpath(file_name)
+        path = storage_json.firmware_bin_path.with_name(file_name)
 
         if not path.is_file():
             args = ["esphome", "idedata", settings.rel_path(configuration)]

esphome/espota2.py

@@ -242,7 +242,7 @@ def send_check(
 
 
 def perform_ota(
-    sock: socket.socket, password: str | None, file_handle: io.IOBase, filename: Path
+    sock: socket.socket, password: str, file_handle: io.IOBase, filename: Path
 ) -> None:
     file_contents = file_handle.read()
     file_size = len(file_contents)
@@ -278,13 +278,13 @@ def perform_ota(
 
     def perform_auth(
         sock: socket.socket,
-        password: str | None,
+        password: str,
         hash_func: Callable[..., Any],
         nonce_size: int,
         hash_name: str,
     ) -> None:
         """Perform challenge-response authentication using specified hash algorithm."""
-        if password is None:
+        if not password:
             raise OTAError("ESP requests password, but no password given!")
 
         nonce_bytes = receive_exactly(
@@ -385,7 +385,7 @@ def perform_ota(
 
 
 def run_ota_impl_(
-    remote_host: str | list[str], remote_port: int, password: str | None, filename: Path
+    remote_host: str | list[str], remote_port: int, password: str, filename: Path
 ) -> tuple[int, str | None]:
     from esphome.core import CORE
 
@@ -410,7 +410,7 @@ def run_ota_impl_(
         af, socktype, _, _, sa = r
         _LOGGER.info("Connecting to %s port %s...", sa[0], sa[1])
         sock = socket.socket(af, socktype)
-        sock.settimeout(20.0)
+        sock.settimeout(10.0)
         try:
             sock.connect(sa)
         except OSError as err:
@@ -436,7 +436,7 @@ def run_ota_impl_(
 
 
 def run_ota(
-    remote_host: str | list[str], remote_port: int, password: str | None, filename: Path
+    remote_host: str | list[str], remote_port: int, password: str, filename: Path
 ) -> tuple[int, str | None]:
     try:
         return run_ota_impl_(remote_host, remote_port, password, filename)

esphome/writer.py

@@ -15,8 +15,6 @@ from esphome.const import (
 from esphome.core import CORE, EsphomeError
 from esphome.helpers import (
     copy_file_if_changed,
-    get_str_env,
-    is_ha_addon,
     read_file,
     walk_files,
     write_file_if_changed,
@@ -340,21 +338,16 @@ def clean_build():
 def clean_all(configuration: list[str]):
     import shutil
 
-    data_dirs = [Path(dir) / ".esphome" for dir in configuration]
-    if is_ha_addon():
-        data_dirs.append(Path("/data"))
-    if "ESPHOME_DATA_DIR" in os.environ:
-        data_dirs.append(Path(get_str_env("ESPHOME_DATA_DIR", None)))
-
-    # Clean build dir
-    for dir in data_dirs:
-        if dir.is_dir():
-            _LOGGER.info("Cleaning %s", dir)
-            # Don't remove storage or .json files which are needed by the dashboard
-            for item in dir.iterdir():
-                if item.is_file() and not item.name.endswith(".json"):
+    # Clean entire build dir
+    for dir in configuration:
+        build_dir = Path(dir) / ".esphome"
+        if build_dir.is_dir():
+            _LOGGER.info("Cleaning %s", build_dir)
+            # Don't remove storage as it will cause the dashboard to regenerate all configs
+            for item in build_dir.iterdir():
+                if item.is_file():
                     item.unlink()
-                elif item.is_dir() and item.name != "storage":
+                elif item.name != "storage" and item.is_dir():
                     shutil.rmtree(item)
 
     # Clean PlatformIO project files

netlify.toml

@@ -1,4 +1,3 @@
 [build]
   command = "script/build-api-docs"
   publish = "api-docs"
-  environment = { PYTHON_VERSION = "3.13" }

requirements.txt

@@ -11,8 +11,8 @@ pyserial==3.5
 platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
 esptool==5.1.0
 click==8.1.7
-esphome-dashboard==20251013.0
-aioesphomeapi==41.16.1
+esphome-dashboard==20251009.0
+aioesphomeapi==41.13.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.18.15 # dashboard_import

requirements_test.txt

@@ -1,7 +1,7 @@
 pylint==3.3.9
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
 ruff==0.14.0  # also change in .pre-commit-config.yaml when updating
-pyupgrade==3.20.0  # also change in .pre-commit-config.yaml when updating
+pyupgrade==3.21.0  # also change in .pre-commit-config.yaml when updating
 pre-commit
 
 # Unit tests

tests/component_tests/mipi_spi/test_init.py

@@ -69,7 +69,7 @@ def run_schema_validation(config: ConfigType) -> None:
             {
                 "id": "display_id",
                 "model": "custom",
-                "dimensions": {"width": 260, "height": 260},
+                "dimensions": {"width": 320, "height": 240},
                 "draw_rounding": 13,
                 "init_sequence": [[0xA0, 0x01]],
             },
@@ -336,7 +336,7 @@ def test_native_generation(
 
     main_cpp = generate_main(component_fixture_path("native.yaml"))
     assert (
-        "mipi_spi::MipiSpiBuffer<uint16_t, mipi_spi::PIXEL_MODE_16, true, mipi_spi::PIXEL_MODE_16, mipi_spi::BUS_TYPE_QUAD, 360, 360, 0, 1, display::DISPLAY_ROTATION_0_DEGREES, 1, 1>()"
+        "mipi_spi::MipiSpiBuffer<uint16_t, mipi_spi::PIXEL_MODE_16, true, mipi_spi::PIXEL_MODE_16, mipi_spi::BUS_TYPE_QUAD, 360, 360, 0, 1, display::DISPLAY_ROTATION_0_DEGREES, 1>()"
         in main_cpp
     )
     assert "set_init_sequence({240, 1, 8, 242" in main_cpp

tests/components/chsc6x/test.esp32-c3-idf.yaml

@@ -7,8 +7,8 @@ display:
     id: ili9xxx_display
     model: GC9A01A
     invert_colors: True
-    cs_pin: 11
-    dc_pin: 7
+    cs_pin: 10
+    dc_pin: 6
     pages:
       - id: page1
         lambda: |-

tests/components/mipi_rgb/test.esp32-s3-idf.yaml

@@ -40,7 +40,9 @@ display:
         - number: 17
       blue:
         - number: 47
-        - number: 1
+          allow_other_uses: true
+        - number: 41
+          allow_other_uses: true
         - number: 0
           ignore_strapping_warning: true
         - number: 42
@@ -51,7 +53,7 @@ display:
       number: 45
       ignore_strapping_warning: true
     hsync_pin:
-      number: 38
+      number: 40
     vsync_pin:
       number: 48
     data_rate: 1000000.0

tests/components/mipi_spi/common.yaml

@@ -10,7 +10,7 @@ display:
     invert_colors: true
     show_test_card: true
     spi_mode: mode0
-    draw_rounding: 4
+    draw_rounding: 8
     use_axis_flips: true
     init_sequence:
       - [0xd0, 1, 2, 3]

tests/components/mipi_spi/test.rp2040-ard.yaml

@@ -1,7 +1,7 @@
 substitutions:
   dc_pin: GPIO14
   cs_pin: GPIO13
-  enable_pin: GPIO17
+  enable_pin: GPIO16
   reset_pin: GPIO20
 
 packages:

tests/components/pzemac/test.esp32-idf.yaml

@@ -1,7 +1,6 @@
 substitutions:
   tx_pin: GPIO4
   rx_pin: GPIO5
-  flow_control_pin: GPIO13
 
 packages:
   modbus: !include ../../test_build_components/common/modbus/esp32-idf.yaml

tests/components/pzemdc/test.esp32-idf.yaml

@@ -1,7 +1,6 @@
 substitutions:
   tx_pin: GPIO4
   rx_pin: GPIO5
-  flow_control_pin: GPIO13
 
 packages:
   modbus: !include ../../test_build_components/common/modbus/esp32-idf.yaml

tests/components/sdm_meter/test.esp32-idf.yaml

@@ -1,7 +1,6 @@
 substitutions:
   tx_pin: GPIO4
   rx_pin: GPIO5
-  flow_control_pin: GPIO13
 
 packages:
   modbus: !include ../../test_build_components/common/modbus/esp32-idf.yaml

tests/components/usb_host/test.esp32-s3-idf.yaml

@@ -1,5 +1,4 @@
 usb_host:
-  max_transfer_requests: 32  # Test uint32_t bitmask path (17-32 requests)
   devices:
     - id: device_1
       vid: 0x1234

tests/dashboard/test_settings.py

@@ -2,13 +2,11 @@
 
 from __future__ import annotations
 
-from argparse import Namespace
 from pathlib import Path
 import tempfile
 
 import pytest
 
-from esphome.core import CORE
 from esphome.dashboard.settings import DashboardSettings
 
 
@@ -161,63 +159,3 @@ def test_rel_path_with_numeric_args(dashboard_settings: DashboardSettings) -> No
     result = dashboard_settings.rel_path("123", "456.789")
     expected = dashboard_settings.config_dir / "123" / "456.789"
     assert result == expected
-
-
-def test_config_path_parent_resolves_to_config_dir(tmp_path: Path) -> None:
-    """Test that CORE.config_path.parent resolves to config_dir after parse_args.
-
-    This is a regression test for issue #11280 where binary download failed
-    when using packages with secrets after the Path migration in 2025.10.0.
-
-    The issue was that after switching from os.path to Path:
-    - Before: os.path.dirname("/config/.") → "/config"
-    - After: Path("/config/.").parent → Path("/") (normalized first!)
-
-    The fix uses a sentinel file so .parent returns the correct directory:
-    - Fixed: Path("/config/___DASHBOARD_SENTINEL___.yaml").parent → Path("/config")
-    """
-    # Create test directory structure with secrets and packages
-    config_dir = tmp_path / "config"
-    config_dir.mkdir()
-
-    # Create secrets.yaml with obviously fake test values
-    secrets_file = config_dir / "secrets.yaml"
-    secrets_file.write_text(
-        "wifi_ssid: TEST-DUMMY-SSID\n"
-        "wifi_password: not-a-real-password-just-for-testing\n"
-    )
-
-    # Create package file that uses secrets
-    package_file = config_dir / "common.yaml"
-    package_file.write_text(
-        "wifi:\n  ssid: !secret wifi_ssid\n  password: !secret wifi_password\n"
-    )
-
-    # Create main device config that includes the package
-    device_config = config_dir / "test-device.yaml"
-    device_config.write_text(
-        "esphome:\n  name: test-device\n\npackages:\n  common: !include common.yaml\n"
-    )
-
-    # Set up dashboard settings with our test config directory
-    settings = DashboardSettings()
-    args = Namespace(
-        configuration=str(config_dir),
-        password=None,
-        username=None,
-        ha_addon=False,
-        verbose=False,
-    )
-    settings.parse_args(args)
-
-    # Verify that CORE.config_path.parent correctly points to the config directory
-    # This is critical for secret resolution in yaml_util.py which does:
-    #   main_config_dir = CORE.config_path.parent
-    #   main_secret_yml = main_config_dir / "secrets.yaml"
-    assert CORE.config_path.parent == config_dir.resolve()
-    assert (CORE.config_path.parent / "secrets.yaml").exists()
-    assert (CORE.config_path.parent / "common.yaml").exists()
-
-    # Verify that CORE.config_path itself uses the sentinel file
-    assert CORE.config_path.name == "___DASHBOARD_SENTINEL___.yaml"
-    assert not CORE.config_path.exists()  # Sentinel file doesn't actually exist

tests/dashboard/test_web_server.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from argparse import Namespace
 import asyncio
 from collections.abc import Generator
 from contextlib import asynccontextmanager
@@ -18,8 +17,6 @@ from tornado.ioloop import IOLoop
 from tornado.testing import bind_unused_port
 from tornado.websocket import WebSocketClientConnection, websocket_connect
 
-from esphome import yaml_util
-from esphome.core import CORE
 from esphome.dashboard import web_server
 from esphome.dashboard.const import DashboardEvent
 from esphome.dashboard.core import DASHBOARD
@@ -35,26 +32,6 @@ from esphome.zeroconf import DiscoveredImport
 from .common import get_fixture_path
 
 
-def get_build_path(base_path: Path, device_name: str) -> Path:
-    """Get the build directory path for a device.
-
-    This is a test helper that constructs the standard ESPHome build directory
-    structure. Note: This helper does NOT perform path traversal sanitization
-    because it's only used in tests where we control the inputs. The actual
-    web_server.py code handles sanitization in DownloadBinaryRequestHandler.get()
-    via file_name.replace("..", "").lstrip("/").
-
-    Args:
-        base_path: The base temporary path (typically tmp_path from pytest)
-        device_name: The name of the device (should not contain path separators
-                     in production use, but tests may use it for specific scenarios)
-
-    Returns:
-        Path to the build directory (.esphome/build/device_name)
-    """
-    return base_path / ".esphome" / "build" / device_name
-
-
 class DashboardTestHelper:
     def __init__(self, io_loop: IOLoop, client: AsyncHTTPClient, port: int) -> None:
         self.io_loop = io_loop
@@ -437,180 +414,6 @@ async def test_download_binary_handler_idedata_fallback(
     assert response.body == b"bootloader content"
 
 
-@pytest.mark.asyncio
-@pytest.mark.usefixtures("mock_ext_storage_path")
-async def test_download_binary_handler_subdirectory_file(
-    dashboard: DashboardTestHelper,
-    tmp_path: Path,
-    mock_storage_json: MagicMock,
-) -> None:
-    """Test the DownloadBinaryRequestHandler.get with file in subdirectory (nRF52 case).
-
-    This is a regression test for issue #11343 where the Path migration broke
-    downloads for nRF52 firmware files in subdirectories like 'zephyr/zephyr.uf2'.
-
-    The issue was that with_name() doesn't accept path separators:
-    - Before: path = storage_json.firmware_bin_path.with_name(file_name)
-      ValueError: Invalid name 'zephyr/zephyr.uf2'
-    - After: path = storage_json.firmware_bin_path.parent.joinpath(file_name)
-      Works correctly with subdirectory paths
-    """
-    # Create a fake nRF52 build structure with firmware in subdirectory
-    build_dir = get_build_path(tmp_path, "nrf52-device")
-    zephyr_dir = build_dir / "zephyr"
-    zephyr_dir.mkdir(parents=True)
-
-    # Create the main firmware binary (would be in build root)
-    firmware_file = build_dir / "firmware.bin"
-    firmware_file.write_bytes(b"main firmware")
-
-    # Create the UF2 file in zephyr subdirectory (nRF52 specific)
-    uf2_file = zephyr_dir / "zephyr.uf2"
-    uf2_file.write_bytes(b"nRF52 UF2 firmware content")
-
-    # Mock storage JSON
-    mock_storage = Mock()
-    mock_storage.name = "nrf52-device"
-    mock_storage.firmware_bin_path = firmware_file
-    mock_storage_json.load.return_value = mock_storage
-
-    # Request the UF2 file with subdirectory path
-    response = await dashboard.fetch(
-        "/download.bin?configuration=nrf52-device.yaml&file=zephyr/zephyr.uf2",
-        method="GET",
-    )
-    assert response.code == 200
-    assert response.body == b"nRF52 UF2 firmware content"
-    assert response.headers["Content-Type"] == "application/octet-stream"
-    assert "attachment" in response.headers["Content-Disposition"]
-    # Download name should be device-name + full file path
-    assert "nrf52-device-zephyr/zephyr.uf2" in response.headers["Content-Disposition"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.usefixtures("mock_ext_storage_path")
-async def test_download_binary_handler_subdirectory_file_url_encoded(
-    dashboard: DashboardTestHelper,
-    tmp_path: Path,
-    mock_storage_json: MagicMock,
-) -> None:
-    """Test the DownloadBinaryRequestHandler.get with URL-encoded subdirectory path.
-
-    Verifies that URL-encoded paths (e.g., zephyr%2Fzephyr.uf2) are correctly
-    decoded and handled, and that custom download names work with subdirectories.
-    """
-    # Create a fake build structure with firmware in subdirectory
-    build_dir = get_build_path(tmp_path, "test")
-    zephyr_dir = build_dir / "zephyr"
-    zephyr_dir.mkdir(parents=True)
-
-    firmware_file = build_dir / "firmware.bin"
-    firmware_file.write_bytes(b"content")
-
-    uf2_file = zephyr_dir / "zephyr.uf2"
-    uf2_file.write_bytes(b"content")
-
-    # Mock storage JSON
-    mock_storage = Mock()
-    mock_storage.name = "test_device"
-    mock_storage.firmware_bin_path = firmware_file
-    mock_storage_json.load.return_value = mock_storage
-
-    # Request with URL-encoded path and custom download name
-    response = await dashboard.fetch(
-        "/download.bin?configuration=test.yaml&file=zephyr%2Fzephyr.uf2&download=custom_name.bin",
-        method="GET",
-    )
-    assert response.code == 200
-    assert "custom_name.bin" in response.headers["Content-Disposition"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.usefixtures("mock_ext_storage_path")
-@pytest.mark.parametrize(
-    "attack_path",
-    [
-        pytest.param("../../../secrets.yaml", id="basic_traversal"),
-        pytest.param("..%2F..%2F..%2Fsecrets.yaml", id="url_encoded"),
-        pytest.param("zephyr/../../../secrets.yaml", id="traversal_with_prefix"),
-        pytest.param("/etc/passwd", id="absolute_path"),
-        pytest.param("//etc/passwd", id="double_slash_absolute"),
-        pytest.param("....//secrets.yaml", id="multiple_dots"),
-    ],
-)
-async def test_download_binary_handler_path_traversal_protection(
-    dashboard: DashboardTestHelper,
-    tmp_path: Path,
-    mock_storage_json: MagicMock,
-    attack_path: str,
-) -> None:
-    """Test that DownloadBinaryRequestHandler prevents path traversal attacks.
-
-    Verifies that attempts to use '..' in file paths are sanitized to prevent
-    accessing files outside the build directory. Tests multiple attack vectors.
-    """
-    # Create build structure
-    build_dir = get_build_path(tmp_path, "test")
-    build_dir.mkdir(parents=True)
-    firmware_file = build_dir / "firmware.bin"
-    firmware_file.write_bytes(b"firmware content")
-
-    # Create a sensitive file outside the build directory that should NOT be accessible
-    sensitive_file = tmp_path / "secrets.yaml"
-    sensitive_file.write_bytes(b"secret: my_secret_password")
-
-    # Mock storage JSON
-    mock_storage = Mock()
-    mock_storage.name = "test_device"
-    mock_storage.firmware_bin_path = firmware_file
-    mock_storage_json.load.return_value = mock_storage
-
-    # Attempt path traversal attack - should be blocked
-    with pytest.raises(HTTPClientError) as exc_info:
-        await dashboard.fetch(
-            f"/download.bin?configuration=test.yaml&file={attack_path}",
-            method="GET",
-        )
-    # Should get 404 (file not found after sanitization) or 500 (idedata fails)
-    assert exc_info.value.code in (404, 500)
-
-
-@pytest.mark.asyncio
-@pytest.mark.usefixtures("mock_ext_storage_path")
-async def test_download_binary_handler_multiple_subdirectory_levels(
-    dashboard: DashboardTestHelper,
-    tmp_path: Path,
-    mock_storage_json: MagicMock,
-) -> None:
-    """Test downloading files from multiple subdirectory levels.
-
-    Verifies that joinpath correctly handles multi-level paths like 'build/output/firmware.bin'.
-    """
-    # Create nested directory structure
-    build_dir = get_build_path(tmp_path, "test")
-    nested_dir = build_dir / "build" / "output"
-    nested_dir.mkdir(parents=True)
-
-    firmware_file = build_dir / "firmware.bin"
-    firmware_file.write_bytes(b"main")
-
-    nested_file = nested_dir / "firmware.bin"
-    nested_file.write_bytes(b"nested firmware content")
-
-    # Mock storage JSON
-    mock_storage = Mock()
-    mock_storage.name = "test_device"
-    mock_storage.firmware_bin_path = firmware_file
-    mock_storage_json.load.return_value = mock_storage
-
-    response = await dashboard.fetch(
-        "/download.bin?configuration=test.yaml&file=build/output/firmware.bin",
-        method="GET",
-    )
-    assert response.code == 200
-    assert response.body == b"nested firmware content"
-
-
 @pytest.mark.asyncio
 async def test_edit_request_handler_post_invalid_file(
     dashboard: DashboardTestHelper,
@@ -1499,71 +1302,3 @@ async def test_dashboard_subscriber_refresh_event(
 
         # Give it a moment to clean up
         await asyncio.sleep(0.01)
-
-
-@pytest.mark.asyncio
-async def test_dashboard_yaml_loading_with_packages_and_secrets(
-    tmp_path: Path,
-) -> None:
-    """Test dashboard YAML loading with packages referencing secrets.
-
-    This is a regression test for issue #11280 where binary download failed
-    when using packages with secrets after the Path migration in 2025.10.0.
-
-    This test verifies that CORE.config_path initialization in the dashboard
-    allows yaml_util.load_yaml() to correctly resolve secrets from packages.
-    """
-    # Create test directory structure with secrets and packages
-    config_dir = tmp_path / "config"
-    config_dir.mkdir()
-
-    # Create secrets.yaml with obviously fake test values
-    secrets_file = config_dir / "secrets.yaml"
-    secrets_file.write_text(
-        "wifi_ssid: TEST-DUMMY-SSID\n"
-        "wifi_password: not-a-real-password-just-for-testing\n"
-    )
-
-    # Create package file that uses secrets
-    package_file = config_dir / "common.yaml"
-    package_file.write_text(
-        "wifi:\n  ssid: !secret wifi_ssid\n  password: !secret wifi_password\n"
-    )
-
-    # Create main device config that includes the package
-    device_config = config_dir / "test-download-secrets.yaml"
-    device_config.write_text(
-        "esphome:\n  name: test-download-secrets\n  platform: ESP32\n  board: esp32dev\n\n"
-        "packages:\n  common: !include common.yaml\n"
-    )
-
-    # Initialize DASHBOARD settings with our test config directory
-    # This is what sets CORE.config_path - the critical code path for the bug
-    args = Namespace(
-        configuration=str(config_dir),
-        password=None,
-        username=None,
-        ha_addon=False,
-        verbose=False,
-    )
-    DASHBOARD.settings.parse_args(args)
-
-    # With the fix: CORE.config_path should be config_dir / "___DASHBOARD_SENTINEL___.yaml"
-    # so CORE.config_path.parent would be config_dir
-    # Without the fix: CORE.config_path is config_dir / "." which normalizes to config_dir
-    # so CORE.config_path.parent would be tmp_path (the parent of config_dir)
-
-    # The fix ensures CORE.config_path.parent points to config_dir
-    assert CORE.config_path.parent == config_dir.resolve(), (
-        f"CORE.config_path.parent should point to config_dir. "
-        f"Got {CORE.config_path.parent}, expected {config_dir.resolve()}. "
-        f"CORE.config_path is {CORE.config_path}"
-    )
-
-    # Now load the YAML with packages that reference secrets
-    # This is where the bug would manifest - yaml_util.load_yaml would fail
-    # to find secrets.yaml because CORE.config_path.parent pointed to the wrong place
-    config = yaml_util.load_yaml(device_config)
-    # If we get here, secret resolution worked!
-    assert "esphome" in config
-    assert config["esphome"]["name"] == "test-download-secrets"

tests/unit_tests/test_core.py

@@ -570,13 +570,6 @@ class TestEsphomeCore:
 
         assert target.address == "4.3.2.1"
 
-    def test_address__openthread(self, target):
-        target.name = "test-device"
-        target.config = {}
-        target.config[const.CONF_OPENTHREAD] = {}
-
-        assert target.address == "test-device.local"
-
     def test_is_esp32(self, target):
         target.data[const.KEY_CORE] = {const.KEY_TARGET_PLATFORM: "esp32"}
 

tests/unit_tests/test_espota2.py

@@ -287,7 +287,7 @@ def test_perform_ota_no_auth(mock_socket: Mock, mock_file: io.BytesIO) -> None:
 
     mock_socket.recv.side_effect = recv_responses
 
-    espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+    espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
     # Should not send any auth-related data
     auth_calls = [
@@ -317,7 +317,7 @@ def test_perform_ota_with_compression(mock_socket: Mock) -> None:
 
     mock_socket.recv.side_effect = recv_responses
 
-    espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+    espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
     # Verify compressed content was sent
     # Get the binary size that was sent (4 bytes after features)
@@ -347,7 +347,7 @@ def test_perform_ota_auth_without_password(mock_socket: Mock) -> None:
     with pytest.raises(
         espota2.OTAError, match="ESP requests password, but no password given"
     ):
-        espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+        espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
 
 @pytest.mark.usefixtures("mock_time")
@@ -413,7 +413,7 @@ def test_perform_ota_sha256_auth_without_password(mock_socket: Mock) -> None:
     with pytest.raises(
         espota2.OTAError, match="ESP requests password, but no password given"
     ):
-        espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+        espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
 
 def test_perform_ota_unexpected_auth_response(mock_socket: Mock) -> None:
@@ -450,7 +450,7 @@ def test_perform_ota_unsupported_version(mock_socket: Mock) -> None:
     mock_socket.recv.side_effect = responses
 
     with pytest.raises(espota2.OTAError, match="Device uses unsupported OTA version"):
-        espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+        espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
 
 @pytest.mark.usefixtures("mock_time")
@@ -471,7 +471,7 @@ def test_perform_ota_upload_error(mock_socket: Mock, mock_file: io.BytesIO) -> N
     mock_socket.recv.side_effect = recv_responses
 
     with pytest.raises(espota2.OTAError, match="Error receiving acknowledge chunk OK"):
-        espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+        espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
 
 @pytest.mark.usefixtures("mock_socket_constructor", "mock_resolve_ip")
@@ -493,7 +493,7 @@ def test_run_ota_impl_successful(
     assert result_host == "192.168.1.100"
 
     # Verify socket was configured correctly
-    mock_socket.settimeout.assert_called_with(20.0)
+    mock_socket.settimeout.assert_called_with(10.0)
     mock_socket.connect.assert_called_once_with(("192.168.1.100", 3232))
     mock_socket.close.assert_called_once()
 
@@ -706,7 +706,7 @@ def test_perform_ota_version_differences(
     ]
 
     mock_socket.recv.side_effect = recv_responses
-    espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+    espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
     # For v1.0, verify that we only get the expected number of recv calls
     # v1.0 doesn't have chunk acknowledgments, so fewer recv calls
@@ -732,7 +732,7 @@ def test_perform_ota_version_differences(
     ]
 
     mock_socket.recv.side_effect = recv_responses_v2
-    espota2.perform_ota(mock_socket, None, mock_file, "test.bin")
+    espota2.perform_ota(mock_socket, "", mock_file, "test.bin")
 
     # For v2.0, verify more recv calls due to chunk acknowledgments
     assert mock_socket.recv.call_count == 9  # v2.0 has 9 recv calls (includes chunk OK)

tests/unit_tests/test_main.py

@@ -321,14 +321,12 @@ def test_choose_upload_log_host_with_serial_device_no_ports(
 ) -> None:
     """Test SERIAL device when no serial ports are found."""
     setup_core()
-    with pytest.raises(
-        EsphomeError, match="All specified devices .* could not be resolved"
-    ):
-        choose_upload_log_host(
-            default="SERIAL",
-            check_default=None,
-            purpose=Purpose.UPLOADING,
-        )
+    result = choose_upload_log_host(
+        default="SERIAL",
+        check_default=None,
+        purpose=Purpose.UPLOADING,
+    )
+    assert result == []
     assert "No serial ports found, skipping SERIAL device" in caplog.text
 
 
@@ -369,14 +367,12 @@ def test_choose_upload_log_host_with_ota_device_with_api_config() -> None:
     """Test OTA device when API is configured (no upload without OTA in config)."""
     setup_core(config={CONF_API: {}}, address="192.168.1.100")
 
-    with pytest.raises(
-        EsphomeError, match="All specified devices .* could not be resolved"
-    ):
-        choose_upload_log_host(
-            default="OTA",
-            check_default=None,
-            purpose=Purpose.UPLOADING,
-        )
+    result = choose_upload_log_host(
+        default="OTA",
+        check_default=None,
+        purpose=Purpose.UPLOADING,
+    )
+    assert result == []
 
 
 def test_choose_upload_log_host_with_ota_device_with_api_config_logging() -> None:
@@ -409,14 +405,12 @@ def test_choose_upload_log_host_with_ota_device_no_fallback() -> None:
     """Test OTA device with no valid fallback options."""
     setup_core()
 
-    with pytest.raises(
-        EsphomeError, match="All specified devices .* could not be resolved"
-    ):
-        choose_upload_log_host(
-            default="OTA",
-            check_default=None,
-            purpose=Purpose.UPLOADING,
-        )
+    result = choose_upload_log_host(
+        default="OTA",
+        check_default=None,
+        purpose=Purpose.UPLOADING,
+    )
+    assert result == []
 
 
 @pytest.mark.usefixtures("mock_choose_prompt")
@@ -621,19 +615,21 @@ def test_choose_upload_log_host_empty_defaults_list() -> None:
 
 
 @pytest.mark.usefixtures("mock_no_serial_ports", "mock_no_mqtt_logging")
-def test_choose_upload_log_host_all_devices_unresolved() -> None:
+def test_choose_upload_log_host_all_devices_unresolved(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
     """Test when all specified devices cannot be resolved."""
     setup_core()
 
-    with pytest.raises(
-        EsphomeError,
-        match=r"All specified devices \['SERIAL', 'OTA'\] could not be resolved",
-    ):
-        choose_upload_log_host(
-            default=["SERIAL", "OTA"],
-            check_default=None,
-            purpose=Purpose.UPLOADING,
-        )
+    result = choose_upload_log_host(
+        default=["SERIAL", "OTA"],
+        check_default=None,
+        purpose=Purpose.UPLOADING,
+    )
+    assert result == []
+    assert (
+        "All specified devices: ['SERIAL', 'OTA'] could not be resolved." in caplog.text
+    )
 
 
 @pytest.mark.usefixtures("mock_no_serial_ports", "mock_no_mqtt_logging")
@@ -766,14 +762,12 @@ def test_choose_upload_log_host_no_address_with_ota_config() -> None:
     """Test OTA device when OTA is configured but no address is set."""
     setup_core(config={CONF_OTA: {}})
 
-    with pytest.raises(
-        EsphomeError, match="All specified devices .* could not be resolved"
-    ):
-        choose_upload_log_host(
-            default="OTA",
-            check_default=None,
-            purpose=Purpose.UPLOADING,
-        )
+    result = choose_upload_log_host(
+        default="OTA",
+        check_default=None,
+        purpose=Purpose.UPLOADING,
+    )
+    assert result == []
 
 
 @dataclass
@@ -1068,7 +1062,7 @@ def test_upload_program_ota_with_file_arg(
     assert exit_code == 0
     assert host == "192.168.1.100"
     mock_run_ota.assert_called_once_with(
-        ["192.168.1.100"], 3232, None, Path("custom.bin")
+        ["192.168.1.100"], 3232, "", Path("custom.bin")
     )
 
 
@@ -1125,9 +1119,7 @@ def test_upload_program_ota_with_mqtt_resolution(
     expected_firmware = (
         tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin"
     )
-    mock_run_ota.assert_called_once_with(
-        ["192.168.1.100"], 3232, None, expected_firmware
-    )
+    mock_run_ota.assert_called_once_with(["192.168.1.100"], 3232, "", expected_firmware)
 
 
 @patch("esphome.__main__.importlib.import_module")
@@ -1211,31 +1203,6 @@ def test_show_logs_api(
     )
 
 
-@patch("esphome.components.api.client.run_logs")
-def test_show_logs_api_with_fqdn_mdns_disabled(
-    mock_run_logs: Mock,
-) -> None:
-    """Test show_logs with API using FQDN when mDNS is disabled."""
-    setup_core(
-        config={
-            "logger": {},
-            CONF_API: {},
-            CONF_MDNS: {CONF_DISABLED: True},
-        },
-        platform=PLATFORM_ESP32,
-    )
-    mock_run_logs.return_value = 0
-
-    args = MockArgs()
-    devices = ["device.example.com"]
-
-    result = show_logs(CORE.config, args, devices)
-
-    assert result == 0
-    # Should use the FQDN directly, not try MQTT lookup
-    mock_run_logs.assert_called_once_with(CORE.config, ["device.example.com"])
-
-
 @patch("esphome.components.api.client.run_logs")
 def test_show_logs_api_with_mqtt_fallback(
     mock_run_logs: Mock,
@@ -1255,7 +1222,7 @@ def test_show_logs_api_with_mqtt_fallback(
     mock_mqtt_get_ip.return_value = ["192.168.1.200"]
 
     args = MockArgs(username="user", password="pass", client_id="client")
-    devices = ["MQTTIP"]
+    devices = ["device.local"]
 
     result = show_logs(CORE.config, args, devices)
 
@@ -1520,31 +1487,27 @@ def test_mqtt_get_ip() -> None:
 def test_has_resolvable_address() -> None:
     """Test has_resolvable_address function."""
 
-    # Test with mDNS enabled and .local hostname address
+    # Test with mDNS enabled and hostname address
     setup_core(config={}, address="esphome-device.local")
     assert has_resolvable_address() is True
 
-    # Test with mDNS disabled and .local hostname address (still resolvable via DNS)
+    # Test with mDNS disabled and hostname address
     setup_core(
         config={CONF_MDNS: {CONF_DISABLED: True}}, address="esphome-device.local"
     )
-    assert has_resolvable_address() is True
+    assert has_resolvable_address() is False
 
-    # Test with mDNS disabled and regular DNS hostname (resolvable)
-    setup_core(config={CONF_MDNS: {CONF_DISABLED: True}}, address="device.example.com")
-    assert has_resolvable_address() is True
-
-    # Test with IP address (always resolvable, mDNS doesn't matter)
+    # Test with IP address (mDNS doesn't matter)
     setup_core(config={}, address="192.168.1.100")
     assert has_resolvable_address() is True
 
-    # Test with IP address and mDNS disabled (still resolvable)
+    # Test with IP address and mDNS disabled
     setup_core(config={CONF_MDNS: {CONF_DISABLED: True}}, address="192.168.1.100")
     assert has_resolvable_address() is True
 
-    # Test with no address
+    # Test with no address but mDNS enabled (can still resolve mDNS names)
     setup_core(config={}, address=None)
-    assert has_resolvable_address() is False
+    assert has_resolvable_address() is True
 
     # Test with no address and mDNS disabled
     setup_core(config={CONF_MDNS: {CONF_DISABLED: True}}, address=None)
@@ -1984,292 +1947,3 @@ def test_command_clean_all_args_used() -> None:
         # Verify the correct configuration paths were passed
         mock_clean_all.assert_any_call(["/path/to/config1"])
         mock_clean_all.assert_any_call(["/path/to/config2", "/path/to/config3"])
-
-
-def test_upload_program_ota_static_ip_with_mqttip(
-    mock_mqtt_get_ip: Mock,
-    mock_run_ota: Mock,
-    tmp_path: Path,
-) -> None:
-    """Test upload_program with static IP and MQTTIP (issue #11260).
-
-    This tests the scenario where a device has manual_ip (static IP) configured
-    and MQTT is also configured. The devices list contains both the static IP
-    and "MQTTIP" magic string. This previously failed because only the first
-    device was checked for MQTT resolution.
-    """
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path)
-
-    mock_mqtt_get_ip.return_value = ["192.168.2.50"]  # Different subnet
-    mock_run_ota.return_value = (0, "192.168.1.100")
-
-    config = {
-        CONF_OTA: [
-            {
-                CONF_PLATFORM: CONF_ESPHOME,
-                CONF_PORT: 3232,
-            }
-        ],
-        CONF_MQTT: {
-            CONF_BROKER: "mqtt.local",
-        },
-    }
-    args = MockArgs(username="user", password="pass", client_id="client")
-    # Simulates choose_upload_log_host returning static IP + MQTTIP
-    devices = ["192.168.1.100", "MQTTIP"]
-
-    exit_code, host = upload_program(config, args, devices)
-
-    assert exit_code == 0
-    assert host == "192.168.1.100"
-
-    # Verify MQTT was resolved
-    mock_mqtt_get_ip.assert_called_once_with(config, "user", "pass", "client")
-
-    # Verify espota2.run_ota was called with both IPs
-    expected_firmware = (
-        tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin"
-    )
-    mock_run_ota.assert_called_once_with(
-        ["192.168.1.100", "192.168.2.50"], 3232, None, expected_firmware
-    )
-
-
-def test_upload_program_ota_multiple_mqttip_resolves_once(
-    mock_mqtt_get_ip: Mock,
-    mock_run_ota: Mock,
-    tmp_path: Path,
-) -> None:
-    """Test that MQTT resolution only happens once even with multiple MQTT magic strings."""
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path)
-
-    mock_mqtt_get_ip.return_value = ["192.168.2.50", "192.168.2.51"]
-    mock_run_ota.return_value = (0, "192.168.2.50")
-
-    config = {
-        CONF_OTA: [
-            {
-                CONF_PLATFORM: CONF_ESPHOME,
-                CONF_PORT: 3232,
-            }
-        ],
-        CONF_MQTT: {
-            CONF_BROKER: "mqtt.local",
-        },
-    }
-    args = MockArgs(username="user", password="pass", client_id="client")
-    # Multiple MQTT magic strings in the list
-    devices = ["MQTTIP", "MQTT", "192.168.1.100"]
-
-    exit_code, host = upload_program(config, args, devices)
-
-    assert exit_code == 0
-    assert host == "192.168.2.50"
-
-    # Verify MQTT was only resolved once despite multiple MQTT magic strings
-    mock_mqtt_get_ip.assert_called_once_with(config, "user", "pass", "client")
-
-    # Verify espota2.run_ota was called with all unique IPs
-    expected_firmware = (
-        tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin"
-    )
-    mock_run_ota.assert_called_once_with(
-        ["192.168.2.50", "192.168.2.51", "192.168.1.100"], 3232, None, expected_firmware
-    )
-
-
-def test_upload_program_ota_mqttip_deduplication(
-    mock_mqtt_get_ip: Mock,
-    mock_run_ota: Mock,
-    tmp_path: Path,
-) -> None:
-    """Test that duplicate IPs are filtered when MQTT returns same IP as static IP."""
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path)
-
-    # MQTT returns the same IP as the static IP
-    mock_mqtt_get_ip.return_value = ["192.168.1.100"]
-    mock_run_ota.return_value = (0, "192.168.1.100")
-
-    config = {
-        CONF_OTA: [
-            {
-                CONF_PLATFORM: CONF_ESPHOME,
-                CONF_PORT: 3232,
-            }
-        ],
-        CONF_MQTT: {
-            CONF_BROKER: "mqtt.local",
-        },
-    }
-    args = MockArgs(username="user", password="pass", client_id="client")
-    devices = ["192.168.1.100", "MQTTIP"]
-
-    exit_code, host = upload_program(config, args, devices)
-
-    assert exit_code == 0
-    assert host == "192.168.1.100"
-
-    # Verify MQTT was resolved
-    mock_mqtt_get_ip.assert_called_once_with(config, "user", "pass", "client")
-
-    # Verify espota2.run_ota was called with deduplicated IPs (only one instance of 192.168.1.100)
-    # Note: Current implementation doesn't dedupe, so we'll get the IP twice
-    # This test documents current behavior - deduplication could be future enhancement
-    mock_run_ota.assert_called_once()
-    call_args = mock_run_ota.call_args[0]
-    # Should contain both the original IP and MQTT-resolved IP (even if duplicate)
-    assert "192.168.1.100" in call_args[0]
-
-
-@patch("esphome.components.api.client.run_logs")
-def test_show_logs_api_static_ip_with_mqttip(
-    mock_run_logs: Mock,
-    mock_mqtt_get_ip: Mock,
-) -> None:
-    """Test show_logs with static IP and MQTTIP (issue #11260).
-
-    This tests the scenario where a device has manual_ip (static IP) configured
-    and MQTT is also configured. The devices list contains both the static IP
-    and "MQTTIP" magic string.
-    """
-    setup_core(
-        config={
-            "logger": {},
-            CONF_API: {},
-            CONF_MQTT: {CONF_BROKER: "mqtt.local"},
-        },
-        platform=PLATFORM_ESP32,
-    )
-    mock_run_logs.return_value = 0
-    mock_mqtt_get_ip.return_value = ["192.168.2.50"]
-
-    args = MockArgs(username="user", password="pass", client_id="client")
-    # Simulates choose_upload_log_host returning static IP + MQTTIP
-    devices = ["192.168.1.100", "MQTTIP"]
-
-    result = show_logs(CORE.config, args, devices)
-
-    assert result == 0
-
-    # Verify MQTT was resolved
-    mock_mqtt_get_ip.assert_called_once_with(CORE.config, "user", "pass", "client")
-
-    # Verify run_logs was called with both IPs
-    mock_run_logs.assert_called_once_with(
-        CORE.config, ["192.168.1.100", "192.168.2.50"]
-    )
-
-
-@patch("esphome.components.api.client.run_logs")
-def test_show_logs_api_multiple_mqttip_resolves_once(
-    mock_run_logs: Mock,
-    mock_mqtt_get_ip: Mock,
-) -> None:
-    """Test that MQTT resolution only happens once for show_logs with multiple MQTT magic strings."""
-    setup_core(
-        config={
-            "logger": {},
-            CONF_API: {},
-            CONF_MQTT: {CONF_BROKER: "mqtt.local"},
-        },
-        platform=PLATFORM_ESP32,
-    )
-    mock_run_logs.return_value = 0
-    mock_mqtt_get_ip.return_value = ["192.168.2.50", "192.168.2.51"]
-
-    args = MockArgs(username="user", password="pass", client_id="client")
-    # Multiple MQTT magic strings in the list
-    devices = ["MQTTIP", "192.168.1.100", "MQTT"]
-
-    result = show_logs(CORE.config, args, devices)
-
-    assert result == 0
-
-    # Verify MQTT was only resolved once despite multiple MQTT magic strings
-    mock_mqtt_get_ip.assert_called_once_with(CORE.config, "user", "pass", "client")
-
-    # Verify run_logs was called with all unique IPs (MQTT strings replaced with IPs)
-    # Note: "MQTT" is a different magic string from "MQTTIP", but both trigger MQTT resolution
-    # The _resolve_network_devices helper filters out both after first resolution
-    mock_run_logs.assert_called_once_with(
-        CORE.config, ["192.168.2.50", "192.168.2.51", "192.168.1.100"]
-    )
-
-
-def test_upload_program_ota_mqtt_timeout_fallback(
-    mock_mqtt_get_ip: Mock,
-    mock_run_ota: Mock,
-    tmp_path: Path,
-) -> None:
-    """Test upload_program falls back to other devices when MQTT times out."""
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path)
-
-    # MQTT times out
-    mock_mqtt_get_ip.side_effect = EsphomeError("Failed to find IP via MQTT")
-    mock_run_ota.return_value = (0, "192.168.1.100")
-
-    config = {
-        CONF_OTA: [
-            {
-                CONF_PLATFORM: CONF_ESPHOME,
-                CONF_PORT: 3232,
-            }
-        ],
-        CONF_MQTT: {
-            CONF_BROKER: "mqtt.local",
-        },
-    }
-    args = MockArgs(username="user", password="pass", client_id="client")
-    # Static IP first, MQTTIP second
-    devices = ["192.168.1.100", "MQTTIP"]
-
-    exit_code, host = upload_program(config, args, devices)
-
-    # Should succeed using the static IP even though MQTT failed
-    assert exit_code == 0
-    assert host == "192.168.1.100"
-
-    # Verify MQTT was attempted
-    mock_mqtt_get_ip.assert_called_once_with(config, "user", "pass", "client")
-
-    # Verify espota2.run_ota was called with only the static IP (MQTT failed)
-    expected_firmware = (
-        tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin"
-    )
-    mock_run_ota.assert_called_once_with(
-        ["192.168.1.100"], 3232, None, expected_firmware
-    )
-
-
-@patch("esphome.components.api.client.run_logs")
-def test_show_logs_api_mqtt_timeout_fallback(
-    mock_run_logs: Mock,
-    mock_mqtt_get_ip: Mock,
-) -> None:
-    """Test show_logs falls back to other devices when MQTT times out."""
-    setup_core(
-        config={
-            "logger": {},
-            CONF_API: {},
-            CONF_MQTT: {CONF_BROKER: "mqtt.local"},
-        },
-        platform=PLATFORM_ESP32,
-    )
-    mock_run_logs.return_value = 0
-    # MQTT times out
-    mock_mqtt_get_ip.side_effect = EsphomeError("Failed to find IP via MQTT")
-
-    args = MockArgs(username="user", password="pass", client_id="client")
-    # Static IP first, MQTTIP second
-    devices = ["192.168.1.100", "MQTTIP"]
-
-    result = show_logs(CORE.config, args, devices)
-
-    # Should succeed using the static IP even though MQTT failed
-    assert result == 0
-
-    # Verify MQTT was attempted
-    mock_mqtt_get_ip.assert_called_once_with(CORE.config, "user", "pass", "client")
-
-    # Verify run_logs was called with only the static IP (MQTT failed)
-    mock_run_logs.assert_called_once_with(CORE.config, ["192.168.1.100"])

tests/unit_tests/test_substitutions.py

@@ -2,12 +2,9 @@ import glob
 import logging
 from pathlib import Path
 
-from esphome import config as config_module, yaml_util
+from esphome import yaml_util
 from esphome.components import substitutions
-from esphome.config_helpers import merge_config
-from esphome.const import CONF_PACKAGES, CONF_SUBSTITUTIONS
-from esphome.core import CORE
-from esphome.util import OrderedDict
+from esphome.const import CONF_PACKAGES
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -121,200 +118,3 @@ def test_substitutions_fixtures(fixture_path):
     if DEV_MODE:
         _LOGGER.error("Tests passed, but Dev mode is enabled.")
     assert not DEV_MODE  # make sure DEV_MODE is disabled after you are finished.
-
-
-def test_substitutions_with_command_line_maintains_ordered_dict() -> None:
-    """Test that substitutions remain an OrderedDict when command line substitutions are provided,
-    and that move_to_end() can be called successfully.
-
-    This is a regression test for https://github.com/esphome/esphome/issues/11182
-    where the config would become a regular dict and fail when move_to_end() was called.
-    """
-    # Create an OrderedDict config with substitutions
-    config = OrderedDict()
-    config["esphome"] = {"name": "test"}
-    config[CONF_SUBSTITUTIONS] = {"var1": "value1", "var2": "value2"}
-    config["other_key"] = "other_value"
-
-    # Command line substitutions that should override
-    command_line_subs = {"var2": "override", "var3": "new_value"}
-
-    # Call do_substitution_pass with command line substitutions
-    substitutions.do_substitution_pass(config, command_line_subs)
-
-    # Verify that config is still an OrderedDict
-    assert isinstance(config, OrderedDict), "Config should remain an OrderedDict"
-
-    # Verify substitutions are at the beginning (move_to_end with last=False)
-    keys = list(config.keys())
-    assert keys[0] == CONF_SUBSTITUTIONS, "Substitutions should be first key"
-
-    # Verify substitutions were properly merged
-    assert config[CONF_SUBSTITUTIONS]["var1"] == "value1"
-    assert config[CONF_SUBSTITUTIONS]["var2"] == "override"
-    assert config[CONF_SUBSTITUTIONS]["var3"] == "new_value"
-
-    # Verify config[CONF_SUBSTITUTIONS] is also an OrderedDict
-    assert isinstance(config[CONF_SUBSTITUTIONS], OrderedDict), (
-        "Substitutions should be an OrderedDict"
-    )
-
-
-def test_substitutions_without_command_line_maintains_ordered_dict() -> None:
-    """Test that substitutions work correctly without command line substitutions."""
-    config = OrderedDict()
-    config["esphome"] = {"name": "test"}
-    config[CONF_SUBSTITUTIONS] = {"var1": "value1"}
-    config["other_key"] = "other_value"
-
-    # Call without command line substitutions
-    substitutions.do_substitution_pass(config, None)
-
-    # Verify that config is still an OrderedDict
-    assert isinstance(config, OrderedDict), "Config should remain an OrderedDict"
-
-    # Verify substitutions are at the beginning
-    keys = list(config.keys())
-    assert keys[0] == CONF_SUBSTITUTIONS, "Substitutions should be first key"
-
-
-def test_substitutions_after_merge_config_maintains_ordered_dict() -> None:
-    """Test that substitutions work after merge_config (packages scenario).
-
-    This is a regression test for https://github.com/esphome/esphome/issues/11182
-    where using packages would cause config to become a regular dict, breaking move_to_end().
-    """
-    # Simulate what happens with packages - merge two OrderedDict configs
-    base_config = OrderedDict()
-    base_config["esphome"] = {"name": "base"}
-    base_config[CONF_SUBSTITUTIONS] = {"var1": "value1"}
-
-    package_config = OrderedDict()
-    package_config["sensor"] = [{"platform": "template"}]
-    package_config[CONF_SUBSTITUTIONS] = {"var2": "value2"}
-
-    # Merge configs (simulating package merge)
-    merged_config = merge_config(base_config, package_config)
-
-    # Verify merged config is still an OrderedDict
-    assert isinstance(merged_config, OrderedDict), (
-        "Merged config should be an OrderedDict"
-    )
-
-    # Now try to run substitution pass on the merged config
-    substitutions.do_substitution_pass(merged_config, None)
-
-    # Should not raise AttributeError
-    assert isinstance(merged_config, OrderedDict), (
-        "Config should still be OrderedDict after substitution pass"
-    )
-    keys = list(merged_config.keys())
-    assert keys[0] == CONF_SUBSTITUTIONS, "Substitutions should be first key"
-
-
-def test_validate_config_with_command_line_substitutions_maintains_ordered_dict(
-    tmp_path,
-) -> None:
-    """Test that validate_config preserves OrderedDict when merging command-line substitutions.
-
-    This tests the code path in config.py where result[CONF_SUBSTITUTIONS] is set
-    using merge_dicts_ordered() with command-line substitutions provided.
-    """
-    # Create a minimal valid config
-    test_config = OrderedDict()
-    test_config["esphome"] = {"name": "test_device", "platform": "ESP32"}
-    test_config[CONF_SUBSTITUTIONS] = OrderedDict({"var1": "value1", "var2": "value2"})
-    test_config["esp32"] = {"board": "esp32dev"}
-
-    # Command line substitutions that should override
-    command_line_subs = {"var2": "override", "var3": "new_value"}
-
-    # Set up CORE for the test with a proper Path object
-    test_yaml = tmp_path / "test.yaml"
-    test_yaml.write_text("# test config")
-    CORE.config_path = test_yaml
-
-    # Call validate_config with command line substitutions
-    result = config_module.validate_config(test_config, command_line_subs)
-
-    # Verify that result[CONF_SUBSTITUTIONS] is an OrderedDict
-    assert isinstance(result.get(CONF_SUBSTITUTIONS), OrderedDict), (
-        "Result substitutions should be an OrderedDict"
-    )
-
-    # Verify substitutions were properly merged
-    assert result[CONF_SUBSTITUTIONS]["var1"] == "value1"
-    assert result[CONF_SUBSTITUTIONS]["var2"] == "override"
-    assert result[CONF_SUBSTITUTIONS]["var3"] == "new_value"
-
-
-def test_validate_config_without_command_line_substitutions_maintains_ordered_dict(
-    tmp_path,
-) -> None:
-    """Test that validate_config preserves OrderedDict without command-line substitutions.
-
-    This tests the code path in config.py where result[CONF_SUBSTITUTIONS] is set
-    using merge_dicts_ordered() when command_line_substitutions is None.
-    """
-    # Create a minimal valid config
-    test_config = OrderedDict()
-    test_config["esphome"] = {"name": "test_device", "platform": "ESP32"}
-    test_config[CONF_SUBSTITUTIONS] = OrderedDict({"var1": "value1", "var2": "value2"})
-    test_config["esp32"] = {"board": "esp32dev"}
-
-    # Set up CORE for the test with a proper Path object
-    test_yaml = tmp_path / "test.yaml"
-    test_yaml.write_text("# test config")
-    CORE.config_path = test_yaml
-
-    # Call validate_config without command line substitutions
-    result = config_module.validate_config(test_config, None)
-
-    # Verify that result[CONF_SUBSTITUTIONS] is an OrderedDict
-    assert isinstance(result.get(CONF_SUBSTITUTIONS), OrderedDict), (
-        "Result substitutions should be an OrderedDict"
-    )
-
-    # Verify substitutions are unchanged
-    assert result[CONF_SUBSTITUTIONS]["var1"] == "value1"
-    assert result[CONF_SUBSTITUTIONS]["var2"] == "value2"
-
-
-def test_merge_config_preserves_ordered_dict() -> None:
-    """Test that merge_config preserves OrderedDict type.
-
-    This is a regression test to ensure merge_config doesn't lose OrderedDict type
-    when merging configs, which causes AttributeError on move_to_end().
-    """
-    # Test OrderedDict + dict = OrderedDict
-    od = OrderedDict([("a", 1), ("b", 2)])
-    d = {"b": 20, "c": 3}
-    result = merge_config(od, d)
-    assert isinstance(result, OrderedDict), (
-        "OrderedDict + dict should return OrderedDict"
-    )
-
-    # Test dict + OrderedDict = OrderedDict
-    d = {"a": 1, "b": 2}
-    od = OrderedDict([("b", 20), ("c", 3)])
-    result = merge_config(d, od)
-    assert isinstance(result, OrderedDict), (
-        "dict + OrderedDict should return OrderedDict"
-    )
-
-    # Test OrderedDict + OrderedDict = OrderedDict
-    od1 = OrderedDict([("a", 1), ("b", 2)])
-    od2 = OrderedDict([("b", 20), ("c", 3)])
-    result = merge_config(od1, od2)
-    assert isinstance(result, OrderedDict), (
-        "OrderedDict + OrderedDict should return OrderedDict"
-    )
-
-    # Test that dict + dict still returns regular dict (no unnecessary conversion)
-    d1 = {"a": 1, "b": 2}
-    d2 = {"b": 20, "c": 3}
-    result = merge_config(d1, d2)
-    assert isinstance(result, dict), "dict + dict should return dict"
-    assert not isinstance(result, OrderedDict), (
-        "dict + dict should not return OrderedDict"
-    )

tests/unit_tests/test_writer.py

@@ -985,49 +985,3 @@ def test_clean_all_removes_non_storage_directories(
     # Verify logging mentions cleaning
     assert "Cleaning" in caplog.text
     assert str(build_dir) in caplog.text
-
-
-@patch("esphome.writer.CORE")
-def test_clean_all_preserves_json_files(
-    mock_core: MagicMock,
-    tmp_path: Path,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test clean_all preserves .json files."""
-    # Create build directory with various files
-    config_dir = tmp_path / "config"
-    config_dir.mkdir()
-
-    build_dir = config_dir / ".esphome"
-    build_dir.mkdir()
-
-    # Create .json files (should be preserved)
-    (build_dir / "config.json").write_text('{"config": "data"}')
-    (build_dir / "metadata.json").write_text('{"metadata": "info"}')
-
-    # Create non-.json files (should be removed)
-    (build_dir / "dummy.txt").write_text("x")
-    (build_dir / "other.log").write_text("log content")
-
-    # Call clean_all
-    from esphome.writer import clean_all
-
-    with caplog.at_level("INFO"):
-        clean_all([str(config_dir)])
-
-    # Verify .esphome directory still exists
-    assert build_dir.exists()
-
-    # Verify .json files are preserved
-    assert (build_dir / "config.json").exists()
-    assert (build_dir / "config.json").read_text() == '{"config": "data"}'
-    assert (build_dir / "metadata.json").exists()
-    assert (build_dir / "metadata.json").read_text() == '{"metadata": "info"}'
-
-    # Verify non-.json files were removed
-    assert not (build_dir / "dummy.txt").exists()
-    assert not (build_dir / "other.log").exists()
-
-    # Verify logging mentions cleaning
-    assert "Cleaning" in caplog.text
-    assert str(build_dir) in caplog.text