2026.6.3 (#173633)

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Martin Hjelmare <marhje52@gmail.com>
Co-authored-by: puddly <32534428+puddly@users.noreply.github.com>

.github/workflows/ci.yaml

@@ -1326,7 +1326,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
         with:
           fail_ci_if_error: true
           flags: full-suite
@@ -1485,7 +1485,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env]
@@ -1513,7 +1513,7 @@ jobs:
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
         with:
           report_type: test_results
           fail_ci_if_error: true

.github/workflows/wheels.yml

@@ -137,7 +137,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@34957438948e0b3dcde73c77750643dadae594f5 # 2026.06.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
@@ -195,7 +195,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@34957438948e0b3dcde73c77750643dadae594f5 # 2026.06.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2

CODEOWNERS

@@ -623,8 +623,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/generic_hygrostat/ @Shulyaka
 /homeassistant/components/geniushub/ @manzanotti
 /tests/components/geniushub/ @manzanotti
-/homeassistant/components/gentex_homelink/ @niaexa @ryanjones-gentex
-/tests/components/gentex_homelink/ @niaexa @ryanjones-gentex
+/homeassistant/components/gentex_homelink/ @Gentex-Corporation/Homelink @rjones-gentex
+/tests/components/gentex_homelink/ @Gentex-Corporation/Homelink @rjones-gentex
 /homeassistant/components/geo_json_events/ @exxamalte
 /tests/components/geo_json_events/ @exxamalte
 /homeassistant/components/geo_location/ @home-assistant/core

homeassistant/components/actron_air/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "silver",
-  "requirements": ["actron-neo-api==0.5.6"]
+  "requirements": ["actron-neo-api==0.5.12"]
 }

homeassistant/components/alexa_devices/button.py

@@ -6,7 +6,7 @@ from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
 
-from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
+from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator, alexa_api_call
 from .entity import AmazonServiceEntity
 
 # Coordinator is used to centralize the data updates
@@ -49,4 +49,5 @@ class AmazonRoutineButton(AmazonServiceEntity, ButtonEntity):
 
     async def async_press(self) -> None:
         """Handle button press action."""
-        await self.coordinator.api.call_routine(self._routine)
+        async with alexa_api_call(self.coordinator):
+            await self.coordinator.api.call_routine(self._routine)

homeassistant/components/alexa_devices/coordinator.py

@@ -1,5 +1,7 @@
 """Support for Alexa Devices."""
 
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
 from datetime import timedelta
 
 from aioamazondevices.api import AmazonEchoApi
@@ -19,7 +21,11 @@ from aiohttp import ClientSession
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryNotReady,
+    HomeAssistantError,
+)
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
@@ -29,6 +35,65 @@ from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
 
 SCAN_INTERVAL = 300
 
+
+@asynccontextmanager
+async def alexa_api_call(
+    coordinator: DataUpdateCoordinator | None = None,
+) -> AsyncGenerator[None]:
+    """Handle common Alexa API exceptions as HomeAssistantError."""
+    try:
+        yield
+    except CannotAuthenticate as err:
+        if coordinator:
+            coordinator.last_update_success = False
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_auth",
+            translation_placeholders={"error": repr(err)},
+        ) from err
+    except CannotConnect as err:
+        if coordinator:
+            coordinator.last_update_success = False
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect_with_error",
+            translation_placeholders={"error": repr(err)},
+        ) from err
+    except (CannotRetrieveData, ValueError) as err:
+        if coordinator:
+            coordinator.last_update_success = False
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="cannot_retrieve_data_with_error",
+            translation_placeholders={"error": repr(err)},
+        ) from err
+
+
+@asynccontextmanager
+async def alexa_config_entry_errors() -> AsyncGenerator[None]:
+    """Handle common Alexa API exceptions as ConfigEntry errors."""
+    try:
+        yield
+    except CannotAuthenticate as err:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="invalid_auth",
+            translation_placeholders={"error": repr(err)},
+        ) from err
+    except (CannotConnect, TimeoutError) as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect_with_error",
+            translation_placeholders={"error": repr(err)},
+        ) from err
+    except (CannotRetrieveData, ValueError, KeyError, StopIteration) as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="cannot_retrieve_data_with_error",
+            translation_placeholders={"error": repr(err)},
+        ) from err
+
+
 type AmazonConfigEntry = ConfigEntry[AmazonDevicesCoordinator]
 
 
@@ -113,6 +178,12 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
                 translation_key="invalid_auth",
                 translation_placeholders={"error": repr(err)},
             ) from err
+        except ValueError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_retrieve_data_with_error",
+                translation_placeholders={"error": repr(err)},
+            ) from err
         else:
             current_devices = set(data.keys())
             if stale_devices := self.previous_devices - current_devices:
@@ -169,26 +240,8 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
 
     async def sync_history_state(self) -> None:
         """Sync history state."""
-        try:
+        async with alexa_config_entry_errors():
             self._vocal_records = await self.api.sync_history_state()
-        except CannotAuthenticate as e:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="invalid_auth",
-                translation_placeholders={"error": repr(e)},
-            ) from e
-        except CannotConnect as e:
-            raise ConfigEntryNotReady(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect_with_error",
-                translation_placeholders={"error": repr(e)},
-            ) from e
-        except BaseException as e:
-            raise ConfigEntryNotReady(
-                translation_domain=DOMAIN,
-                translation_key="cannot_retrieve_data_with_error",
-                translation_placeholders={"error": repr(e)},
-            ) from e
 
     async def history_state_event_handler(
         self, vocal_records: dict[str, AmazonVocalRecord]
@@ -204,26 +257,8 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
 
     async def sync_media_state(self) -> None:
         """Sync media state."""
-        try:
+        async with alexa_config_entry_errors():
             await self.api.sync_media_state()
-        except CannotAuthenticate as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="invalid_auth",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-        except (CannotConnect, TimeoutError) as err:
-            raise ConfigEntryNotReady(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect_with_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-        except (CannotRetrieveData, ValueError) as err:
-            raise ConfigEntryNotReady(
-                translation_domain=DOMAIN,
-                translation_key="cannot_retrieve_data_with_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
 
     async def media_state_event_handler(
         self, media_state: dict[str, AmazonMediaState]

homeassistant/components/alexa_devices/diagnostics.py

@@ -12,7 +12,18 @@ from homeassistant.helpers.device_registry import DeviceEntry
 
 from .coordinator import AmazonConfigEntry
 
-TO_REDACT = {CONF_PASSWORD, CONF_USERNAME, CONF_NAME, "title"}
+TO_REDACT = {
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_USERNAME,
+    "access_token",
+    "adp_token",
+    "device_private_key",
+    "refresh_token",
+    "store_authentication_cookie",
+    "title",
+    "website_cookies",
+}
 
 
 async def async_get_config_entry_diagnostics(

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==14.0.0"]
+  "requirements": ["aioamazondevices==14.0.3"]
 }

homeassistant/components/alexa_devices/media_player.py

@@ -22,9 +22,8 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import _LOGGER
-from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
+from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator, alexa_api_call
 from .entity import AmazonEntity
-from .utils import alexa_api_call
 
 PARALLEL_UPDATES = 1
 
@@ -216,16 +215,15 @@ class AlexaDevicesMediaPlayer(AmazonEntity, MediaPlayerEntity):
         provider = media_type.value if isinstance(media_type, MediaType) else media_type
         await self.async_call_alexa_music(media_id, provider)
 
-    @alexa_api_call
     async def async_call_alexa_music(
         self, search_phrase: str, provider_id: str
     ) -> None:
         """Call alexa music."""
-        await self.coordinator.api.call_alexa_music(
-            self.device, search_phrase, provider_id
-        )
+        async with alexa_api_call(self.coordinator):
+            await self.coordinator.api.call_alexa_music(
+                self.device, search_phrase, provider_id
+            )
 
-    @alexa_api_call
     async def async_set_device_volume(self, volume: int) -> None:
         """Set the device volume."""
         _LOGGER.debug(
@@ -233,7 +231,8 @@ class AlexaDevicesMediaPlayer(AmazonEntity, MediaPlayerEntity):
             self.device.serial_number,
             volume,
         )
-        await self.coordinator.api.set_device_volume(self.device, volume)
+        async with alexa_api_call(self.coordinator):
+            await self.coordinator.api.set_device_volume(self.device, volume)
 
     async def async_set_volume_level(self, volume: float) -> None:
         """Set the volume level (0.0 to 1.0)."""
@@ -263,12 +262,12 @@ class AlexaDevicesMediaPlayer(AmazonEntity, MediaPlayerEntity):
         await self.async_set_volume_level(target_volume / 100)
         self._prev_volume = None
 
-    @alexa_api_call
     async def _send_media_command(self, command: AmazonMediaControls) -> None:
         _LOGGER.debug(
             "Sending media command '%s' to %s", command, self.device.serial_number
         )
-        await self.coordinator.api.send_media_command(self.device, command)
+        async with alexa_api_call(self.coordinator):
+            await self.coordinator.api.send_media_command(self.device, command)
 
     async def async_media_stop(self) -> None:
         """Send stop command."""

homeassistant/components/alexa_devices/notify.py

@@ -12,9 +12,8 @@ from homeassistant.components.notify import NotifyEntity, NotifyEntityDescriptio
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import AmazonConfigEntry
+from .coordinator import AmazonConfigEntry, alexa_api_call
 from .entity import AmazonEntity
-from .utils import alexa_api_call
 
 PARALLEL_UPDATES = 1
 
@@ -80,10 +79,11 @@ class AmazonNotifyEntity(AmazonEntity, NotifyEntity):
 
     entity_description: AmazonNotifyEntityDescription
 
-    @alexa_api_call
     async def async_send_message(
         self, message: str, title: str | None = None, **kwargs: Any
     ) -> None:
         """Send a message."""
-
-        await self.entity_description.method(self.coordinator.api, self.device, message)
+        async with alexa_api_call(self.coordinator):
+            await self.entity_description.method(
+                self.coordinator.api, self.device, message
+            )

homeassistant/components/alexa_devices/services.py

@@ -11,7 +11,7 @@ from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 
 from .const import DOMAIN, INFO_SKILLS_MAPPING
-from .coordinator import AmazonConfigEntry
+from .coordinator import AmazonConfigEntry, alexa_api_call
 
 ATTR_TEXT_COMMAND = "text_command"
 ATTR_SOUND = "sound"
@@ -85,13 +85,15 @@ async def _async_execute_action(call: ServiceCall, attribute: str) -> None:
                 translation_key="invalid_sound_value",
                 translation_placeholders={"sound": value},
             )
-        await coordinator.api.call_alexa_sound(
-            coordinator.data[device.serial_number], value
-        )
+        async with alexa_api_call():
+            await coordinator.api.call_alexa_sound(
+                coordinator.data[device.serial_number], value
+            )
     elif attribute == ATTR_TEXT_COMMAND:
-        await coordinator.api.call_alexa_text_command(
-            coordinator.data[device.serial_number], value
-        )
+        async with alexa_api_call():
+            await coordinator.api.call_alexa_text_command(
+                coordinator.data[device.serial_number], value
+            )
     elif attribute == ATTR_INFO_SKILL:
         info_skill = INFO_SKILLS_MAPPING.get(value)
         if info_skill not in ALEXA_INFO_SKILLS:
@@ -100,9 +102,10 @@ async def _async_execute_action(call: ServiceCall, attribute: str) -> None:
                 translation_key="invalid_info_skill_value",
                 translation_placeholders={"info_skill": value},
             )
-        await coordinator.api.call_alexa_info_skill(
-            coordinator.data[device.serial_number], info_skill
-        )
+        async with alexa_api_call():
+            await coordinator.api.call_alexa_info_skill(
+                coordinator.data[device.serial_number], info_skill
+            )
 
 
 async def async_send_sound_notification(call: ServiceCall) -> None:

homeassistant/components/alexa_devices/switch.py

@@ -14,13 +14,9 @@ from homeassistant.components.switch import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import AmazonConfigEntry
+from .coordinator import AmazonConfigEntry, alexa_api_call
 from .entity import AmazonEntity
-from .utils import (
-    alexa_api_call,
-    async_remove_dnd_from_virtual_group,
-    async_update_unique_id,
-)
+from .utils import async_remove_dnd_from_virtual_group, async_update_unique_id
 
 PARALLEL_UPDATES = 1
 
@@ -90,7 +86,6 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
 
     entity_description: AmazonSwitchEntityDescription
 
-    @alexa_api_call
     async def _switch_set_state(self, state: bool) -> None:
         """Set desired switch state."""
         method = getattr(self.coordinator.api, self.entity_description.method)
@@ -98,7 +93,8 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
         if TYPE_CHECKING:
             assert method is not None
 
-        await method(self.device, state)
+        async with alexa_api_call(self.coordinator):
+            await method(self.device, state)
         self.coordinator.data[self.device.serial_number].sensors[
             self.entity_description.key
         ].value = state

homeassistant/components/alexa_devices/utils.py

@@ -1,54 +1,19 @@
 """Utils for Alexa Devices."""
 
-from collections.abc import Awaitable, Callable, Coroutine
-from functools import wraps
-from typing import Any, Concatenate
-
 from aioamazondevices.const.devices import SPEAKER_GROUP_FAMILY
 from aioamazondevices.const.schedules import (
     NOTIFICATION_ALARM,
     NOTIFICATION_REMINDER,
     NOTIFICATION_TIMER,
 )
-from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
 
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 import homeassistant.helpers.entity_registry as er
 
 from .const import _LOGGER, DOMAIN
 from .coordinator import AmazonDevicesCoordinator
-from .entity import AmazonEntity
-
-
-def alexa_api_call[_T: AmazonEntity, **_P](
-    func: Callable[Concatenate[_T, _P], Awaitable[None]],
-) -> Callable[Concatenate[_T, _P], Coroutine[Any, Any, None]]:
-    """Catch Alexa API call exceptions."""
-
-    @wraps(func)
-    async def cmd_wrapper(self: _T, *args: _P.args, **kwargs: _P.kwargs) -> None:
-        """Wrap all command methods."""
-        try:
-            await func(self, *args, **kwargs)
-        except CannotConnect as err:
-            self.coordinator.last_update_success = False
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect_with_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-        except CannotRetrieveData as err:
-            self.coordinator.last_update_success = False
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_retrieve_data_with_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-
-    return cmd_wrapper
 
 
 async def async_update_unique_id(

homeassistant/components/assist_pipeline/pipeline.py

@@ -1816,6 +1816,11 @@ class PipelineInput:
                             await self.run.text_to_speech(tts_input)
 
         except PipelineError as err:
+            if self.run.tts_stream:
+                # Clean up TTS stream
+                self.run.tts_stream.delete()
+                self.run.tts_stream = None
+
             self.run.process_event(
                 PipelineEvent(
                     PipelineEventType.ERROR,
@@ -1885,15 +1890,17 @@ class PipelineInput:
         ):
             prepare_tasks.append(self.run.prepare_recognize_intent(self.session))
 
+        if prepare_tasks:
+            await asyncio.gather(*prepare_tasks)
+
+        # Do TTS prepare separately so we don't create a ResultStream if the
+        # pipeline is invalid.
         if (
             start_stage_index
             <= PIPELINE_STAGE_ORDER.index(PipelineStage.TTS)
             <= end_stage_index
         ):
-            prepare_tasks.append(self.run.prepare_text_to_speech())
-
-        if prepare_tasks:
-            await asyncio.gather(*prepare_tasks)
+            await self.run.prepare_text_to_speech()
 
 
 class PipelinePreferred(CollectionError):

homeassistant/components/assist_satellite/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/assist_satellite",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0"]
+  "requirements": ["hassil==3.7.0"]
 }

homeassistant/components/bluetooth/api.py

@@ -6,6 +6,7 @@ These APIs are the only documented way to interact with the bluetooth integratio
 import asyncio
 from asyncio import Future
 from collections.abc import Callable, Iterable
+from contextlib import ExitStack
 from typing import TYPE_CHECKING, cast
 
 from bleak import BleakScanner
@@ -178,15 +179,20 @@ async def async_process_advertisements(
         if not done.done() and callback(service_info):
             done.set_result(service_info)
 
-    unload = _get_manager(hass).async_register_callback(
-        _async_discovered_device, match_dict, mode, scan_duration=timeout
-    )
+    manager = _get_manager(hass)
+
+    with ExitStack() as stack:
+        unload = manager.async_register_callback(
+            _async_discovered_device, match_dict, mode
+        )
+        stack.callback(unload)
+
+        if mode == BluetoothScanningMode.ACTIVE:
+            task = hass.async_create_task(manager.async_request_active_scan(timeout))
+            stack.callback(task.cancel)
 
-    try:
         async with asyncio.timeout(timeout):
             return await done
-    finally:
-        unload()
 
 
 @hass_callback

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.23.2"]
+  "requirements": ["bthome-ble==3.23.4"]
 }

homeassistant/components/cambridge_audio/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["aiostreammagic"],
   "quality_scale": "platinum",
-  "requirements": ["aiostreammagic==2.13.1"],
+  "requirements": ["aiostreammagic==2.13.2"],
   "zeroconf": ["_stream-magic._tcp.local.", "_smoip._tcp.local."]
 }

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.6.1"]
+  "requirements": ["hassil==3.7.0", "home-assistant-intents==2026.6.1"]
 }

homeassistant/components/daikin/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pydaikin"],
-  "requirements": ["pydaikin==2.17.2"],
+  "requirements": ["pydaikin==2.18.1"],
   "zeroconf": ["_dkapi._tcp.local."]
 }

homeassistant/components/duco/strings.json

@@ -59,7 +59,7 @@
         "name": "Target flow level"
       },
       "time_state_end": {
-        "name": "Mode end time"
+        "name": "State end time"
       },
       "ventilation_state": {
         "name": "Ventilation state",

homeassistant/components/esphome/entry_data.py

@@ -166,6 +166,8 @@ class RuntimeEntryData:
     )
     loaded_platforms: set[Platform] = field(default_factory=set)
     platform_load_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    # Set once the first connection has finished scanner setup or teardown.
+    first_connect_done: asyncio.Event = field(default_factory=asyncio.Event)
     _storage_contents: StoreData | None = None
     _pending_storage: Callable[[], StoreData] | None = None
     assist_pipeline_update_callbacks: list[CALLBACK_TYPE] = field(default_factory=list)

homeassistant/components/esphome/manager.py

@@ -1,11 +1,12 @@
 """Manager for esphome devices."""
 
+import asyncio
 import base64
 from functools import partial
 import logging
 import secrets
 import struct
-from typing import TYPE_CHECKING, Any, NamedTuple
+from typing import TYPE_CHECKING, Any, Final, NamedTuple
 
 from aioesphomeapi import (
     APIClient,
@@ -106,6 +107,9 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# Max time to wait at startup for a BLE proxy to register its scanner.
+STARTUP_SCANNER_WAIT: Final = 3.0
+
 LOG_LEVEL_TO_LOGGER = {
     LogLevel.LOG_LEVEL_NONE: logging.DEBUG,
     LogLevel.LOG_LEVEL_ERROR: logging.ERROR,
@@ -677,6 +681,8 @@ class ESPHomeManager:
                 hass, device_info.bluetooth_mac_address or device_info.mac_address
             )
 
+        entry_data.first_connect_done.set()
+
         if device_info.voice_assistant_feature_flags_compat(api_version) and (
             Platform.ASSIST_SATELLITE not in entry_data.loaded_platforms
         ):
@@ -988,6 +994,21 @@ class ESPHomeManager:
 
         await reconnect_logic.start()
 
+        # Wait for a cached BLE proxy to register its scanner before finishing setup.
+        if (
+            device_info := entry_data.device_info
+        ) is not None and device_info.bluetooth_proxy_feature_flags_compat(
+            entry_data.api_version
+        ):
+            try:
+                async with asyncio.timeout(STARTUP_SCANNER_WAIT):
+                    await entry_data.first_connect_done.wait()
+            except TimeoutError:
+                _LOGGER.debug(
+                    "%s: Timed out waiting for Bluetooth scanner to register",
+                    self.host,
+                )
+
 
 @callback
 def _async_setup_device_registry(

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260527.4"]
+  "requirements": ["home-assistant-frontend==20260527.6"]
 }

homeassistant/components/gardena_bluetooth/__init__.py

@@ -1,11 +1,13 @@
 """The Gardena Bluetooth integration."""
 
+from contextlib import suppress
 import logging
 
 from bleak.backends.device import BLEDevice
 from gardena_bluetooth.client import CachedConnection, Client
-from gardena_bluetooth.const import ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
+from gardena_bluetooth.const import ScanService
+from gardena_bluetooth.parse import ManufacturerData, ProductType
+from habluetooth import BluetoothServiceInfoBleak
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
@@ -30,6 +32,64 @@ PLATFORMS: list[Platform] = [
 ]
 LOGGER = logging.getLogger(__name__)
 DISCONNECT_DELAY = 5
+PRODUCTS_SCAN_TIMEOUT = 10
+PRODUCT_TYPE_TIMEOUT = 30
+
+
+async def async_get_product_type(hass: HomeAssistant, address: str) -> ProductType:
+    """Get a product type for the given address."""
+
+    data = ManufacturerData()
+
+    def _data_callback(info: BluetoothServiceInfoBleak) -> bool:
+        LOGGER.debug("Processing advertisement from %s: %s", info.address, info)
+        if info.device.address != address:
+            return False
+
+        data.update(info.manufacturer_data.get(ManufacturerData.company, b""))
+        return data.product_type is not ProductType.UNKNOWN
+
+    with suppress(TimeoutError):
+        await bluetooth.async_process_advertisements(
+            hass,
+            _data_callback,
+            bluetooth.BluetoothCallbackMatcher(
+                address=address, manufacturer_id=ManufacturerData.company
+            ),
+            mode=bluetooth.BluetoothScanningMode.ACTIVE,
+            timeout=PRODUCT_TYPE_TIMEOUT,
+        )
+    return data.product_type
+
+
+async def async_get_products(hass: HomeAssistant) -> dict[str, ManufacturerData]:
+    """Get all products that are currently advertising."""
+    products: dict[str, ManufacturerData] = {}
+
+    def _data_callback(info: BluetoothServiceInfoBleak) -> bool:
+        LOGGER.debug("Processing advertisement from %s: %s", info.address, info)
+        if ScanService not in info.service_uuids:
+            return False
+
+        raw = info.manufacturer_data.get(ManufacturerData.company, b"")
+        if (data := products.get(info.device.address)) is None:
+            data = ManufacturerData()
+            products[info.device.address] = data
+
+        data.update(raw)
+        return False
+
+    with suppress(TimeoutError):
+        await bluetooth.async_process_advertisements(
+            hass,
+            _data_callback,
+            bluetooth.BluetoothCallbackMatcher(
+                manufacturer_id=ManufacturerData.company
+            ),
+            mode=bluetooth.BluetoothScanningMode.ACTIVE,
+            timeout=PRODUCTS_SCAN_TIMEOUT,
+        )
+    return products
 
 
 def get_connection(hass: HomeAssistant, address: str) -> CachedConnection:
@@ -53,12 +113,7 @@ async def async_setup_entry(
 
     address = entry.data[CONF_ADDRESS]
 
-    try:
-        mfg_data = await async_get_manufacturer_data({address})
-    except TimeoutError as exc:
-        raise ConfigEntryNotReady("Unable to find product type") from exc
-
-    product_type = mfg_data[address].product_type
+    product_type = await async_get_product_type(hass, address)
     if product_type is ProductType.UNKNOWN:
         raise ConfigEntryNotReady("Unable to find product type")
 

homeassistant/components/gardena_bluetooth/config_flow.py

@@ -4,21 +4,17 @@ import logging
 from typing import Any
 
 from gardena_bluetooth.client import Client
-from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation, ScanService
+from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
-from gardena_bluetooth.parse import ManufacturerData, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
+from gardena_bluetooth.parse import ProductType
 import voluptuous as vol
 
-from homeassistant.components.bluetooth import (
-    BluetoothServiceInfo,
-    async_discovered_service_info,
-)
+from homeassistant.components.bluetooth import BluetoothServiceInfo
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.data_entry_flow import AbortFlow
 
-from . import get_connection
+from . import async_get_product_type, async_get_products, get_connection
 from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
@@ -33,17 +29,6 @@ _SUPPORTED_PRODUCT_TYPES = {
 }
 
 
-def _is_supported(discovery_info: BluetoothServiceInfo):
-    """Check if device is supported."""
-    if ScanService not in discovery_info.service_uuids:
-        return False
-
-    if discovery_info.manufacturer_data.get(ManufacturerData.company) is None:
-        _LOGGER.debug("Missing manufacturer data: %s", discovery_info)
-        return False
-    return True
-
-
 class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Gardena Bluetooth."""
 
@@ -75,8 +60,7 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the bluetooth discovery step."""
         _LOGGER.debug("Discovered device: %s", discovery_info)
-        data = await async_get_manufacturer_data({discovery_info.address})
-        product_type = data[discovery_info.address].product_type
+        product_type = await async_get_product_type(self.hass, discovery_info.address)
         if product_type not in _SUPPORTED_PRODUCT_TYPES:
             return self.async_abort(reason="no_devices_found")
 
@@ -117,22 +101,16 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             self._abort_if_unique_id_configured()
             return await self.async_step_confirm()
 
-        current_addresses = self._async_current_ids(include_ignore=False)
-        candidates = set()
-        for discovery_info in async_discovered_service_info(self.hass):
-            address = discovery_info.address
-            if address in current_addresses or not _is_supported(discovery_info):
-                continue
-            candidates.add(address)
-
-        data = await async_get_manufacturer_data(candidates)
-        for address, mfg_data in data.items():
-            if mfg_data.product_type not in _SUPPORTED_PRODUCT_TYPES:
-                continue
-            self.devices[address] = PRODUCT_NAMES[mfg_data.product_type]
+        current = self._async_current_ids(include_ignore=False)
+        devices = await async_get_products(self.hass)
 
         # Keep selection sorted by address to ensure stable tests
-        self.devices = dict(sorted(self.devices.items(), key=lambda x: x[0]))
+        self.devices = {
+            address: PRODUCT_NAMES[data.product_type]
+            for address in sorted(devices)
+            if address not in current
+            and (data := devices[address]).product_type in _SUPPORTED_PRODUCT_TYPES
+        }
 
         if not self.devices:
             return self.async_abort(reason="no_devices_found")

homeassistant/components/gentex_homelink/manifest.json

@@ -1,11 +1,12 @@
 {
   "domain": "gentex_homelink",
   "name": "HomeLink",
-  "codeowners": ["@niaexa", "@ryanjones-gentex"],
+  "codeowners": ["@Gentex-Corporation/Homelink", "@rjones-gentex"],
   "config_flow": true,
   "dependencies": ["application_credentials"],
   "documentation": "https://www.home-assistant.io/integrations/gentex_homelink",
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "quality_scale": "bronze",
-  "requirements": ["homelink-integration-api==0.0.1"]
+  "requirements": ["homelink-integration-api==0.0.5"]
 }

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.97", "babel==2.15.0"]
+  "requirements": ["holidays==0.98", "babel==2.15.0"]
 }

homeassistant/components/homeassistant_connect_zbt2/__init__.py

@@ -135,7 +135,24 @@ async def async_migrate_entry(
             )
 
             if canonical.entry_id != config_entry.entry_id:
-                # The canonical entry's migration will remove this duplicate.
+                if canonical.minor_version < 2:
+                    # The canonical entry has not been migrated yet and its
+                    # migration will remove this duplicate.
+                    return False
+
+                # The canonical entry is already fully migrated and will not run
+                # a migration that removes this duplicate, so remove it here. The
+                # entry can't remove itself while its setup lock is held, so
+                # schedule the removal instead.
+                _LOGGER.debug(
+                    "Removing duplicate config entry %s for serial %s in favor of %s",
+                    config_entry.entry_id,
+                    serial_number,
+                    canonical.entry_id,
+                )
+                hass.async_create_task(
+                    hass.config_entries.async_remove(config_entry.entry_id)
+                )
                 return False
 
             for duplicate in duplicates:

homeassistant/components/homeassistant_sky_connect/__init__.py

@@ -239,7 +239,24 @@ async def async_migrate_entry(
             )
 
             if canonical.entry_id != config_entry.entry_id:
-                # The canonical entry's migration will remove this duplicate.
+                if canonical.minor_version < 5:
+                    # The canonical entry has not been migrated yet and its
+                    # migration will remove this duplicate.
+                    return False
+
+                # The canonical entry is already fully migrated and will not run
+                # a migration that removes this duplicate, so remove it here. The
+                # entry can't remove itself while its setup lock is held, so
+                # schedule the removal instead.
+                _LOGGER.warning(
+                    "Removing duplicate config entry %s for serial %s in favor of %s",
+                    config_entry.entry_id,
+                    serial_number,
+                    canonical.entry_id,
+                )
+                hass.async_create_task(
+                    hass.config_entries.async_remove(config_entry.entry_id)
+                )
                 return False
 
             for duplicate in duplicates:

homeassistant/components/html5/notify.py

@@ -9,10 +9,12 @@ import time
 from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import urlparse
 import uuid
+import warnings
 
 from aiohttp import ClientError, ClientResponse, ClientSession, web
 from aiohttp.hdrs import AUTHORIZATION
 import jwt
+from jwt.warnings import InsecureKeyLengthWarning
 from py_vapid import Vapid
 from pywebpush import WebPusher, WebPushException, webpush_async
 import voluptuous as vol
@@ -325,7 +327,8 @@ class HTML5PushCallbackView(HomeAssistantView):
         if target_check.get(ATTR_TARGET) in self.registrations:
             possible_target = self.registrations[target_check[ATTR_TARGET]]
             key = possible_target["subscription"]["keys"]["auth"]
-            with suppress(jwt.exceptions.DecodeError):
+            with suppress(jwt.exceptions.DecodeError), warnings.catch_warnings():
+                warnings.simplefilter("ignore", InsecureKeyLengthWarning)
                 return jwt.decode(token, key, algorithms=["ES256", "HS256"])
 
         return self.json_message(
@@ -585,7 +588,9 @@ def add_jwt(timestamp: int, target: str, tag: str, jwt_secret: str) -> str:
         ATTR_TARGET: target,
         ATTR_TAG: tag,
     }
-    return jwt.encode(jwt_claims, jwt_secret)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", InsecureKeyLengthWarning)
+        return jwt.encode(jwt_claims, jwt_secret)
 
 
 async def async_setup_entry(

homeassistant/components/hue/v2/group.py

@@ -85,6 +85,7 @@ class GroupedHueLight(HueBaseEntity, LightEntity):
 
     entity_description = LightEntityDescription(
         key="hue_grouped_light",
+        translation_key="hue_grouped_light",
         has_entity_name=True,
         name=None,
     )

homeassistant/components/hue/v2/sensor.py

@@ -166,8 +166,10 @@ class HueLightLevelSensor(HueSensorBase):
     )
 
     @property
-    def native_value(self) -> int:
+    def native_value(self) -> int | None:
         """Return the value reported by the sensor."""
+        if self.resource.light.value is None:
+            return None
         # Light level in 10000 log10 (lux) +1 measured by sensor. Logarithm
         # scale used because the human eye adjusts to light levels and small
         # changes at low lux levels are more noticeable than at high lux

homeassistant/components/husqvarna_automower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_push",
   "loggers": ["aioautomower"],
   "quality_scale": "silver",
-  "requirements": ["aioautomower==2.7.5"]
+  "requirements": ["aioautomower==2.7.6"]
 }

homeassistant/components/icloud/__init__.py

@@ -59,7 +59,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: IcloudConfigEntry) -> bo
     await hass.async_add_executor_job(account.setup)
 
     entry.runtime_data = account
-    entry.async_on_unload(account.cancel_fetch)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -68,4 +67,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: IcloudConfigEntry) -> bo
 
 async def async_unload_entry(hass: HomeAssistant, entry: IcloudConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        await hass.async_add_executor_job(entry.runtime_data.cancel_fetch)
+    return unload_ok

homeassistant/components/idasen_desk/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "bronze",
-  "requirements": ["idasen-ha==2.6.5"]
+  "requirements": ["idasen-ha==2.7.0"]
 }

homeassistant/components/image_upload/__init__.py

@@ -248,7 +248,10 @@ def _generate_thumbnail_if_file_does_not_exist(
     if not target_file.is_file():
         image = ImageOps.exif_transpose(Image.open(original_path))
         image.thumbnail(target_size)
-        image.save(target_path, format=content_type.partition("/")[-1])
+        save_format = content_type.partition("/")[-1]
+        if save_format == "jpeg" and image.mode not in ("RGB", "L", "CMYK"):
+            image = image.convert("RGB")
+        image.save(target_path, format=save_format)
 
 
 def _validate_size_from_filename(filename: str) -> tuple[int, int]:

homeassistant/components/imgw_pib/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["imgw_pib==2.2.0"]
+  "requirements": ["imgw_pib==2.2.2"]
 }

homeassistant/components/lg_netcast/media_player.py

@@ -1,5 +1,6 @@
 """Support for LG TV running on NetCast 3 or 4."""
 
+from collections import Counter
 from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
@@ -133,13 +134,22 @@ class LgTVDevice(MediaPlayerEntity):
 
                 channel_list = client.query_data("channel_list")
                 if channel_list:
-                    channel_names = []
+                    channel_pairs = []
                     for channel in channel_list:
                         channel_name = channel.find("chname")
                         if channel_name is not None:
-                            channel_names.append(str(channel_name.text))
-                    self._sources = dict(zip(channel_names, channel_list, strict=False))
-                    # sort source names by the major channel number
+                            channel_pairs.append((str(channel_name.text), channel))
+
+                    name_count = Counter(name for name, _ in channel_pairs)
+
+                    self._sources = {}
+                    for name, channel in channel_pairs:
+                        if name_count[name] > 1:
+                            major = channel.find("major")
+                            if major is not None:
+                                name = f"{name} ({major.text})"
+                        self._sources[name] = channel
+
                     source_tuples = [
                         (k, source.find("major").text)
                         for k, source in self._sources.items()

homeassistant/components/linkplay/entity.py

@@ -51,7 +51,7 @@ class LinkPlayBaseEntity(Entity):
             )
 
         self._attr_device_info = dr.DeviceInfo(
-            configuration_url=bridge.endpoint,
+            configuration_url=str(bridge.endpoint),
             connections=connections,
             hw_version=bridge.device.properties["hardware"],
             identifiers={(DOMAIN, bridge.device.uuid)},

homeassistant/components/lyric/sensor.py

@@ -142,11 +142,13 @@ def get_setpoint_status(status: str, time: str) -> str | None:
     return LYRIC_SETPOINT_STATUS_NAMES.get(status)
 
 
-def get_datetime_from_future_time(time_str: str) -> datetime:
+def get_datetime_from_future_time(time_str: str | None) -> datetime | None:
     """Get datetime from future time provided."""
+    if time_str is None:
+        return None
     time = dt_util.parse_time(time_str)
     if time is None:
-        raise ValueError(f"Unable to parse time {time_str}")
+        return None
     now = dt_util.utcnow()
     if time <= now.time():
         now = now + timedelta(days=1)

homeassistant/components/mitsubishi_comfort/__init__.py

@@ -14,9 +14,16 @@ from mitsubishi_comfort.exceptions import AuthenticationError, DeviceConnectionE
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEFAULT_CONNECT_TIMEOUT, DEFAULT_RESPONSE_TIMEOUT, DOMAIN, PLATFORMS
+from .const import (
+    CONF_ADDRESSES,
+    DEFAULT_CONNECT_TIMEOUT,
+    DEFAULT_RESPONSE_TIMEOUT,
+    DOMAIN,
+    PLATFORMS,
+)
 from .coordinator import MitsubishiComfortConfigEntry, MitsubishiComfortCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -25,13 +32,14 @@ _LOGGER = logging.getLogger(__name__)
 def _make_device(
     info: DeviceInfo,
     serial: str,
+    address: str,
     session,
 ) -> IndoorUnit | KumoStation:
     """Create the appropriate device instance from DeviceInfo."""
     cls = IndoorUnit if info.is_indoor_unit else KumoStation
     return cls(
         name=info.label,
-        address=info.address,
+        address=address,
         password_b64=info.password,
         crypto_serial_hex=info.crypto_serial,
         serial=serial,
@@ -64,12 +72,39 @@ async def async_setup_entry(
             translation_key="no_devices",
         )
 
+    # The cloud provides each device's MAC but never its LAN IP. Register every
+    # device with its MAC so the manifest's "registered_devices" DHCP matcher
+    # tracks it; DHCP discovery then supplies the IP via async_step_dhcp.
+    device_registry = dr.async_get(hass)
+    owned_macs = {dr.format_mac(info.mac) for info in devices.values()}
+    for serial, info in devices.items():
+        device_registry.async_get_or_create(
+            config_entry_id=entry.entry_id,
+            identifiers={(DOMAIN, serial)},
+            connections={(dr.CONNECTION_NETWORK_MAC, dr.format_mac(info.mac))},
+            manufacturer="Mitsubishi",
+            name=info.label,
+            serial_number=serial,
+        )
+
+    # Resolved IPs are stored keyed by MAC. Drop any for devices that are no
+    # longer on the account.
+    stored: dict[str, str] = entry.data.get(CONF_ADDRESSES, {})
+    addresses = {mac: ip for mac, ip in stored.items() if mac in owned_macs}
+    if addresses != stored:
+        hass.config_entries.async_update_entry(
+            entry, data={**entry.data, CONF_ADDRESSES: addresses}
+        )
+
     coordinators: dict[str, MitsubishiComfortCoordinator] = {}
     for serial, info in devices.items():
-        if not info.address or not info.password or not info.crypto_serial:
-            _LOGGER.warning("Device %s missing credentials, skipping", info.label)
+        address = addresses.get(dr.format_mac(info.mac))
+        if not address or not info.password or not info.crypto_serial:
+            # No LAN address yet: the device is registered, so DHCP discovery
+            # supplies its IP and reloads the entry to add it.
+            _LOGGER.debug("Device %s has no known LAN address yet", info.label)
             continue
-        device = _make_device(info, serial, session)
+        device = _make_device(info, serial, address, session)
         coordinators[serial] = MitsubishiComfortCoordinator(
             hass, entry, device, info.mac
         )

homeassistant/components/mitsubishi_comfort/config_flow.py

@@ -9,9 +9,11 @@ import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
-from .const import DOMAIN
+from .const import CONF_ADDRESSES, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -71,3 +73,41 @@ class MitsubishiComfortConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="user", data_schema=USER_SCHEMA, errors=errors
         )
+
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle a registered device discovered on the local network via DHCP.
+
+        The cloud API never returns a device's LAN IP, so DHCP discovery is the
+        source of addresses. Each device is registered with its MAC during setup,
+        so "registered_devices" discovery only fires for our own devices: record
+        the IP on the owning entry and reload to set the device up or recover a
+        changed IP.
+        """
+        mac = dr.format_mac(discovery_info.macaddress)
+        device = dr.async_get(self.hass).async_get_device(
+            connections={(dr.CONNECTION_NETWORK_MAC, mac)}
+        )
+        entry = next(
+            (
+                entry
+                for entry in self._async_current_entries(include_ignore=False)
+                if device is not None and entry.entry_id in device.config_entries
+            ),
+            None,
+        )
+        if entry is None:
+            return self.async_abort(reason="already_configured")
+
+        addresses = entry.data.get(CONF_ADDRESSES, {})
+        if addresses.get(mac) != discovery_info.ip:
+            self.hass.config_entries.async_update_entry(
+                entry,
+                data={
+                    **entry.data,
+                    CONF_ADDRESSES: {**addresses, mac: discovery_info.ip},
+                },
+            )
+            self.hass.config_entries.async_schedule_reload(entry.entry_id)
+        return self.async_abort(reason="already_configured")

homeassistant/components/mitsubishi_comfort/const.py

@@ -7,6 +7,13 @@ from homeassistant.const import Platform
 
 DOMAIN: Final = "mitsubishi_comfort"
 PLATFORMS: Final = [Platform.CLIMATE]
+
+# Config entry data key holding the per-device LAN address cache, keyed by the
+# device's formatted MAC. The cloud API only returns each device's MAC, never
+# its LAN IP, so addresses are resolved from DHCP discovery and persisted here
+# to survive restarts without re-discovery.
+CONF_ADDRESSES: Final = "addresses"
+
 DEFAULT_SCAN_INTERVAL = timedelta(seconds=60)
 DEFAULT_CONNECT_TIMEOUT: Final = 1.2
 DEFAULT_RESPONSE_TIMEOUT: Final = 8.0

homeassistant/components/mitsubishi_comfort/coordinator.py

@@ -42,12 +42,23 @@ class MitsubishiComfortCoordinator(DataUpdateCoordinator[IndoorUnit | KumoStatio
         try:
             success = await self.device.update_status()
         except Exception as err:
+            # The user-facing UpdateFailed message is translated and omits the IP;
+            # log it here so the failing address is visible in debug logs.
+            _LOGGER.debug(
+                "Error polling %s at %s: %s",
+                self.device.name,
+                self.device.address,
+                err,
+            )
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="communication_error",
                 translation_placeholders={"device_name": self.device.name},
             ) from err
         if not success:
+            _LOGGER.debug(
+                "%s at %s returned no data", self.device.name, self.device.address
+            )
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="update_failed",

homeassistant/components/mitsubishi_comfort/manifest.json

@@ -3,9 +3,10 @@
   "name": "Mitsubishi Comfort",
   "codeowners": ["@nikolairahimi"],
   "config_flow": true,
+  "dhcp": [{ "registered_devices": true }],
   "documentation": "https://www.home-assistant.io/integrations/mitsubishi_comfort",
   "integration_type": "hub",
-  "iot_class": "cloud_polling",
+  "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["mitsubishi-comfort==0.3.0"]
+  "requirements": ["mitsubishi-comfort==0.3.1"]
 }

homeassistant/components/mitsubishi_comfort/quality_scale.yaml

@@ -56,7 +56,7 @@ rules:
   icon-translations: todo
   reconfiguration-flow: todo
   dynamic-devices: todo
-  discovery-update-info: todo
+  discovery-update-info: done
   repair-issues: todo
   docs-use-cases: done
   docs-supported-devices: done

homeassistant/components/mqtt/__init__.py

@@ -412,6 +412,12 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async def _reload_config(call: ServiceCall) -> None:
         """Reload the platforms."""
+        if not mqtt_config_entry_enabled(hass):
+            _LOGGER.debug(
+                "Skipped reloading MQTT integration, "
+                "the MQTT config entry is not enabled"
+            )
+            return
         entry: ConfigEntry = next(iter(hass.config_entries.async_entries(DOMAIN)))
         mqtt_data = hass.data[DATA_MQTT]
 
@@ -504,6 +510,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # Can be removed with HA Core 2027.1
         new_entry_data = entry.data.copy()
         new_entry_data[CONF_PROTOCOL] = PROTOCOL_5
+        # Create temporary certificate files from entry
+        await async_create_certificate_temp_files(hass, new_entry_data)
         # Try the connection with protocol version 5
         # And update the protocol if successful
         if await hass.async_add_executor_job(

homeassistant/components/mqtt/config_flow.py

@@ -2451,7 +2451,7 @@ PLATFORM_MQTT_FIELDS: dict[Platform, dict[str, PlatformField]] = {
             validator=valid_subscribe_topic,
             error="invalid_subscribe_topic",
         ),
-        CONF_VALUE_TEMPLATE: PlatformField(
+        CONF_STATE_VALUE_TEMPLATE: PlatformField(
             selector=TEMPLATE_SELECTOR,
             required=False,
             validator=validate(cv.template),
@@ -3395,7 +3395,7 @@ PLATFORM_MQTT_FIELDS: dict[Platform, dict[str, PlatformField]] = {
             validator=valid_subscribe_topic,
             error="invalid_subscribe_topic",
         ),
-        CONF_VALUE_TEMPLATE: PlatformField(
+        CONF_STATE_VALUE_TEMPLATE: PlatformField(
             selector=TEMPLATE_SELECTOR,
             required=False,
             validator=validate(cv.template),

homeassistant/components/mqtt/entity.py

@@ -1432,9 +1432,10 @@ class MqttEntity(
         if (
             self._config[CONF_ENABLED_BY_DEFAULT]
             and deleted_entry
-            and deleted_entry.disabled_by is not None
+            and deleted_entry.disabled_by is er.RegistryEntryDisabler.INTEGRATION
         ):
-            # Enable previous deleted entity and enable it
+            # Enable previous deleted entity and enable it,
+            # if it was not disabled by the user
             recreated_entry = entity_registry.async_get_or_create(
                 entity_platform, DOMAIN, self.unique_id
             )

homeassistant/components/opengarage/entity.py

@@ -52,5 +52,5 @@ class OpenGarageEntity(CoordinatorEntity[OpenGarageDataUpdateCoordinator]):
             manufacturer="Open Garage",
             name=self.coordinator.data["name"],
             suggested_area="Garage",
-            sw_version=self.coordinator.data["fwv"],
+            sw_version=str(self.coordinator.data["fwv"]),
         )

homeassistant/components/opentherm_gw/__init__.py

@@ -159,11 +159,14 @@ class OpenThermGatewayHub:
             _LOGGER.debug("Received report: %s", status)
             async_dispatcher_send(self.hass, self.update_signal, status)
 
+            boiler_manufacturer = status[OpenThermDataSource.BOILER].get(
+                gw_vars.DATA_SLAVE_MEMBERID
+            )
             dev_reg.async_update_device(
                 boiler_device.id,
-                manufacturer=status[OpenThermDataSource.BOILER].get(
-                    gw_vars.DATA_SLAVE_MEMBERID
-                ),
+                manufacturer=str(boiler_manufacturer)
+                if boiler_manufacturer is not None
+                else None,
                 model_id=status[OpenThermDataSource.BOILER].get(
                     gw_vars.DATA_SLAVE_PRODUCT_TYPE
                 ),
@@ -175,11 +178,14 @@ class OpenThermGatewayHub:
                 ),
             )
 
+            thermostat_manufacturer = status[OpenThermDataSource.THERMOSTAT].get(
+                gw_vars.DATA_MASTER_MEMBERID
+            )
             dev_reg.async_update_device(
                 thermostat_device.id,
-                manufacturer=status[OpenThermDataSource.THERMOSTAT].get(
-                    gw_vars.DATA_MASTER_MEMBERID
-                ),
+                manufacturer=str(thermostat_manufacturer)
+                if thermostat_manufacturer is not None
+                else None,
                 model_id=status[OpenThermDataSource.THERMOSTAT].get(
                     gw_vars.DATA_MASTER_PRODUCT_TYPE
                 ),

homeassistant/components/opower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
   "quality_scale": "platinum",
-  "requirements": ["opower==0.18.2"]
+  "requirements": ["opower==0.18.4"]
 }

homeassistant/components/person/__init__.py

@@ -565,7 +565,7 @@ class Person(
         self._latitude = coordinates.attributes.get(ATTR_LATITUDE)
         self._longitude = coordinates.attributes.get(ATTR_LONGITUDE)
         self._gps_accuracy = coordinates.attributes.get(ATTR_GPS_ACCURACY)
-        self._in_zones = coordinates.attributes.get(ATTR_IN_ZONES, [])
+        self._in_zones = state.attributes.get(ATTR_IN_ZONES, [])
 
     @callback
     def _update_extra_state_attributes(self) -> None:

homeassistant/components/philips_js/config_flow.py

@@ -45,8 +45,8 @@ USER_SCHEMA = vol.Schema(
         ): str,
         vol.Required(
             CONF_API_VERSION,
-            default=1,
-        ): vol.In([1, 5, 6]),
+            default="1",
+        ): vol.In(["1", "5", "6"]),
     }
 )
 
@@ -223,7 +223,7 @@ class PhilipsJSConfigFlow(ConfigFlow, domain=DOMAIN):
             self._current = user_input
             try:
                 await self._async_attempt_prepare(
-                    user_input[CONF_HOST], user_input[CONF_API_VERSION], False
+                    user_input[CONF_HOST], int(user_input[CONF_API_VERSION]), False
                 )
             except GeneralFailure as exc:
                 LOGGER.error(exc)

homeassistant/components/plugwise/climate.py

@@ -155,9 +155,9 @@ class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
         )
 
     @property
-    def current_temperature(self) -> float:
+    def current_temperature(self) -> float | None:
         """Return the current temperature."""
-        return self.device["sensors"]["temperature"]
+        return self.device["sensors"].get("temperature")
 
     @property
     def target_temperature(self) -> float:

homeassistant/components/plugwise/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
   "quality_scale": "platinum",
-  "requirements": ["plugwise==1.11.3"],
+  "requirements": ["plugwise==1.11.4"],
   "zeroconf": ["_plugwise._tcp.local."]
 }

homeassistant/components/portainer/__init__.py

@@ -63,7 +63,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: PortainerConfigEntry) ->
         api_url=entry.data[CONF_URL],
         api_key=entry.data[CONF_API_TOKEN],
         session=session,
-        request_timeout=60,
+        request_timeout=120,
         max_retries=API_MAX_RETRIES,
     )
 

homeassistant/components/rainmachine/entity.py

@@ -54,7 +54,7 @@ class RainMachineEntity(CoordinatorEntity[RainMachineDataUpdateCoordinator]):
             connections={(dr.CONNECTION_NETWORK_MAC, self._data.controller.mac)},
             name=self._data.controller.name.capitalize(),
             manufacturer="RainMachine",
-            hw_version=self._version_coordinator.data["hwVer"],
+            hw_version=str(self._version_coordinator.data["hwVer"]),
             sw_version=f"{self._version_coordinator.data['swVer']} "
             f"(API: {self._version_coordinator.data['apiVer']})",
         )

homeassistant/components/renault/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["renault_api"],
   "quality_scale": "silver",
-  "requirements": ["renault-api==0.5.11"]
+  "requirements": ["renault-api==0.5.12"]
 }

homeassistant/components/reolink/diagnostics.py

@@ -41,6 +41,7 @@ async def async_get_config_entry_diagnostics(
         "HTTP(S) port": api.port,
         "Baichuan port": api.baichuan.port,
         "Baichuan only": api.baichuan_only,
+        "Baichuan connection": api.baichuan.connection_type.value,
         "WiFi connection": api.wifi_connection(),
         "WiFi signal": api.wifi_signal(),
         "RTMP enabled": api.rtmp_enabled,
@@ -48,10 +49,15 @@ async def async_get_config_entry_diagnostics(
         "ONVIF enabled": api.onvif_enabled,
         "event connection": host.event_connection,
         "stream protocol": api.protocol,
+        "is NVR": api.is_nvr,
+        "is Hub": api.is_hub,
+        "is Battery": api.is_battery,
         "channels": api.channels,
         "stream channels": api.stream_channels,
         "IPC cams": ipc_cam,
         "Chimes": chimes,
+        "Broken cmds": api.broken_cmds,
+        "Baichuan fallbacks": api.baichuan_cmds,
         "capabilities": api.capabilities,
         "cmd list": host.update_cmd,
         "firmware ch list": host.firmware_ch_list,

homeassistant/components/reolink/host.py

@@ -369,7 +369,11 @@ class ReolinkHost:
                 )
 
         # start long polling if ONVIF push failed immediately
-        if not self._onvif_push_supported and not self._api.baichuan.privacy_mode():
+        if (
+            self._onvif_long_poll_supported
+            and not self._onvif_push_supported
+            and not self._api.baichuan.privacy_mode()
+        ):
             _LOGGER.debug(
                 "Camera model %s does not support ONVIF push,"
                 " using ONVIF long polling instead",
@@ -378,14 +382,8 @@ class ReolinkHost:
             try:
                 await self._async_start_long_polling(initial=True)
             except NotSupportedError:
-                _LOGGER.debug(
-                    "Camera model %s does not support ONVIF long"
-                    " polling, using fast polling instead",
-                    self._api.model,
-                )
                 self._onvif_long_poll_supported = False
                 await self._api.unsubscribe()
-                await self._async_poll_all_motion()
             else:
                 self._cancel_long_poll_check = async_call_later(
                     self._hass,
@@ -393,6 +391,13 @@ class ReolinkHost:
                     self._async_check_onvif_long_poll,
                 )
 
+        if not self._onvif_long_poll_supported:
+            _LOGGER.debug(
+                "Camera model %s does not support ONVIF push and long polling, using fast polling instead",
+                self._api.model,
+            )
+            await self._async_poll_all_motion()
+
         self._cancel_tcp_push_check = None
 
     async def _async_check_onvif(self, *_: Any) -> None:
@@ -822,7 +827,7 @@ class ReolinkHost:
             return
 
         try:
-            if self._api.session_active:
+            if self._api.session_active and not self._api.baichuan.privacy_mode():
                 await self._api.get_motion_state_all_ch()
         except ReolinkError as err:
             if not self._fast_poll_error:
@@ -834,7 +839,7 @@ class ReolinkHost:
                 )
             self._fast_poll_error = True
         else:
-            if self._api.session_active:
+            if self._api.session_active and not self._api.baichuan.privacy_mode():
                 self._fast_poll_error = False
         finally:
             # schedule next poll

homeassistant/components/reolink/manifest.json

@@ -20,5 +20,5 @@
   "iot_class": "local_push",
   "loggers": ["reolink_aio"],
   "quality_scale": "platinum",
-  "requirements": ["reolink-aio==0.20.1"]
+  "requirements": ["reolink-aio==0.21.0"]
 }

homeassistant/components/rituals_perfume_genie/entity.py

@@ -1,5 +1,7 @@
 """Base class for Rituals Perfume Genie diffuser entity."""
 
+from typing import Any
+
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -12,6 +14,12 @@ MODEL = "The Perfume Genie"
 MODEL2 = "The Perfume Genie 2.0"
 
 
+def _version_string(version: Any) -> str:
+    if isinstance(version, dict):
+        return str(version.get("title", version))
+    return str(version)
+
+
 class DiffuserEntity(CoordinatorEntity[RitualsDataUpdateCoordinator]):
     """Representation of a diffuser entity."""
 
@@ -31,7 +39,7 @@ class DiffuserEntity(CoordinatorEntity[RitualsDataUpdateCoordinator]):
             manufacturer=MANUFACTURER,
             model=MODEL if coordinator.diffuser.has_battery else MODEL2,
             name=coordinator.diffuser.name,
-            sw_version=coordinator.diffuser.version,
+            sw_version=_version_string(coordinator.diffuser.version),
         )
 
     @property

homeassistant/components/shelly/__init__.py

@@ -1,5 +1,6 @@
 """The Shelly integration."""
 
+import asyncio
 from functools import partial
 from typing import Final
 
@@ -73,6 +74,7 @@ from .utils import (
     get_http_port,
     get_rpc_scripts_event_types,
     get_ws_context,
+    is_rpc_ble_scanner_supported,
     remove_empty_sub_devices,
     remove_stale_blu_trv_devices,
 )
@@ -114,6 +116,9 @@ COAP_SCHEMA: Final = vol.Schema(
 )
 CONFIG_SCHEMA: Final = vol.Schema({DOMAIN: COAP_SCHEMA}, extra=vol.ALLOW_EXTRA)
 
+# Max time to wait at startup for a BLE proxy to register its scanner.
+STARTUP_SCANNER_WAIT: Final = 3.0
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Shelly component."""
@@ -365,6 +370,21 @@ async def _async_setup_rpc_entry(hass: HomeAssistant, entry: ShellyConfigEntry)
 
         runtime_data.rpc = ShellyRpcCoordinator(hass, entry, device)
         runtime_data.rpc.async_setup()
+
+        if (
+            is_rpc_ble_scanner_supported(entry)
+            and entry.options.get(CONF_BLE_SCANNER_MODE, BLEScannerMode.DISABLED)
+            != BLEScannerMode.DISABLED
+        ):
+            # Wait for the proxy to register its scanner before finishing setup.
+            try:
+                async with asyncio.timeout(STARTUP_SCANNER_WAIT):
+                    await runtime_data.rpc.ble_scanner_setup_done.wait()
+            except TimeoutError:
+                LOGGER.debug(
+                    "%s: Timed out waiting for BLE scanner to register", entry.title
+                )
+
         runtime_data.rpc_poll = ShellyRpcPollingCoordinator(hass, entry, device)
         await hass.config_entries.async_forward_entry_setups(
             entry, runtime_data.platforms

homeassistant/components/shelly/coordinator.py

@@ -521,6 +521,8 @@ class ShellyRpcCoordinator(ShellyCoordinatorBase[RpcDevice]):
         super().__init__(hass, entry, device, update_interval)
 
         self.connected = False
+        # Set once BLE scanner setup has been attempted after connecting.
+        self.ble_scanner_setup_done = asyncio.Event()
         self._disconnected_callbacks: list[CALLBACK_TYPE] = []
         self._connection_lock = asyncio.Lock()
         self._event_listeners: list[Callable[[dict[str, Any]], None]] = []
@@ -759,27 +761,30 @@ class ShellyRpcCoordinator(ShellyCoordinatorBase[RpcDevice]):
 
     async def _async_connect_ble_scanner(self) -> None:
         """Connect BLE scanner."""
-        ble_scanner_mode = self.config_entry.options.get(
-            CONF_BLE_SCANNER_MODE, BLEScannerMode.DISABLED
-        )
-        if ble_scanner_mode == BLEScannerMode.DISABLED and self.connected:
-            await async_stop_scanner(self.device)
-            async_remove_scanner(self.hass, self.bluetooth_source)
-            return
-        if await async_ensure_ble_enabled(self.device):
-            # BLE enable required a reboot, don't bother connecting
-            # the scanner since it will be disconnected anyway
-            LOGGER.debug(
-                "Device %s BLE enable required a reboot, skipping scanner connect",
-                self.name,
+        try:
+            ble_scanner_mode = self.config_entry.options.get(
+                CONF_BLE_SCANNER_MODE, BLEScannerMode.DISABLED
             )
-            return
-        assert self.device_id is not None
-        self._disconnected_callbacks.append(
-            await async_connect_scanner(
-                self.hass, self, ble_scanner_mode, self.device_id
+            if ble_scanner_mode == BLEScannerMode.DISABLED and self.connected:
+                await async_stop_scanner(self.device)
+                async_remove_scanner(self.hass, self.bluetooth_source)
+                return
+            if await async_ensure_ble_enabled(self.device):
+                # BLE enable required a reboot, don't bother connecting
+                # the scanner since it will be disconnected anyway
+                LOGGER.debug(
+                    "Device %s BLE enable required a reboot, skipping scanner connect",
+                    self.name,
+                )
+                return
+            assert self.device_id is not None
+            self._disconnected_callbacks.append(
+                await async_connect_scanner(
+                    self.hass, self, ble_scanner_mode, self.device_id
+                )
             )
-        )
+        finally:
+            self.ble_scanner_setup_done.set()
 
     @callback
     def _async_handle_rpc_device_online(self) -> None:

homeassistant/components/shelly/utils.py

@@ -663,9 +663,9 @@ def is_view_for_platform(config: dict[str, Any], key: str, platform: str) -> boo
 def get_virtual_component_unit(config: dict[str, Any]) -> str | None:
     """Return the unit of a virtual component.
 
-    If the unit is not set, the device sends an empty string
+    If the unit is not set, the device sends an empty string or the key may be absent.
     """
-    unit = config["meta"]["ui"]["unit"]
+    unit = config["meta"]["ui"].get("unit")
     return DEVICE_UNIT_MAP.get(unit, unit) if unit else None
 
 

homeassistant/components/sleepiq/__init__.py

@@ -16,7 +16,7 @@ from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, PRESSURE, Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN, IS_IN_BED, SLEEP_NUMBER
@@ -69,7 +69,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: SleepIQConfigEntry) -> b
     email = conf[CONF_USERNAME]
     password = conf[CONF_PASSWORD]
 
-    client_session = async_get_clientsession(hass)
+    client_session = async_create_clientsession(hass)
 
     gateway = AsyncSleepIQ(client_session=client_session)
 

homeassistant/components/sleepiq/coordinator.py

@@ -47,11 +47,16 @@ class SleepIQDataUpdateCoordinator(DataUpdateCoordinator[None]):
             bed.foundation.update_foundation_status()
             for bed in self.client.beds.values()
         ]
-        await asyncio.gather(*tasks)
+        try:
+            await asyncio.gather(*tasks)
+        except SleepIQTimeoutException as err:
+            raise UpdateFailed(f"Timed out fetching SleepIQ data: {err}") from err
+        except SleepIQAPIException as err:
+            raise UpdateFailed(f"Failed to fetch SleepIQ data: {err}") from err
 
 
 class SleepIQPauseUpdateCoordinator(DataUpdateCoordinator[None]):
-    """SleepIQ data update coordinator."""
+    """SleepIQ pause update coordinator."""
 
     config_entry: SleepIQConfigEntry
 
@@ -72,9 +77,14 @@ class SleepIQPauseUpdateCoordinator(DataUpdateCoordinator[None]):
         self.client = client
 
     async def _async_update_data(self) -> None:
-        await asyncio.gather(
-            *[bed.fetch_pause_mode() for bed in self.client.beds.values()]
-        )
+        try:
+            await asyncio.gather(
+                *[bed.fetch_pause_mode() for bed in self.client.beds.values()]
+            )
+        except SleepIQTimeoutException as err:
+            raise UpdateFailed(f"Timed out fetching SleepIQ pause data: {err}") from err
+        except SleepIQAPIException as err:
+            raise UpdateFailed(f"Failed to fetch SleepIQ pause data: {err}") from err
 
 
 class SleepIQSleepDataCoordinator(DataUpdateCoordinator[None]):

homeassistant/components/smartthings/manifest.json

@@ -38,5 +38,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmartthings"],
   "quality_scale": "bronze",
-  "requirements": ["pysmartthings==4.0.0"]
+  "requirements": ["pysmartthings==4.0.1"]
 }

homeassistant/components/squeezebox/media_player.py

@@ -74,7 +74,7 @@ ATTR_QUERY_RESULT = "query_result"
 
 _LOGGER = logging.getLogger(__name__)
 
-PARALLEL_UPDATES = 1
+PARALLEL_UPDATES = 0
 
 ATTR_OTHER_PLAYER = "other_player"
 

homeassistant/components/squeezebox/switch.py

@@ -22,7 +22,7 @@ from .entity import SqueezeboxEntity
 
 _LOGGER = logging.getLogger(__name__)
 
-PARALLEL_UPDATES = 1
+PARALLEL_UPDATES = 0
 
 
 async def async_setup_entry(

homeassistant/components/switchbot_cloud/__init__.py

@@ -504,9 +504,15 @@ def _create_handle_webhook(
         _LOGGER.debug("Received data from switchbot webhook: %s", repr(data))
         device_mac = data["context"]["deviceMac"]
 
-        if device_mac not in coordinators_by_id:
-            _LOGGER.error(
-                "Received data for unknown entity from switchbot webhook: %s", data
+        registered_device_macs = [
+            coordinator.data.get("deviceMac") or coordinator.data.get("deviceId")
+            for coordinator in coordinators_by_id.values()
+            if coordinator.manageable_by_webhook() and coordinator.data is not None
+        ]
+        if device_mac not in registered_device_macs:
+            _LOGGER.debug(
+                "Received data for an unregistered webhook entity from SwitchBot Webhook: %s",
+                data,
             )
             return
 

homeassistant/components/thread/dataset_store.py

@@ -250,13 +250,9 @@ class DatasetStore:
         entry: DatasetEntry | None
         for entry in self.datasets.values():
             if entry.dataset == dataset:
-                if (
-                    preferred_extended_address
-                    and entry.preferred_extended_address is None
-                ):
-                    self.async_set_preferred_border_agent(
-                        entry.id, preferred_border_agent_id, preferred_extended_address
-                    )
+                self._async_maybe_update_preferred_border_agent(
+                    entry, preferred_border_agent_id, preferred_extended_address
+                )
                 return
 
         # Update if dataset with same extended pan id exists and the timestamp
@@ -307,10 +303,9 @@ class DatasetStore:
                 self.datasets[entry.id], tlv=tlv
             )
             self.async_schedule_save()
-            if preferred_extended_address and entry.preferred_extended_address is None:
-                self.async_set_preferred_border_agent(
-                    entry.id, preferred_border_agent_id, preferred_extended_address
-                )
+            self._async_maybe_update_preferred_border_agent(
+                entry, preferred_border_agent_id, preferred_extended_address
+            )
             return
 
         entry = DatasetEntry(
@@ -348,6 +343,37 @@ class DatasetStore:
         """Get dataset by id."""
         return self.datasets.get(dataset_id)
 
+    @callback
+    def _async_maybe_update_preferred_border_agent(
+        self,
+        entry: DatasetEntry,
+        preferred_border_agent_id: str | None,
+        preferred_extended_address: str | None,
+    ) -> None:
+        """Update the preferred border agent of an existing dataset if appropriate.
+
+        Sets the preferred border agent if it was not set yet, or refreshes the
+        stored extended address when the border agent ID still matches but the
+        extended address changed. The latter happens e.g. after an OTBR upgrade
+        regenerates the extended address while keeping the same border agent ID.
+        """
+        if not preferred_extended_address:
+            return
+        if entry.preferred_extended_address is None or (
+            preferred_border_agent_id is not None
+            and preferred_border_agent_id == entry.preferred_border_agent_id
+            and preferred_extended_address != entry.preferred_extended_address
+        ):
+            _LOGGER.info(
+                "Updating extended address of preferred border agent %s from %s to %s",
+                preferred_border_agent_id,
+                entry.preferred_extended_address,
+                preferred_extended_address,
+            )
+            self.async_set_preferred_border_agent(
+                entry.id, preferred_border_agent_id, preferred_extended_address
+            )
+
     @callback
     def async_set_preferred_border_agent(
         self, dataset_id: str, border_agent_id: str | None, extended_address: str

homeassistant/components/tts/__init__.py

@@ -613,6 +613,10 @@ class ResultStream:
         async for chunk in converted_audio:
             yield chunk
 
+    def delete(self) -> None:
+        """Remove the result stream from the manager."""
+        self._manager.async_delete_result_stream(self.token)
+
 
 def _hash_options(options: dict) -> str:
     """Hashes an options dictionary."""
@@ -809,6 +813,11 @@ class SpeechManager:
             stream.last_used = monotonic()
         return stream
 
+    @callback
+    def async_delete_result_stream(self, token: str) -> None:
+        """Delete a result stream given a token."""
+        self.token_to_stream.pop(token, None)
+
     @callback
     def async_create_result_stream(
         self,

homeassistant/components/unifiprotect/entity.py

@@ -440,7 +440,7 @@ class ProtectSettableKeysMixin(ProtectEntityDescription[T]):
 
     async def ufp_set(self, obj: T, value: Any) -> None:
         """Set value for UniFi Protect device."""
-        _LOGGER.debug("Setting %s to %s for %s", self.name, value, obj.display_name)
+        _LOGGER.debug("Setting %s to %s for %s", self.key, value, obj.display_name)
         if self.ufp_set_method is not None:
             await getattr(obj, self.ufp_set_method)(value)
         elif self.ufp_set_method_fn is not None:

homeassistant/components/uptimerobot/const.py

@@ -8,8 +8,10 @@ from homeassistant.const import Platform
 
 LOGGER: Logger = getLogger(__package__)
 
-# The free plan is limited to 10 requests/minute
-COORDINATOR_UPDATE_INTERVAL: timedelta = timedelta(seconds=10)
+# The free plan is formally limited to 10 requests/minute
+# But real world says 5 requests/minute is the real limit
+# Opened a ticket with support with no response for 2 months
+COORDINATOR_UPDATE_INTERVAL: timedelta = timedelta(seconds=15)
 
 DOMAIN: Final = "uptimerobot"
 PLATFORMS: Final = [Platform.BINARY_SENSOR, Platform.SENSOR, Platform.SWITCH]

homeassistant/components/v2c/diagnostics.py

@@ -1,6 +1,6 @@
 """Diagnostics support for V2C."""
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.const import CONF_HOST
@@ -21,11 +21,11 @@ async def async_get_config_entry_diagnostics(
         assert coordinator.evse
 
     coordinator_data = coordinator.evse.data
-    evse_raw_data = coordinator.evse.raw_data
+    evse_raw_data = cast(dict[str, Any], coordinator.evse.raw_data)
 
     return {
         "config_entry": async_redact_data(entry.as_dict(), TO_REDACT),
         "data": str(coordinator_data),
-        "raw_data": evse_raw_data["content"].decode("utf-8"),  # type: ignore[attr-defined]
+        "raw_data": evse_raw_data["content"].decode("utf-8"),
         "host_status": evse_raw_data["status_code"],
     }

homeassistant/components/v2c/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/v2c",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["pytrydan==1.0.0"]
+  "requirements": ["pytrydan==1.0.2"]
 }

homeassistant/components/workday/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["holidays"],
   "quality_scale": "internal",
-  "requirements": ["holidays==0.97"]
+  "requirements": ["holidays==0.98"]
 }

homeassistant/components/wyoming/assist_satellite.py

@@ -348,6 +348,8 @@ class WyomingAssistSatellite(WyomingSatelliteEntity, AssistSatelliteEntity):
             # Use ffmpeg to convert to raw PCM audio with the appropriate format
             proc = await asyncio.create_subprocess_exec(
                 self._ffmpeg_manager.binary,
+                "-protocol_whitelist",
+                "http,https,file,tcp,tls",
                 "-i",
                 announcement.media_id,
                 "-f",

homeassistant/components/yale_smart_alarm/__init__.py

@@ -31,7 +31,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: YaleConfigEntry) -> boo
 
 async def async_migrate_entry(hass: HomeAssistant, entry: YaleConfigEntry) -> bool:
     """Migrate old entry."""
-    LOGGER.debug("Migrating from version %s", entry.version)
+    LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
 
     if entry.version == 1:
         new_options = entry.options.copy()
@@ -55,6 +55,19 @@ async def async_migrate_entry(hass: HomeAssistant, entry: YaleConfigEntry) -> bo
         del new_data[CONF_NAME]
         hass.config_entries.async_update_entry(entry, data=new_data, minor_version=2)
 
-    LOGGER.debug("Migration to version %s successful", entry.version)
+    if entry.version == 2 and entry.minor_version == 2:
+        entity_reg = er.async_get(hass)
+        entries = er.async_entries_for_config_entry(entity_reg, entry.entry_id)
+        for entity in entries:
+            if entity.unique_id == "yale_smart_alarm-panic":
+                entity_reg.async_update_entity(
+                    entity.entity_id,
+                    new_unique_id=f"{entry.entry_id}-panic",
+                )
+        hass.config_entries.async_update_entry(entry, minor_version=3)
+
+    LOGGER.debug(
+        "Migration to version %s.%s successful", entry.version, entry.minor_version
+    )
 
     return True

homeassistant/components/yale_smart_alarm/button.py

@@ -47,7 +47,7 @@ class YalePanicButton(YaleAlarmEntity, ButtonEntity):
         """Initialize the plug switch."""
         super().__init__(coordinator)
         self.entity_description = description
-        self._attr_unique_id = f"yale_smart_alarm-{description.key}"
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}-{description.key}"
 
     async def async_press(self) -> None:
         """Press the button."""

homeassistant/components/yale_smart_alarm/config_flow.py

@@ -64,7 +64,7 @@ class YaleConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Yale integration."""
 
     VERSION = 2
-    MINOR_VERSION = 2
+    MINOR_VERSION = 3
 
     @staticmethod
     @callback

homeassistant/components/yardian/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/yardian",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["pyyardian==1.3.3"]
+  "requirements": ["pyyardian==1.4.0"]
 }

homeassistant/components/yoto/manifest.json

@@ -10,5 +10,5 @@
   "iot_class": "cloud_push",
   "loggers": ["yoto_api"],
   "quality_scale": "bronze",
-  "requirements": ["yoto-api==3.1.5"]
+  "requirements": ["yoto-api==3.1.6"]
 }

homeassistant/components/zinvolt/binary_sensor.py

@@ -30,7 +30,7 @@ POINT_ENTITIES = {
 class ZinvoltBatteryStateDescription(BinarySensorEntityDescription):
     """Binary sensor description for Zinvolt battery state."""
 
-    is_on_fn: Callable[[ZinvoltData], bool]
+    is_on_fn: Callable[[ZinvoltData], bool | None]
 
 
 SENSORS: tuple[ZinvoltBatteryStateDescription, ...] = (
@@ -84,7 +84,7 @@ class ZinvoltBatteryStateBinarySensor(ZinvoltEntity, BinarySensorEntity):
         )
 
     @property
-    def is_on(self) -> bool:
+    def is_on(self) -> bool | None:
         """Return the state of the binary sensor."""
         return self.entity_description.is_on_fn(self.coordinator.data)
 

homeassistant/components/zinvolt/entity.py

@@ -1,6 +1,6 @@
 """Base entity for Zinvolt integration."""
 
-from zinvolt.models import Unit
+from zinvolt.models import OnlineStatus, Unit
 
 from homeassistant.const import ATTR_VIA_DEVICE
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -25,6 +25,15 @@ class ZinvoltEntity(CoordinatorEntity[ZinvoltDeviceCoordinator]):
             serial_number=coordinator.data.battery.serial_number,
         )
 
+    @property
+    def available(self) -> bool:
+        """Return if the entity is available."""
+        return (
+            super().available
+            and self.coordinator.data.battery.current_power.online_status
+            is OnlineStatus.ONLINE
+        )
+
 
 class ZinvoltUnitEntity(ZinvoltEntity):
     """Base entity for Zinvolt units."""

homeassistant/components/zinvolt/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["zinvolt"],
   "quality_scale": "bronze",
-  "requirements": ["zinvolt==0.4.3"]
+  "requirements": ["zinvolt==1.0.0"]
 }

homeassistant/components/zinvolt/number.py

@@ -34,7 +34,11 @@ NUMBERS: tuple[ZinvoltBatteryStateDescription, ...] = (
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
-        value_fn=lambda state: state.battery.global_settings.max_output,
+        value_fn=lambda state: (
+            2000
+            if state.battery.global_settings.max_output_unlocked
+            else state.battery.global_settings.max_output
+        ),
         set_value_fn=lambda client, battery_id, value: client.set_max_output(
             battery_id, value
         ),

homeassistant/components/zinvolt/sensor.py

@@ -21,7 +21,7 @@ from .entity import ZinvoltEntity
 class ZinvoltBatteryStateDescription(SensorEntityDescription):
     """Sensor description for Zinvolt battery state."""
 
-    value_fn: Callable[[ZinvoltData], float]
+    value_fn: Callable[[ZinvoltData], float | None]
 
 
 SENSORS: tuple[ZinvoltBatteryStateDescription, ...] = (
@@ -37,7 +37,13 @@ SENSORS: tuple[ZinvoltBatteryStateDescription, ...] = (
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=UnitOfPower.WATT,
-        value_fn=lambda state: 0 - state.battery.current_power.power_socket_output,
+        value_fn=(
+            lambda state: (
+                None
+                if state.battery.current_power.power_socket_output is None
+                else 0 - state.battery.current_power.power_socket_output
+            )
+        ),
     ),
 )
 
@@ -74,6 +80,6 @@ class ZinvoltBatteryStateSensor(ZinvoltEntity, SensorEntity):
         )
 
     @property
-    def native_value(self) -> float:
+    def native_value(self) -> float | None:
         """Return the state of the sensor."""
         return self.entity_description.value_fn(self.coordinator.data)

homeassistant/const.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 APPLICATION_NAME: Final = "HomeAssistant"
 MAJOR_VERSION: Final = 2026
 MINOR_VERSION: Final = 6
-PATCH_VERSION: Final = "0"
+PATCH_VERSION: Final = "3"
 __short_version__: Final = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__: Final = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER: Final[tuple[int, int, int]] = (3, 14, 2)

homeassistant/generated/dhcp.py

@@ -443,6 +443,10 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "hostname": "lyric-*",
         "macaddress": "00D02D*",
     },
+    {
+        "domain": "mitsubishi_comfort",
+        "registered_devices": True,
+    },
     {
         "domain": "motion_blinds",
         "registered_devices": True,

homeassistant/generated/integrations.json

@@ -4351,7 +4351,7 @@
         "mitsubishi_comfort": {
           "integration_type": "hub",
           "config_flow": true,
-          "iot_class": "cloud_polling",
+          "iot_class": "local_polling",
           "name": "Mitsubishi Comfort"
         }
       }

homeassistant/helpers/llm.py

@@ -699,7 +699,7 @@ def _get_exposed_entities(
             ):
                 # Entity is in area
                 area_names.append(area_entry.name)
-                area_names.extend(area_entry.aliases)
+                area_names.extend(sorted(area_entry.aliases))
             elif device_entry is not None:
                 # Check device area
                 if (
@@ -710,7 +710,7 @@ def _get_exposed_entities(
                     is not None
                 ):
                     area_names.append(area_entry.name)
-                    area_names.extend(area_entry.aliases)
+                    area_names.extend(sorted(area_entry.aliases))
 
         info: dict[str, Any] = {
             "names": ", ".join(names),
@@ -957,9 +957,9 @@ def _get_cached_action_parameters(
                 aliases = er.async_get_entity_aliases(hass, entity_entry)
                 if aliases:
                     if description:
-                        description = description + ". Aliases: " + str(list(aliases))
+                        description = description + ". Aliases: " + str(sorted(aliases))
                     else:
-                        description = "Aliases: " + str(list(aliases))
+                        description = "Aliases: " + str(sorted(aliases))
 
         parameters_cache.setdefault(domain, {})[action] = (description, parameters)
 

homeassistant/helpers/template/extensions/config_entries.py

@@ -1,6 +1,7 @@
 """Config entry functions for Home Assistant templates."""
 
 from collections.abc import Iterable
+from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from homeassistant.exceptions import TemplateError
@@ -104,4 +105,6 @@ class ConfigEntryExtension(BaseTemplateExtension):
         if config_entry is None:
             return None
 
-        return getattr(config_entry, attr_name)
+        if isinstance(result := getattr(config_entry, attr_name), Enum):
+            return result.value
+        return result

homeassistant/package_constraints.txt

@@ -37,9 +37,9 @@ go2rtc-client==0.4.0
 ha-ffmpeg==3.2.2
 habluetooth==6.8.1
 hass-nabucasa==2.2.0
-hassil==3.5.0
+hassil==3.7.0
 home-assistant-bluetooth==2.0.0
-home-assistant-frontend==20260527.4
+home-assistant-frontend==20260527.6
 home-assistant-intents==2026.6.1
 httpx==0.28.1
 ifaddr==0.2.0

pylint/plugins/pylint_home_assistant/generated/mdi_icons.py

@@ -5,7 +5,7 @@ To update, run python3 -m script.hassfest
 
 from typing import Final
 
-FRONTEND_VERSION: Final[str] = "20260527.4"
+FRONTEND_VERSION: Final[str] = "20260527.6"
 
 MDI_ICONS: Final[set[str]] = {
     "ab-testing",

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "homeassistant"
-version = "2026.6.0"
+version = "2026.6.3"
 license = "Apache-2.0"
 license-files = ["LICENSE*", "homeassistant/backports/LICENSE*"]
 description = "Open-source home automation platform running on Python 3."

requirements.txt

@@ -25,7 +25,7 @@ cryptography==48.0.0
 fnv-hash-fast==2.0.3
 ha-ffmpeg==3.2.2
 hass-nabucasa==2.2.0
-hassil==3.5.0
+hassil==3.7.0
 home-assistant-bluetooth==2.0.0
 home-assistant-intents==2026.6.1
 httpx==0.28.1