Add reconfiguration flow to Twente Milieu

2026-04-16 06:36:14 +02:00 · 2026-04-12 10:23:32 +00:00
398 changed files with 4435 additions and 13552 deletions
--- a/.claude/agents/raise-pull-request.md
+++ b/.claude/agents/raise-pull-request.md
@@ -186,11 +186,15 @@ If `CHANGE_TYPE` IS "Breaking change" or "Deprecation", keep the `## Breaking ch

 ## Step 10: Push Branch and Create PR

-Push the branch with upstream tracking, and create a PR against `home-assistant/core` with the generated title and body:
-
 ```bash
+# Get branch name and GitHub username
+BRANCH=$(git branch --show-current)
+PUSH_REMOTE=$(git config "branch.$BRANCH.remote" 2>/dev/null || git remote | head -1)
+GITHUB_USER=$(gh api user --jq .login 2>/dev/null || git remote get-url "$PUSH_REMOTE" | sed -E 's#.*[:/]([^/]+)/([^/]+)(\.git)?$#\1#')
+
 # Create PR (gh pr create pushes the branch automatically)
 gh pr create --repo home-assistant/core --base dev \
+  --head "$GITHUB_USER:$BRANCH" \
  --draft \
  --title "TITLE_HERE" \
  --body "$(cat <<'EOF'
--- a/.github/renovate.json
+++ b/.github/renovate.json
@@ -1,205 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:recommended"],
-
-  "enabledManagers": [
-    "pep621",
-    "pip_requirements",
-    "pre-commit",
-    "homeassistant-manifest"
-  ],
-
-  "pre-commit": {
-    "enabled": true
-  },
-
-  "pip_requirements": {
-    "managerFilePatterns": [
-      "/(^|/)requirements[\\w_-]*\\.txt$/",
-      "/(^|/)homeassistant/package_constraints\\.txt$/"
-    ]
-  },
-
-  "homeassistant-manifest": {
-    "managerFilePatterns": [
-      "/^homeassistant/components/[^/]+/manifest\\.json$/"
-    ]
-  },
-
-  "minimumReleaseAge": "7 days",
-  "prConcurrentLimit": 10,
-  "prHourlyLimit": 2,
-  "schedule": ["before 6am"],
-
-  "semanticCommits": "disabled",
-  "commitMessageAction": "Update",
-  "commitMessageTopic": "{{depName}}",
-  "commitMessageExtra": "to {{newVersion}}",
-
-  "automerge": false,
-
-  "vulnerabilityAlerts": {
-    "enabled": false
-  },
-
-  "packageRules": [
-    {
-      "description": "Deny all by default — allowlist below re-enables specific packages",
-      "matchPackageNames": ["*"],
-      "enabled": false
-    },
-    {
-      "description": "Core runtime dependencies (allowlisted)",
-      "matchPackageNames": [
-        "aiohttp",
-        "aiohttp-fast-zlib",
-        "aiohttp_cors",
-        "aiohttp-asyncmdnsresolver",
-        "yarl",
-        "httpx",
-        "requests",
-        "urllib3",
-        "certifi",
-        "orjson",
-        "PyYAML",
-        "Jinja2",
-        "cryptography",
-        "pyOpenSSL",
-        "PyJWT",
-        "SQLAlchemy",
-        "Pillow",
-        "attrs",
-        "uv",
-        "voluptuous",
-        "voluptuous-serialize",
-        "voluptuous-openapi",
-        "zeroconf"
-      ],
-      "enabled": true,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Common Python utilities (allowlisted)",
-      "matchPackageNames": [
-        "astral",
-        "atomicwrites-homeassistant",
-        "audioop-lts",
-        "awesomeversion",
-        "bcrypt",
-        "ciso8601",
-        "cronsim",
-        "defusedxml",
-        "fnv-hash-fast",
-        "getmac",
-        "ical",
-        "ifaddr",
-        "lru-dict",
-        "mutagen",
-        "propcache",
-        "pyserial",
-        "python-slugify",
-        "PyTurboJPEG",
-        "securetar",
-        "standard-aifc",
-        "standard-telnetlib",
-        "ulid-transform",
-        "url-normalize",
-        "xmltodict"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Home Assistant ecosystem packages (core-maintained, no cooldown)",
-      "matchPackageNames": [
-        "hassil",
-        "home-assistant-bluetooth",
-        "home-assistant-frontend",
-        "home-assistant-intents",
-        "infrared-protocols"
-      ],
-      "enabled": true,
-      "minimumReleaseAge": null,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Test dependencies (allowlisted)",
-      "matchPackageNames": [
-        "pytest",
-        "pytest-asyncio",
-        "pytest-aiohttp",
-        "pytest-cov",
-        "pytest-freezer",
-        "pytest-github-actions-annotate-failures",
-        "pytest-socket",
-        "pytest-sugar",
-        "pytest-timeout",
-        "pytest-unordered",
-        "pytest-picked",
-        "pytest-xdist",
-        "pylint",
-        "pylint-per-file-ignores",
-        "astroid",
-        "coverage",
-        "freezegun",
-        "syrupy",
-        "respx",
-        "requests-mock",
-        "ruff",
-        "codespell",
-        "yamllint",
-        "zizmor"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "For types-* stubs, only allow patch updates. Major/minor bumps track the upstream runtime package version and must be manually coordinated with the corresponding pin.",
-      "matchPackageNames": ["/^types-/"],
-      "matchUpdateTypes": ["patch"],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Pre-commit hook repos (allowlisted, matched by owner/repo)",
-      "matchPackageNames": [
-        "astral-sh/ruff-pre-commit",
-        "codespell-project/codespell",
-        "adrienverge/yamllint",
-        "zizmorcore/zizmor-pre-commit"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Group ruff pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["astral-sh/ruff-pre-commit", "ruff"],
-      "groupName": "ruff",
-      "groupSlug": "ruff"
-    },
-    {
-      "description": "Group codespell pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["codespell-project/codespell", "codespell"],
-      "groupName": "codespell",
-      "groupSlug": "codespell"
-    },
-    {
-      "description": "Group yamllint pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["adrienverge/yamllint", "yamllint"],
-      "groupName": "yamllint",
-      "groupSlug": "yamllint"
-    },
-    {
-      "description": "Group zizmor pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["zizmorcore/zizmor-pre-commit", "zizmor"],
-      "groupName": "zizmor",
-      "groupSlug": "zizmor"
-    },
-    {
-      "description": "Group pylint with astroid (their versions are linked and must move together)",
-      "matchPackageNames": ["pylint", "astroid"],
-      "groupName": "pylint",
-      "groupSlug": "pylint"
-    }
-  ]
-}
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -50,11 +50,9 @@ env:
  # - 10.10.3 is the latest (as of 6 Feb 2023)
  # 10.11 is the latest long-term-support
  # - 10.11.2 is the version currently shipped with Synology (as of 11 Oct 2023)
-  # 11.4 is an LTS with support until May 2029
-  # - 11.4.9 is used in Alpine 3.23 (used in latest HA base images as of 11 Apr 2026)
  # mysql 8.0.32 does not always behave the same as MariaDB
  # and some queries that work on MariaDB do not work on MySQL
-  MARIADB_VERSIONS: "['mariadb:10.3.32','mariadb:10.6.10','mariadb:10.10.3','mariadb:10.11.2','mariadb:11.4.9','mysql:8.0.32']"
+  MARIADB_VERSIONS: "['mariadb:10.3.32','mariadb:10.6.10','mariadb:10.10.3','mariadb:10.11.2','mysql:8.0.32']"
  # 12 is the oldest supported version
  # - 12.14 is the latest (as of 9 Feb 2023)
  # 15 is the latest version
@@ -1064,9 +1062,7 @@ jobs:
          - 3306:3306
        env:
          MYSQL_ROOT_PASSWORD: password
-        options: >-
-          --health-cmd="if command -v mariadb-admin >/dev/null; then mariadb-admin ping -uroot -ppassword; else mysqladmin ping -uroot -ppassword; fi"
-          --health-interval=5s --health-timeout=2s --health-retries=3
+        options: --health-cmd="mysqladmin ping -uroot -ppassword" --health-interval=5s --health-timeout=2s --health-retries=3
    needs:
      - info
      - base
--- a/.gitignore
+++ b/.gitignore
@@ -142,6 +142,5 @@ pytest_buckets.txt

 # AI tooling
 .claude/settings.local.json
-.claude/worktrees/
 .serena/

--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -8,7 +8,7 @@ repos:
      - id: ruff-format
        files: ^((homeassistant|pylint|script|tests)/.+)?[^/]+\.(py|pyi)$
  - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
    hooks:
      - id: codespell
        args:
@@ -36,7 +36,7 @@ repos:
          - --branch=master
          - --branch=rc
  - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.38.0
+    rev: v1.37.1
    hooks:
      - id: yamllint
  - repo: https://github.com/rbubley/mirrors-prettier
--- a/26
+++ b/26
@@ -489,8 +489,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
 /homeassistant/components/ephember/ @ttroy50 @roberty99
-/homeassistant/components/epic_games_store/ @Quentame
-/tests/components/epic_games_store/ @Quentame
+/homeassistant/components/epic_games_store/ @hacf-fr @Quentame
+/tests/components/epic_games_store/ @hacf-fr @Quentame
 /homeassistant/components/epion/ @lhgravendeel
 /tests/components/epion/ @lhgravendeel
 /homeassistant/components/epson/ @pszafer
@@ -566,8 +566,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/fortios/ @kimfrellsen
 /homeassistant/components/foscam/ @Foscam-wangzhengyu
 /tests/components/foscam/ @Foscam-wangzhengyu
-/homeassistant/components/freebox/ @hacf-fr/reviewers @Quentame
-/tests/components/freebox/ @hacf-fr/reviewers @Quentame
+/homeassistant/components/freebox/ @hacf-fr @Quentame
+/tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
 /homeassistant/components/freshr/ @SierraNL
@@ -1057,8 +1057,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/met/ @danielhiversen
 /homeassistant/components/met_eireann/ @DylanGore
 /tests/components/met_eireann/ @DylanGore
-/homeassistant/components/meteo_france/ @hacf-fr/reviewers @oncleben31 @Quentame
-/tests/components/meteo_france/ @hacf-fr/reviewers @oncleben31 @Quentame
+/homeassistant/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
+/tests/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
 /homeassistant/components/meteo_lt/ @xE1H
 /tests/components/meteo_lt/ @xE1H
 /homeassistant/components/meteoalarm/ @rolfberkenbosch
@@ -1150,8 +1150,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/netatmo/ @cgtobi
 /tests/components/netatmo/ @cgtobi
 /homeassistant/components/netdata/ @fabaff
-/homeassistant/components/netgear/ @Quentame @starkillerOG
-/tests/components/netgear/ @Quentame @starkillerOG
+/homeassistant/components/netgear/ @hacf-fr @Quentame @starkillerOG
+/tests/components/netgear/ @hacf-fr @Quentame @starkillerOG
 /homeassistant/components/netgear_lte/ @tkdrob
 /tests/components/netgear_lte/ @tkdrob
 /homeassistant/components/network/ @home-assistant/core
@@ -1694,8 +1694,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/syncthing/ @zhulik
 /homeassistant/components/syncthru/ @nielstron
 /tests/components/syncthru/ @nielstron
-/homeassistant/components/synology_dsm/ @Quentame @mib1185
-/tests/components/synology_dsm/ @Quentame @mib1185
+/homeassistant/components/synology_dsm/ @hacf-fr @Quentame @mib1185
+/tests/components/synology_dsm/ @hacf-fr @Quentame @mib1185
 /homeassistant/components/synology_srm/ @aerialls
 /homeassistant/components/system_bridge/ @timmo001
 /tests/components/system_bridge/ @timmo001
@@ -1828,8 +1828,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/unifi_access/ @imhotep @RaHehl
 /tests/components/unifi_access/ @imhotep @RaHehl
 /homeassistant/components/unifi_direct/ @tofuSCHNITZEL
-/homeassistant/components/unifi_discovery/ @RaHehl
-/tests/components/unifi_discovery/ @RaHehl
 /homeassistant/components/unifiled/ @florisvdk
 /homeassistant/components/unifiprotect/ @RaHehl
 /tests/components/unifiprotect/ @RaHehl
@@ -1877,8 +1875,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/version/ @ludeeus
 /homeassistant/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
-/homeassistant/components/vicare/ @CFenner @lackas
-/tests/components/vicare/ @CFenner @lackas
+/homeassistant/components/vicare/ @CFenner
+/tests/components/vicare/ @CFenner
 /homeassistant/components/victron_ble/ @rajlaud
 /tests/components/victron_ble/ @rajlaud
 /homeassistant/components/victron_gx/ @tomer-w
--- a/16
+++ b/16
@@ -19,23 +19,25 @@ ENV \
    UV_SYSTEM_PYTHON=true \
    UV_NO_CACHE=true

-WORKDIR /usr/src
-
 # Home Assistant S6-Overlay
 COPY rootfs /

 # Add go2rtc binary
 COPY --from=ghcr.io/alexxit/go2rtc@sha256:675c318b23c06fd862a61d262240c9a63436b4050d177ffc68a32710d9e05bae /usr/local/bin/go2rtc /bin/go2rtc

+RUN \
+    # Verify go2rtc can be executed
+    go2rtc --version \
+    # Install uv
+    && pip3 install uv==0.11.1
+
+WORKDIR /usr/src
+
 ## Setup Home Assistant Core dependencies
 COPY requirements.txt homeassistant/
 COPY homeassistant/package_constraints.txt homeassistant/homeassistant/
 RUN \
-    # Verify go2rtc can be executed
-    go2rtc --version \
-    # Install uv at the version pinned in the requirements file
-    && pip3 install --no-cache-dir "uv==$(awk -F'==' '/^uv==/{print $2}' homeassistant/requirements.txt)" \
-    && uv pip install \
+    uv pip install \
        --no-build \
        -r homeassistant/requirements.txt

--- a/homeassistant/brands/ubiquiti.json
+++ b/homeassistant/brands/ubiquiti.json
@@ -6,7 +6,6 @@
    "unifi",
    "unifi_access",
    "unifi_direct",
-    "unifi_discovery",
    "unifiled",
    "unifiprotect"
  ]
--- a/homeassistant/components/acer_projector/const.py
+++ b/homeassistant/components/acer_projector/const.py
@@ -6,11 +6,10 @@ from typing import Final

 from homeassistant.const import STATE_OFF, STATE_ON

-CONF_READ_TIMEOUT: Final = "timeout"
 CONF_WRITE_TIMEOUT: Final = "write_timeout"

 DEFAULT_NAME: Final = "Acer Projector"
-DEFAULT_READ_TIMEOUT: Final = 1
+DEFAULT_TIMEOUT: Final = 1
 DEFAULT_WRITE_TIMEOUT: Final = 1

 ECO_MODE: Final = "ECO Mode"
--- a/homeassistant/components/acer_projector/manifest.json
+++ b/homeassistant/components/acer_projector/manifest.json
@@ -5,5 +5,5 @@
  "documentation": "https://www.home-assistant.io/integrations/acer_projector",
  "iot_class": "local_polling",
  "quality_scale": "legacy",
-  "requirements": ["serialx==1.2.2"]
+  "requirements": ["pyserial==3.5"]
 }
--- a/homeassistant/components/acer_projector/switch.py
+++ b/homeassistant/components/acer_projector/switch.py
@@ -6,7 +6,7 @@ import logging
 import re
 from typing import Any

-from serialx import Serial, SerialException
+import serial
 import voluptuous as vol

 from homeassistant.components.switch import (
@@ -16,22 +16,21 @@ from homeassistant.components.switch import (
 from homeassistant.const import (
    CONF_FILENAME,
    CONF_NAME,
+    CONF_TIMEOUT,
    STATE_OFF,
    STATE_ON,
    STATE_UNKNOWN,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType

 from .const import (
    CMD_DICT,
-    CONF_READ_TIMEOUT,
    CONF_WRITE_TIMEOUT,
    DEFAULT_NAME,
-    DEFAULT_READ_TIMEOUT,
+    DEFAULT_TIMEOUT,
    DEFAULT_WRITE_TIMEOUT,
    ECO_MODE,
    ICON,
@@ -46,7 +45,7 @@ PLATFORM_SCHEMA = SWITCH_PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_FILENAME): cv.isdevice,
        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-        vol.Optional(CONF_READ_TIMEOUT, default=DEFAULT_READ_TIMEOUT): cv.positive_int,
+        vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
        vol.Optional(
            CONF_WRITE_TIMEOUT, default=DEFAULT_WRITE_TIMEOUT
        ): cv.positive_int,
@@ -63,10 +62,10 @@ def setup_platform(
    """Connect with serial port and return Acer Projector."""
    serial_port = config[CONF_FILENAME]
    name = config[CONF_NAME]
-    read_timeout = config[CONF_READ_TIMEOUT]
+    timeout = config[CONF_TIMEOUT]
    write_timeout = config[CONF_WRITE_TIMEOUT]

-    add_entities([AcerSwitch(serial_port, name, read_timeout, write_timeout)], True)
+    add_entities([AcerSwitch(serial_port, name, timeout, write_timeout)], True)


 class AcerSwitch(SwitchEntity):
@@ -78,14 +77,14 @@ class AcerSwitch(SwitchEntity):
        self,
        serial_port: str,
        name: str,
-        read_timeout: int,
+        timeout: int,
        write_timeout: int,
    ) -> None:
        """Init of the Acer projector."""
+        self.serial = serial.Serial(
+            port=serial_port, timeout=timeout, write_timeout=write_timeout
+        )
        self._serial_port = serial_port
-        self._read_timeout = read_timeout
-        self._write_timeout = write_timeout
-
        self._attr_name = name
        self._attributes = {
            LAMP_HOURS: STATE_UNKNOWN,
@@ -95,26 +94,22 @@ class AcerSwitch(SwitchEntity):

    def _write_read(self, msg: str) -> str:
        """Write to the projector and read the return."""
-
+        ret = ""
        # Sometimes the projector won't answer for no reason or the projector
        # was disconnected during runtime.
        # This way the projector can be reconnected and will still work
        try:
-            with Serial.from_url(
-                self._serial_port,
-                read_timeout=self._read_timeout,
-                write_timeout=self._write_timeout,
-            ) as serial:
-                serial.write(msg.encode("utf-8"))
-
-                # Size is an experience value there is no real limit.
-                # AFAIK there is no limit and no end character so we will usually
-                # need to wait for timeout
-                return serial.read_until(size=20).decode("utf-8")
-        except (OSError, SerialException, TimeoutError) as exc:
-            raise HomeAssistantError(
-                f"Problem communicating with {self._serial_port}"
-            ) from exc
+            if not self.serial.is_open:
+                self.serial.open()
+            self.serial.write(msg.encode("utf-8"))
+            # Size is an experience value there is no real limit.
+            # AFAIK there is no limit and no end character so we will usually
+            # need to wait for timeout
+            ret = self.serial.read_until(size=20).decode("utf-8")
+        except serial.SerialException:
+            _LOGGER.error("Problem communicating with %s", self._serial_port)
+        self.serial.close()
+        return ret

    def _write_read_format(self, msg: str) -> str:
        """Write msg, obtain answer and format output."""
--- a/homeassistant/components/actron_air/quality_scale.yaml
+++ b/homeassistant/components/actron_air/quality_scale.yaml
@@ -57,9 +57,9 @@ rules:
  entity-category: done
  entity-device-class: todo
  entity-disabled-by-default: todo
-  entity-translations: done
+  entity-translations: todo
  exception-translations: done
-  icon-translations: done
+  icon-translations: todo
  reconfiguration-flow: todo
  repair-issues:
    status: exempt
--- a/homeassistant/components/alexa_devices/manifest.json
+++ b/homeassistant/components/alexa_devices/manifest.json
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["aioamazondevices"],
  "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==13.4.1"]
+  "requirements": ["aioamazondevices==13.3.2"]
 }
--- a/homeassistant/components/analytics_insights/strings.json
+++ b/homeassistant/components/analytics_insights/strings.json
@@ -11,12 +11,12 @@
      "user": {
        "data": {
          "tracked_apps": "Apps",
-          "tracked_custom_integrations": "Custom integrations",
+          "tracked_custom_integrations": "Community integrations",
          "tracked_integrations": "Integrations"
        },
        "data_description": {
          "tracked_apps": "Select the apps you want to track",
-          "tracked_custom_integrations": "Select the custom integrations you want to track",
+          "tracked_custom_integrations": "Select the community integrations you want to track",
          "tracked_integrations": "Select the integrations you want to track"
        }
      }
@@ -31,7 +31,7 @@
        "unit_of_measurement": "[%key:component::analytics_insights::entity::sensor::apps::unit_of_measurement%]"
      },
      "custom_integrations": {
-        "name": "{custom_integration_domain} (custom)",
+        "name": "{custom_integration_domain} (community)",
        "unit_of_measurement": "[%key:component::analytics_insights::entity::sensor::apps::unit_of_measurement%]"
      },
      "total_active_installations": {
--- a/homeassistant/components/apple_tv/binary_sensor.py
+++ b/homeassistant/components/apple_tv/binary_sensor.py
@@ -14,8 +14,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import SIGNAL_CONNECTED, AppleTvConfigEntry
 from .entity import AppleTVEntity

-PARALLEL_UPDATES = 0
-

 async def async_setup_entry(
    hass: HomeAssistant,
--- a/homeassistant/components/automation/init.py
+++ b/homeassistant/components/automation/init.py
@@ -143,7 +143,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
    "occupancy",
    "person",
    "power",
-    "remote",
    "schedule",
    "select",
    "siren",
@@ -151,8 +150,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
    "temperature",
    "text",
    "timer",
-    "todo",
-    "update",
    "vacuum",
    "valve",
    "water_heater",
--- a/homeassistant/components/bmw_connected_drive/strings.json
+++ b/homeassistant/components/bmw_connected_drive/strings.json
@@ -1,7 +1,7 @@
 {
  "issues": {
    "integration_removed": {
-      "description": "The BMW Connected Drive integration has been removed from Home Assistant.\n\nIn September 2025, BMW blocked third-party access to their servers by adding additional security measures. For EU-registered cars, a community-developed [custom component]({custom_component_url}) using BMW's CarData API is available as an alternative.\n\nTo resolve this issue, please remove the (now defunct) integration entries from your Home Assistant setup. [Click here to see your existing BMW Connected Drive integration entries]({entries}).",
+      "description": "The BMW Connected Drive integration has been removed from Home Assistant.\n\nIn September 2025, BMW blocked third-party access to their servers by adding additional security measures. For EU-registered cars, a [community integration]({custom_component_url}) using BMW's CarData API is available as an alternative.\n\nTo resolve this issue, please remove the (now defunct) integration entries from your Home Assistant setup. [Click here to see your existing BMW Connected Drive integration entries]({entries}).",
      "title": "The BMW Connected Drive integration has been removed"
    }
  }
--- a/homeassistant/components/camera/manifest.json
+++ b/homeassistant/components/camera/manifest.json
@@ -7,5 +7,5 @@
  "documentation": "https://www.home-assistant.io/integrations/camera",
  "integration_type": "entity",
  "quality_scale": "internal",
-  "requirements": ["PyTurboJPEG==1.8.3"]
+  "requirements": ["PyTurboJPEG==1.8.0"]
 }
--- a/homeassistant/components/doods/manifest.json
+++ b/homeassistant/components/doods/manifest.json
@@ -6,5 +6,5 @@
  "iot_class": "local_polling",
  "loggers": ["pydoods"],
  "quality_scale": "legacy",
-  "requirements": ["pydoods==1.0.2", "Pillow==12.2.0"]
+  "requirements": ["pydoods==1.0.2", "Pillow==12.1.1"]
 }
--- a/homeassistant/components/duco/const.py
+++ b/homeassistant/components/duco/const.py
@@ -5,5 +5,5 @@ from datetime import timedelta
 from homeassistant.const import Platform

 DOMAIN = "duco"
-PLATFORMS = [Platform.FAN, Platform.SENSOR]
+PLATFORMS = [Platform.FAN]
 SCAN_INTERVAL = timedelta(seconds=30)
--- a/homeassistant/components/duco/diagnostics.py
+++ b/homeassistant/components/duco/diagnostics.py
@@ -1,53 +0,0 @@
-"""Diagnostics support for Duco."""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import asdict
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_HOST
-from homeassistant.core import HomeAssistant
-
-from .coordinator import DucoConfigEntry
-
-TO_REDACT = {
-    CONF_HOST,
-    "mac",
-    "host_name",
-    "serial_board_box",
-    "serial_board_comm",
-    "serial_duco_box",
-    "serial_duco_comm",
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: DucoConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    board = asdict(coordinator.board_info)
-    board.pop("time")
-
-    lan_info, duco_diags, write_remaining = await asyncio.gather(
-        coordinator.client.async_get_lan_info(),
-        coordinator.client.async_get_diagnostics(),
-        coordinator.client.async_get_write_req_remaining(),
-    )
-
-    return async_redact_data(
-        {
-            "entry_data": entry.data,
-            "board_info": board,
-            "lan_info": asdict(lan_info),
-            "nodes": {
-                str(node_id): asdict(node) for node_id, node in coordinator.data.items()
-            },
-            "duco_diagnostics": [asdict(d) for d in duco_diags],
-            "write_requests_remaining": write_remaining,
-        },
-        TO_REDACT,
-    )
--- a/homeassistant/components/duco/icons.json
+++ b/homeassistant/components/duco/icons.json
@@ -1,15 +0,0 @@
-{
-  "entity": {
-    "sensor": {
-      "iaq_co2": {
-        "default": "mdi:molecule-co2"
-      },
-      "iaq_rh": {
-        "default": "mdi:water-percent"
-      },
-      "ventilation_state": {
-        "default": "mdi:tune-variant"
-      }
-    }
-  }
-}
--- a/homeassistant/components/duco/quality_scale.yaml
+++ b/homeassistant/components/duco/quality_scale.yaml
@@ -45,7 +45,7 @@ rules:

  # Gold
  devices: done
-  diagnostics: done
+  diagnostics: todo
  discovery-update-info:
    status: todo
    comment: >-
@@ -71,11 +71,11 @@ rules:
      Users can pair new modules (CO2 sensors, humidity sensors, zone valves)
      to their Duco box. Dynamic device support to be added in a follow-up PR.
  entity-category: todo
-  entity-device-class: done
-  entity-disabled-by-default: done
+  entity-device-class: todo
+  entity-disabled-by-default: todo
  entity-translations: done
-  exception-translations: done
-  icon-translations: done
+  exception-translations: todo
+  icon-translations: todo
  reconfiguration-flow: todo
  repair-issues: todo
  stale-devices:
--- a/homeassistant/components/duco/sensor.py
+++ b/homeassistant/components/duco/sensor.py
@@ -1,119 +0,0 @@
-"""Sensor platform for the Duco integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from duco.models import Node, NodeType, VentilationState
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import CONCENTRATION_PARTS_PER_MILLION, PERCENTAGE
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import DucoConfigEntry, DucoCoordinator
-from .entity import DucoEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class DucoSensorEntityDescription(SensorEntityDescription):
-    """Duco sensor entity description."""
-
-    value_fn: Callable[[Node], int | float | str | None]
-    node_types: tuple[NodeType, ...]
-
-
-SENSOR_DESCRIPTIONS: tuple[DucoSensorEntityDescription, ...] = (
-    DucoSensorEntityDescription(
-        key="ventilation_state",
-        translation_key="ventilation_state",
-        device_class=SensorDeviceClass.ENUM,
-        options=[s.lower() for s in VentilationState],
-        value_fn=lambda node: (
-            node.ventilation.state.lower() if node.ventilation else None
-        ),
-        node_types=(NodeType.BOX,),
-    ),
-    DucoSensorEntityDescription(
-        key="co2",
-        device_class=SensorDeviceClass.CO2,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
-        value_fn=lambda node: node.sensor.co2 if node.sensor else None,
-        node_types=(NodeType.UCCO2,),
-    ),
-    DucoSensorEntityDescription(
-        key="iaq_co2",
-        translation_key="iaq_co2",
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
-        value_fn=lambda node: node.sensor.iaq_co2 if node.sensor else None,
-        node_types=(NodeType.UCCO2,),
-    ),
-    DucoSensorEntityDescription(
-        key="humidity",
-        device_class=SensorDeviceClass.HUMIDITY,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=PERCENTAGE,
-        value_fn=lambda node: node.sensor.rh if node.sensor else None,
-        node_types=(NodeType.BSRH,),
-    ),
-    DucoSensorEntityDescription(
-        key="iaq_rh",
-        translation_key="iaq_rh",
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
-        value_fn=lambda node: node.sensor.iaq_rh if node.sensor else None,
-        node_types=(NodeType.BSRH,),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: DucoConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Duco sensor entities."""
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        DucoSensorEntity(coordinator, node, description)
-        for node in coordinator.data.values()
-        for description in SENSOR_DESCRIPTIONS
-        if node.general.node_type in description.node_types
-    )
-
-
-class DucoSensorEntity(DucoEntity, SensorEntity):
-    """Sensor entity for a Duco node."""
-
-    entity_description: DucoSensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: DucoCoordinator,
-        node: Node,
-        description: DucoSensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor entity."""
-        super().__init__(coordinator, node)
-        self.entity_description = description
-        self._attr_unique_id = (
-            f"{coordinator.config_entry.unique_id}_{node.node_id}_{description.key}"
-        )
-
-    @property
-    def native_value(self) -> int | float | str | None:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self._node)
--- a/homeassistant/components/duco/strings.json
+++ b/homeassistant/components/duco/strings.json
@@ -29,36 +29,6 @@
          }
        }
      }
-    },
-    "sensor": {
-      "iaq_co2": {
-        "name": "CO2 air quality index"
-      },
-      "iaq_rh": {
-        "name": "Humidity air quality index"
-      },
-      "ventilation_state": {
-        "name": "Ventilation state",
-        "state": {
-          "aut1": "Automatic boost (15 min)",
-          "aut2": "Automatic boost (30 min)",
-          "aut3": "Automatic boost (45 min)",
-          "auto": "Automatic",
-          "cnt1": "Continuous low speed",
-          "cnt2": "Continuous medium speed",
-          "cnt3": "Continuous high speed",
-          "empt": "Empty house",
-          "man1": "Manual low speed (15 min)",
-          "man1x2": "Manual low speed (30 min)",
-          "man1x3": "Manual low speed (45 min)",
-          "man2": "Manual medium speed (15 min)",
-          "man2x2": "Manual medium speed (30 min)",
-          "man2x3": "Manual medium speed (45 min)",
-          "man3": "Manual high speed (15 min)",
-          "man3x2": "Manual high speed (30 min)",
-          "man3x3": "Manual high speed (45 min)"
-        }
-      }
    }
  },
  "exceptions": {
--- a/homeassistant/components/elgato/config_flow.py
+++ b/homeassistant/components/elgato/config_flow.py
@@ -71,43 +71,6 @@ class ElgatoFlowHandler(ConfigFlow, domain=DOMAIN):
        """Handle a flow initiated by zeroconf."""
        return self._async_create_entry()

-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of an existing Elgato device."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            elgato = Elgato(
-                host=user_input[CONF_HOST],
-                session=async_get_clientsession(self.hass),
-            )
-
-            try:
-                info = await elgato.info()
-            except ElgatoError:
-                errors["base"] = "cannot_connect"
-            else:
-                await self.async_set_unique_id(info.serial_number)
-                self._abort_if_unique_id_mismatch(reason="different_device")
-                return self.async_update_reload_and_abort(
-                    self._get_reconfigure_entry(),
-                    data_updates={CONF_HOST: user_input[CONF_HOST]},
-                )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_HOST,
-                        default=self._get_reconfigure_entry().data[CONF_HOST],
-                    ): str,
-                }
-            ),
-            errors=errors,
-        )
-
    async def async_step_dhcp(
        self, discovery_info: DhcpServiceInfo
    ) -> ConfigFlowResult:
--- a/homeassistant/components/elgato/quality_scale.yaml
+++ b/homeassistant/components/elgato/quality_scale.yaml
@@ -62,7 +62,7 @@ rules:
  entity-translations: done
  exception-translations: done
  icon-translations: done
-  reconfiguration-flow: done
+  reconfiguration-flow: todo
  repair-issues:
    status: exempt
    comment: |
--- a/homeassistant/components/elgato/strings.json
+++ b/homeassistant/components/elgato/strings.json
@@ -3,23 +3,13 @@
    "abort": {
      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "different_device": "The configured Elgato device is not the same as the one at this address.",
-      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
    },
    "error": {
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
    },
    "flow_title": "{serial_number}",
    "step": {
-      "reconfigure": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]"
-        },
-        "data_description": {
-          "host": "[%key:component::elgato::config::step::user::data_description::host%]"
-        }
-      },
      "user": {
        "data": {
          "host": "[%key:common::config_flow::data::host%]"
--- a/homeassistant/components/enphase_envoy/manifest.json
+++ b/homeassistant/components/enphase_envoy/manifest.json
@@ -8,7 +8,7 @@
  "iot_class": "local_polling",
  "loggers": ["pyenphase"],
  "quality_scale": "platinum",
-  "requirements": ["pyenphase==2.4.8"],
+  "requirements": ["pyenphase==2.4.6"],
  "zeroconf": [
    {
      "type": "_enphase-envoy._tcp.local."
--- a/homeassistant/components/epic_games_store/manifest.json
+++ b/homeassistant/components/epic_games_store/manifest.json
@@ -1,7 +1,7 @@
 {
  "domain": "epic_games_store",
  "name": "Epic Games Store",
-  "codeowners": ["@Quentame"],
+  "codeowners": ["@hacf-fr", "@Quentame"],
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/epic_games_store",
  "integration_type": "service",
--- a/homeassistant/components/eurotronic_cometblue/init.py
+++ b/homeassistant/components/eurotronic_cometblue/init.py
@@ -16,7 +16,6 @@ from .const import DOMAIN
 from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator

 PLATFORMS: list[Platform] = [
-    Platform.BUTTON,
    Platform.CLIMATE,
 ]

--- a/homeassistant/components/eurotronic_cometblue/button.py
+++ b/homeassistant/components/eurotronic_cometblue/button.py
@@ -1,61 +0,0 @@
-"""Comet Blue button platform."""
-
-from __future__ import annotations
-
-from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.util import dt as dt_util
-
-from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
-from .entity import CometBlueBluetoothEntity
-
-PARALLEL_UPDATES = 1
-
-DESCRIPTIONS = [
-    ButtonEntityDescription(
-        key="sync_time",
-        translation_key="sync_time",
-        entity_category=EntityCategory.CONFIG,
-    ),
-]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: CometBlueConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the client entities."""
-
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        [
-            CometBlueButtonEntity(coordinator, description)
-            for description in DESCRIPTIONS
-        ]
-    )
-
-
-class CometBlueButtonEntity(CometBlueBluetoothEntity, ButtonEntity):
-    """Representation of a button."""
-
-    def __init__(
-        self,
-        coordinator: CometBlueDataUpdateCoordinator,
-        description: ButtonEntityDescription,
-    ) -> None:
-        """Initialize CometBlueButtonEntity."""
-
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.address}-{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        if self.entity_description.key == "sync_time":
-            await self.coordinator.send_command(
-                self.coordinator.device.set_datetime_async, {"date": dt_util.now()}
-            )
--- a/homeassistant/components/eurotronic_cometblue/icons.json
+++ b/homeassistant/components/eurotronic_cometblue/icons.json
@@ -1,9 +0,0 @@
-{
-  "entity": {
-    "button": {
-      "sync_time": {
-        "default": "mdi:calendar-clock"
-      }
-    }
-  }
-}
--- a/homeassistant/components/eurotronic_cometblue/strings.json
+++ b/homeassistant/components/eurotronic_cometblue/strings.json
@@ -29,12 +29,5 @@
        }
      }
    }
-  },
-  "entity": {
-    "button": {
-      "sync_time": {
-        "name": "Sync time"
-      }
-    }
  }
 }
--- a/homeassistant/components/evohome/const.py
+++ b/homeassistant/components/evohome/const.py
@@ -22,8 +22,9 @@ CONF_LOCATION_IDX: Final = "location_idx"
 SCAN_INTERVAL_DEFAULT: Final = timedelta(seconds=300)
 SCAN_INTERVAL_MINIMUM: Final = timedelta(seconds=60)

-ATTR_DURATION: Final = "duration"  # number of minutes, <24h
 ATTR_PERIOD: Final = "period"  # number of days
+ATTR_DURATION: Final = "duration"  # number of minutes, <24h
+
 ATTR_SETPOINT: Final = "setpoint"


@@ -36,4 +37,3 @@ class EvoService(StrEnum):
    RESET_SYSTEM = "reset_system"
    SET_ZONE_OVERRIDE = "set_zone_override"
    CLEAR_ZONE_OVERRIDE = "clear_zone_override"
-    SET_DHW_OVERRIDE = "set_dhw_override"
--- a/homeassistant/components/evohome/icons.json
+++ b/homeassistant/components/evohome/icons.json
@@ -22,9 +22,6 @@
    "reset_system": {
      "service": "mdi:refresh"
    },
-    "set_dhw_override": {
-      "service": "mdi:water-heater"
-    },
    "set_system_mode": {
      "service": "mdi:pencil"
    },
--- a/homeassistant/components/evohome/services.py
+++ b/homeassistant/components/evohome/services.py
@@ -14,8 +14,7 @@ from evohomeasync2.schemas.const import (
 import voluptuous as vol

 from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
-from homeassistant.components.water_heater import DOMAIN as WATER_HEATER_DOMAIN
-from homeassistant.const import ATTR_MODE, ATTR_STATE
+from homeassistant.const import ATTR_MODE
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, service
@@ -50,15 +49,6 @@ SET_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
    ),
 }

-# DHW service schemas (registered as entity services)
-SET_DHW_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
-    vol.Required(ATTR_STATE): cv.boolean,
-    vol.Optional(ATTR_DURATION): vol.All(
-        cv.time_period,
-        vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
-    ),
-}
-

 def _register_zone_entity_services(hass: HomeAssistant) -> None:
    """Register entity-level services for zones."""
@@ -81,19 +71,6 @@ def _register_zone_entity_services(hass: HomeAssistant) -> None:
    )


-def _register_dhw_entity_services(hass: HomeAssistant) -> None:
-    """Register entity-level services for DHW zones."""
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        EvoService.SET_DHW_OVERRIDE,
-        entity_domain=WATER_HEATER_DOMAIN,
-        schema=SET_DHW_OVERRIDE_SCHEMA,
-        func="async_set_dhw_override",
-    )
-
-
 def _validate_set_system_mode_params(tcs: ControlSystem, data: dict[str, Any]) -> None:
    """Validate that a set_system_mode service call is properly formed."""

@@ -179,4 +156,3 @@ def setup_service_functions(
    )

    _register_zone_entity_services(hass)
-    _register_dhw_entity_services(hass)
--- a/homeassistant/components/evohome/services.yaml
+++ b/homeassistant/components/evohome/services.yaml
@@ -58,19 +58,3 @@ clear_zone_override:
      domain: climate
      supported_features:
        - climate.ClimateEntityFeature.TARGET_TEMPERATURE
-
-set_dhw_override:
-  target:
-    entity:
-      integration: evohome
-      domain: water_heater
-  fields:
-    state:
-      required: true
-      selector:
-        boolean:
-    duration:
-      example: "02:15"
-      selector:
-        duration:
-          enable_second: false
--- a/homeassistant/components/evohome/strings.json
+++ b/homeassistant/components/evohome/strings.json
@@ -21,7 +21,7 @@
  },
  "services": {
    "clear_zone_override": {
-      "description": "Sets the zone to follow its schedule.",
+      "description": "Sets a zone to follow its schedule.",
      "name": "Clear zone override"
    },
    "refresh_system": {
@@ -29,25 +29,11 @@
      "name": "Refresh system"
    },
    "reset_system": {
-      "description": "Sets the system mode to `Auto` mode and resets all the zones to follow their schedules. Not all Evohome systems support this feature (i.e. `AutoWithReset` mode).",
+      "description": "Sets the system to `Auto` mode and resets all the zones to follow their schedules. Not all Evohome systems support this feature (i.e. `AutoWithReset` mode).",
      "name": "Reset system"
    },
-    "set_dhw_override": {
-      "description": "Overrides the DHW state, either indefinitely or for a specified duration, after which it will revert to following its schedule.",
-      "fields": {
-        "duration": {
-          "description": "The DHW will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",
-          "name": "Duration"
-        },
-        "state": {
-          "description": "The DHW state: True (on: heat the water up to the setpoint) or False (off).",
-          "name": "State"
-        }
-      },
-      "name": "Set DHW override"
-    },
    "set_system_mode": {
-      "description": "Sets the system mode, either indefinitely or until a specified end time, after which it will revert to `Auto`. Not all systems support all modes.",
+      "description": "Sets the system mode, either indefinitely, or for a specified period of time, after which it will revert to `Auto`. Not all systems support all modes.",
      "fields": {
        "duration": {
          "description": "The duration in hours; used only with `AutoWithEco` mode (up to 24 hours).",
@@ -65,7 +51,7 @@
      "name": "Set system mode"
    },
    "set_zone_override": {
-      "description": "Overrides the zone setpoint, either indefinitely or for a specified duration, after which it will revert to following its schedule.",
+      "description": "Overrides the zone's setpoint, either indefinitely, or for a specified period of time, after which it will revert to following its schedule.",
      "fields": {
        "duration": {
          "description": "The zone will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",
--- a/homeassistant/components/evohome/water_heater.py
+++ b/homeassistant/components/evohome/water_heater.py
@@ -2,7 +2,6 @@

 from __future__ import annotations

-from datetime import timedelta
 import logging
 from typing import Any

@@ -98,28 +97,6 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
            PRECISION_TENTHS if coordinator.client_v1 else PRECISION_WHOLE
        )

-    async def async_set_dhw_override(
-        self, state: bool, duration: timedelta | None = None
-    ) -> None:
-        """Override the DHW zone's on/off state, either permanently or for a duration."""
-
-        if duration is None:
-            until = None  # indefinitely, aka permanent override
-        elif duration.total_seconds() == 0:
-            await self._update_schedule()
-            until = self.setpoints.get("next_sp_from")
-        else:
-            until = dt_util.now() + duration
-
-        until = dt_util.as_utc(until) if until else None
-
-        if state:
-            await self.coordinator.call_client_api(self._evo_device.set_on(until=until))
-        else:
-            await self.coordinator.call_client_api(
-                self._evo_device.set_off(until=until)
-            )
-
    @property
    def current_operation(self) -> str | None:
        """Return the current operating mode (Auto, On, or Off)."""
--- a/homeassistant/components/freebox/manifest.json
+++ b/homeassistant/components/freebox/manifest.json
@@ -1,7 +1,7 @@
 {
  "domain": "freebox",
  "name": "Freebox",
-  "codeowners": ["@hacf-fr/reviewers", "@Quentame"],
+  "codeowners": ["@hacf-fr", "@Quentame"],
  "config_flow": true,
  "dependencies": ["ffmpeg"],
  "documentation": "https://www.home-assistant.io/integrations/freebox",
--- a/homeassistant/components/freshr/coordinator.py
+++ b/homeassistant/components/freshr/coordinator.py
@@ -6,7 +6,7 @@ from datetime import timedelta
 from aiohttp import ClientError
 from pyfreshr import FreshrClient
 from pyfreshr.exceptions import ApiResponseError, LoginError
-from pyfreshr.models import DeviceReadings, DeviceSummary, DeviceType
+from pyfreshr.models import DeviceReadings, DeviceSummary

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
@@ -18,12 +18,6 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda

 from .const import DOMAIN, LOGGER

-_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
-    DeviceType.FRESH_R: "Fresh-r",
-    DeviceType.FORWARD: "Fresh-r Forward",
-    DeviceType.MONITOR: "Fresh-r Monitor",
-}
-
 DEVICES_SCAN_INTERVAL = timedelta(hours=1)
 READINGS_SCAN_INTERVAL = timedelta(minutes=10)

@@ -116,12 +110,6 @@ class FreshrReadingsCoordinator(DataUpdateCoordinator[DeviceReadings]):
        )
        self._device = device
        self._client = client
-        self.device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, device.id)},
-            name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
-            serial_number=device.id,
-            manufacturer="Fresh-r",
-        )

    @property
    def device_id(self) -> str:
--- a/homeassistant/components/freshr/entity.py
+++ b/homeassistant/components/freshr/entity.py
@@ -1,18 +0,0 @@
-"""Base entity for the Fresh-r integration."""
-
-from __future__ import annotations
-
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import FreshrReadingsCoordinator
-
-
-class FreshrEntity(CoordinatorEntity[FreshrReadingsCoordinator]):
-    """Base class for Fresh-r entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: FreshrReadingsCoordinator) -> None:
-        """Initialize the Fresh-r entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
--- a/homeassistant/components/freshr/manifest.json
+++ b/homeassistant/components/freshr/manifest.json
@@ -6,6 +6,6 @@
  "documentation": "https://www.home-assistant.io/integrations/freshr",
  "integration_type": "hub",
  "iot_class": "cloud_polling",
-  "quality_scale": "platinum",
+  "quality_scale": "silver",
  "requirements": ["pyfreshr==1.2.0"]
 }
--- a/homeassistant/components/freshr/sensor.py
+++ b/homeassistant/components/freshr/sensor.py
@@ -21,10 +21,12 @@ from homeassistant.const import (
    UnitOfVolumeFlowRate,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity

+from .const import DOMAIN
 from .coordinator import FreshrConfigEntry, FreshrReadingsCoordinator
-from .entity import FreshrEntity

 PARALLEL_UPDATES = 0

@@ -91,6 +93,12 @@ _TEMP = FreshrSensorEntityDescription(
    value_fn=lambda r: r.temp,
 )

+_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
+    DeviceType.FRESH_R: "Fresh-r",
+    DeviceType.FORWARD: "Fresh-r Forward",
+    DeviceType.MONITOR: "Fresh-r Monitor",
+}
+
 SENSOR_TYPES: dict[DeviceType, tuple[FreshrSensorEntityDescription, ...]] = {
    DeviceType.FRESH_R: (_T1, _T2, _CO2, _HUM, _FLOW, _DP),
    DeviceType.FORWARD: (_T1, _T2, _CO2, _HUM, _FLOW, _DP, _TEMP),
@@ -123,10 +131,17 @@ async def async_setup_entry(
            descriptions = SENSOR_TYPES.get(
                device.device_type, SENSOR_TYPES[DeviceType.FRESH_R]
            )
+            device_info = DeviceInfo(
+                identifiers={(DOMAIN, device_id)},
+                name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
+                serial_number=device_id,
+                manufacturer="Fresh-r",
+            )
            entities.extend(
                FreshrSensor(
                    config_entry.runtime_data.readings[device_id],
                    description,
+                    device_info,
                )
                for description in descriptions
            )
@@ -136,19 +151,22 @@ async def async_setup_entry(
    config_entry.async_on_unload(coordinator.async_add_listener(_check_devices))


-class FreshrSensor(FreshrEntity, SensorEntity):
+class FreshrSensor(CoordinatorEntity[FreshrReadingsCoordinator], SensorEntity):
    """Representation of a Fresh-r sensor."""

+    _attr_has_entity_name = True
    entity_description: FreshrSensorEntityDescription

    def __init__(
        self,
        coordinator: FreshrReadingsCoordinator,
        description: FreshrSensorEntityDescription,
+        device_info: DeviceInfo,
    ) -> None:
        """Initialize the sensor."""
        super().__init__(coordinator)
        self.entity_description = description
+        self._attr_device_info = device_info
        self._attr_unique_id = f"{coordinator.device_id}_{description.key}"

    @property
--- a/homeassistant/components/gardena_bluetooth/init.py
+++ b/homeassistant/components/gardena_bluetooth/init.py
@@ -2,6 +2,7 @@

 from __future__ import annotations

+import asyncio
 import logging

 from bleak.backends.device import BLEDevice
@@ -12,8 +13,7 @@ from gardena_bluetooth.exceptions import (
    CharacteristicNotFound,
    CommunicationFailure,
 )
-from gardena_bluetooth.parse import CharacteristicTime, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
+from gardena_bluetooth.parse import CharacteristicTime

 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
@@ -29,6 +29,7 @@ from .coordinator import (
    GardenaBluetoothConfigEntry,
    GardenaBluetoothCoordinator,
 )
+from .util import async_get_product_type

 PLATFORMS: list[Platform] = [
    Platform.BINARY_SENSOR,
@@ -75,10 +76,11 @@ async def async_setup_entry(

    address = entry.data[CONF_ADDRESS]

-    mfg_data = await async_get_manufacturer_data({address})
-    product_type = mfg_data[address].product_type
-    if product_type == ProductType.UNKNOWN:
-        raise ConfigEntryNotReady("Unable to find product type")
+    try:
+        async with asyncio.timeout(TIMEOUT):
+            product_type = await async_get_product_type(hass, address)
+    except TimeoutError as exception:
+        raise ConfigEntryNotReady("Unable to find product type") from exception

    client = Client(get_connection(hass, address), product_type)
    try:
--- a/homeassistant/components/gardena_bluetooth/config_flow.py
+++ b/homeassistant/components/gardena_bluetooth/config_flow.py
@@ -9,7 +9,6 @@ from gardena_bluetooth.client import Client
 from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation, ScanService
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
 from gardena_bluetooth.parse import ManufacturerData, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
 import voluptuous as vol

 from homeassistant.components.bluetooth import (
@@ -25,27 +24,41 @@ from .const import DOMAIN

 _LOGGER = logging.getLogger(__name__)

-_SUPPORTED_PRODUCT_TYPES = {
-    ProductType.PUMP,
-    ProductType.VALVE,
-    ProductType.WATER_COMPUTER,
-    ProductType.AUTOMATS,
-    ProductType.PRESSURE_TANKS,
-    ProductType.AQUA_CONTOURS,
-}
-

 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:
+    if not (data := discovery_info.manufacturer_data.get(ManufacturerData.company)):
        _LOGGER.debug("Missing manufacturer data: %s", discovery_info)
        return False
+
+    manufacturer_data = ManufacturerData.decode(data)
+    product_type = ProductType.from_manufacturer_data(manufacturer_data)
+
+    if product_type not in (
+        ProductType.PUMP,
+        ProductType.VALVE,
+        ProductType.WATER_COMPUTER,
+        ProductType.AUTOMATS,
+        ProductType.PRESSURE_TANKS,
+        ProductType.AQUA_CONTOURS,
+    ):
+        _LOGGER.debug("Unsupported device: %s", manufacturer_data)
+        return False
+
    return True


+def _get_name(discovery_info: BluetoothServiceInfo):
+    data = discovery_info.manufacturer_data[ManufacturerData.company]
+    manufacturer_data = ManufacturerData.decode(data)
+    product_type = ProductType.from_manufacturer_data(manufacturer_data)
+
+    return PRODUCT_NAMES.get(product_type, "Gardena Device")
+
+
 class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
    """Handle a config flow for Gardena Bluetooth."""

@@ -77,13 +90,11 @@ 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
-        if product_type not in _SUPPORTED_PRODUCT_TYPES:
+        if not _is_supported(discovery_info):
            return self.async_abort(reason="no_devices_found")

        self.address = discovery_info.address
-        self.devices = {discovery_info.address: PRODUCT_NAMES[product_type]}
+        self.devices = {discovery_info.address: _get_name(discovery_info)}
        await self.async_set_unique_id(self.address)
        self._abort_if_unique_id_configured()
        return await self.async_step_confirm()
@@ -120,21 +131,12 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
            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]
-
-        # Keep selection sorted by address to ensure stable tests
-        self.devices = dict(sorted(self.devices.items(), key=lambda x: x[0]))
+            self.devices[address] = _get_name(discovery_info)

        if not self.devices:
            return self.async_abort(reason="no_devices_found")
--- a/homeassistant/components/gardena_bluetooth/manifest.json
+++ b/homeassistant/components/gardena_bluetooth/manifest.json
@@ -15,5 +15,5 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["bleak", "bleak_esphome", "gardena_bluetooth"],
-  "requirements": ["gardena-bluetooth==2.4.0"]
+  "requirements": ["gardena-bluetooth==2.3.0"]
 }
--- a/homeassistant/components/gardena_bluetooth/util.py
+++ b/homeassistant/components/gardena_bluetooth/util.py
@@ -0,0 +1,51 @@
+"""Utility functions for Gardena Bluetooth integration."""
+
+import asyncio
+from collections.abc import AsyncIterator
+
+from gardena_bluetooth.parse import ManufacturerData, ProductType
+
+from homeassistant.components import bluetooth
+
+
+async def _async_service_info(
+    hass, address
+) -> AsyncIterator[bluetooth.BluetoothServiceInfoBleak]:
+    queue = asyncio.Queue[bluetooth.BluetoothServiceInfoBleak]()
+
+    def _callback(
+        service_info: bluetooth.BluetoothServiceInfoBleak,
+        change: bluetooth.BluetoothChange,
+    ) -> None:
+        if change != bluetooth.BluetoothChange.ADVERTISEMENT:
+            return
+
+        queue.put_nowait(service_info)
+
+    service_info = bluetooth.async_last_service_info(hass, address, True)
+    if service_info:
+        yield service_info
+
+    cancel = bluetooth.async_register_callback(
+        hass,
+        _callback,
+        {bluetooth.match.ADDRESS: address},
+        bluetooth.BluetoothScanningMode.ACTIVE,
+    )
+    try:
+        while True:
+            yield await queue.get()
+    finally:
+        cancel()
+
+
+async def async_get_product_type(hass, address: str) -> ProductType:
+    """Wait for enough packets of manufacturer data to get the product type."""
+    data = ManufacturerData()
+
+    async for service_info in _async_service_info(hass, address):
+        data.update(service_info.manufacturer_data.get(ManufacturerData.company, b""))
+        product_type = ProductType.from_manufacturer_data(data)
+        if product_type is not ProductType.UNKNOWN:
+            return product_type
+    raise AssertionError("Iterator should have been infinite")
--- a/homeassistant/components/generic/manifest.json
+++ b/homeassistant/components/generic/manifest.json
@@ -7,5 +7,5 @@
  "documentation": "https://www.home-assistant.io/integrations/generic",
  "integration_type": "device",
  "iot_class": "local_push",
-  "requirements": ["av==16.0.1", "Pillow==12.2.0"]
+  "requirements": ["av==16.0.1", "Pillow==12.1.1"]
 }
--- a/homeassistant/components/generic_thermostat/climate.py
+++ b/homeassistant/components/generic_thermostat/climate.py
@@ -8,7 +8,6 @@ from datetime import datetime, timedelta
 from functools import partial
 import logging
 import math
-import time
 from typing import Any

 import voluptuous as vol
@@ -52,7 +51,6 @@ from homeassistant.core import (
 )
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device import async_entity_id_to_device
-from homeassistant.helpers.entity import CONTEXT_RECENT_TIME_SECONDS
 from homeassistant.helpers.entity_platform import (
    AddConfigEntryEntitiesCallback,
    AddEntitiesCallback,
@@ -480,7 +478,6 @@ class GenericThermostat(ClimateEntity, RestoreEntity):
        if new_state is None or new_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
            return

-        self.async_set_context(event.context)
        self._async_update_temp(new_state)
        await self._async_control_heating()
        self.async_write_ha_state()
@@ -534,11 +531,9 @@ class GenericThermostat(ClimateEntity, RestoreEntity):
            _LOGGER.error("Unable to update from sensor: %s", ex)

    async def _async_control_heating(
-        self, _time: datetime | None = None, force: bool = False
+        self, time: datetime | None = None, force: bool = False
    ) -> None:
        """Check if we need to turn heating on or off."""
-        called_by_timer = _time is not None
-
        async with self._temp_lock:
            if not self._active and None not in (
                self._cur_temp,
@@ -557,7 +552,7 @@ class GenericThermostat(ClimateEntity, RestoreEntity):
            if not self._active or self._hvac_mode == HVACMode.OFF:
                return

-            if force and called_by_timer and self.max_cycle_duration:
+            if force and time is not None and self.max_cycle_duration:
                # We were invoked due to `max_cycle_duration`, so turn off
                _LOGGER.debug(
                    "Turning off heater %s due to max cycle time of %s",
@@ -592,7 +587,7 @@ class GenericThermostat(ClimateEntity, RestoreEntity):
                            now - self._last_toggled_time + self.min_cycle_duration,
                            self._async_timer_control_heating,
                        )
-                elif called_by_timer:
+                elif time is not None:
                    # This is a keep-alive call, so ensure it's on
                    _LOGGER.debug(
                        "Keep-alive - Turning on heater %s",
@@ -614,7 +609,7 @@ class GenericThermostat(ClimateEntity, RestoreEntity):
                        now - self._last_toggled_time + self.cycle_cooldown,
                        self._async_timer_control_heating,
                    )
-            elif called_by_timer:
+            elif time is not None:
                # This is a keep-alive call, so ensure it's off
                _LOGGER.debug(
                    "Keep-alive - Turning off heater %s", self.heater_entity_id
@@ -629,25 +624,13 @@ class GenericThermostat(ClimateEntity, RestoreEntity):

        return self.hass.states.is_state(self.heater_entity_id, STATE_ON)

-    def _get_current_context(self) -> Context | None:
-        """Return the current context if it is still recent, or None."""
-        if (
-            self._context_set is not None
-            and time.time() - self._context_set > CONTEXT_RECENT_TIME_SECONDS
-        ):
-            self._context = None
-            self._context_set = None
-        return self._context
-
    async def _async_heater_turn_on(self, keepalive: bool = False) -> None:
        """Turn heater toggleable device on."""
        data = {ATTR_ENTITY_ID: self.heater_entity_id}
-        # Create a child context for the switch service call so we can
-        # identify the resulting state change event as originating from us.
-        # Don't set it as our own context — the climate entity's state changes
-        # should remain attributed to the parent context (e.g., set_hvac_mode).
-        current_context = self._get_current_context()
-        new_context = Context(parent_id=current_context.id if current_context else None)
+        # Create a new context for this service call so we can identify
+        # the resulting state change event as originating from us
+        new_context = Context(parent_id=self._context.id if self._context else None)
+        self.async_set_context(new_context)
        self._last_context_id = new_context.id
        await self.hass.services.async_call(
            HOMEASSISTANT_DOMAIN, SERVICE_TURN_ON, data, context=new_context
@@ -671,12 +654,10 @@ class GenericThermostat(ClimateEntity, RestoreEntity):
    async def _async_heater_turn_off(self, keepalive: bool = False) -> None:
        """Turn heater toggleable device off."""
        data = {ATTR_ENTITY_ID: self.heater_entity_id}
-        # Create a child context for the switch service call so we can
-        # identify the resulting state change event as originating from us.
-        # Don't set it as our own context — the climate entity's state changes
-        # should remain attributed to the parent context (e.g., set_hvac_mode).
-        current_context = self._get_current_context()
-        new_context = Context(parent_id=current_context.id if current_context else None)
+        # Create a new context for this service call so we can identify
+        # the resulting state change event as originating from us
+        new_context = Context(parent_id=self._context.id if self._context else None)
+        self.async_set_context(new_context)
        self._last_context_id = new_context.id
        await self.hass.services.async_call(
            HOMEASSISTANT_DOMAIN, SERVICE_TURN_OFF, data, context=new_context
--- a/homeassistant/components/go2rtc/init.py
+++ b/homeassistant/components/go2rtc/init.py
@@ -175,7 +175,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
            await server.start()
        except Exception:  # noqa: BLE001
            _LOGGER.warning("Could not start go2rtc server", exc_info=True)
-            await session.close()
            return False

        async def on_stop(event: Event) -> None:
--- a/homeassistant/components/hassio/init.py
+++ b/homeassistant/components/hassio/init.py
@@ -91,14 +91,10 @@ from .const import (
    DATA_STORE,
    DATA_SUPERVISOR_INFO,
    DOMAIN,
-    HASSIO_MAIN_UPDATE_INTERVAL,
-    MAIN_COORDINATOR,
-    STATS_COORDINATOR,
+    HASSIO_UPDATE_INTERVAL,
 )
 from .coordinator import (
-    HassioAddOnDataUpdateCoordinator,
-    HassioMainDataUpdateCoordinator,
-    HassioStatsDataUpdateCoordinator,
+    HassioDataUpdateCoordinator,
    get_addons_info,
    get_addons_list,
    get_addons_stats,
@@ -388,6 +384,12 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
            ]
            hass.data[DATA_SUPERVISOR_INFO]["addons"] = hass.data[DATA_ADDONS_LIST]

+        async_call_later(
+            hass,
+            HASSIO_UPDATE_INTERVAL,
+            HassJob(update_info_data, cancel_on_shutdown=True),
+        )
+
    # Fetch data
    update_info_task = hass.async_create_task(update_info_data(), eager_start=True)

@@ -434,7 +436,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
            # os info not yet fetched from supervisor, retry later
            async_call_later(
                hass,
-                HASSIO_MAIN_UPDATE_INTERVAL,
+                HASSIO_UPDATE_INTERVAL,
                async_setup_hardware_integration_job,
            )
            return
@@ -460,20 +462,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Set up a config entry."""
    dev_reg = dr.async_get(hass)
-
-    coordinator = HassioMainDataUpdateCoordinator(hass, entry, dev_reg)
+    coordinator = HassioDataUpdateCoordinator(hass, entry, dev_reg)
    await coordinator.async_config_entry_first_refresh()
-    hass.data[MAIN_COORDINATOR] = coordinator
-
-    addon_coordinator = HassioAddOnDataUpdateCoordinator(
-        hass, entry, dev_reg, coordinator.jobs
-    )
-    await addon_coordinator.async_config_entry_first_refresh()
-    hass.data[ADDONS_COORDINATOR] = addon_coordinator
-
-    stats_coordinator = HassioStatsDataUpdateCoordinator(hass, entry)
-    await stats_coordinator.async_config_entry_first_refresh()
-    hass.data[STATS_COORDINATOR] = stats_coordinator
+    hass.data[ADDONS_COORDINATOR] = coordinator

    def deprecated_setup_issue() -> None:
        os_info = get_os_info(hass)
@@ -540,12 +531,10 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

    # Unload coordinator
-    coordinator: HassioMainDataUpdateCoordinator = hass.data[MAIN_COORDINATOR]
+    coordinator: HassioDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
    coordinator.unload()

-    # Pop coordinators
-    hass.data.pop(MAIN_COORDINATOR, None)
+    # Pop coordinator
    hass.data.pop(ADDONS_COORDINATOR, None)
-    hass.data.pop(STATS_COORDINATOR, None)

    return unload_ok
--- a/homeassistant/components/hassio/binary_sensor.py
+++ b/homeassistant/components/hassio/binary_sensor.py
@@ -22,7 +22,6 @@ from .const import (
    ATTR_STATE,
    DATA_KEY_ADDONS,
    DATA_KEY_MOUNTS,
-    MAIN_COORDINATOR,
 )
 from .entity import HassioAddonEntity, HassioMountEntity

@@ -61,18 +60,17 @@ async def async_setup_entry(
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
    """Binary sensor set up for Hass.io config entry."""
-    addons_coordinator = hass.data[ADDONS_COORDINATOR]
-    coordinator = hass.data[MAIN_COORDINATOR]
+    coordinator = hass.data[ADDONS_COORDINATOR]

    async_add_entities(
        itertools.chain(
            [
                HassioAddonBinarySensor(
                    addon=addon,
-                    coordinator=addons_coordinator,
+                    coordinator=coordinator,
                    entity_description=entity_description,
                )
-                for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
+                for addon in coordinator.data[DATA_KEY_ADDONS].values()
                for entity_description in ADDON_ENTITY_DESCRIPTIONS
            ],
            [
--- a/homeassistant/components/hassio/const.py
+++ b/homeassistant/components/hassio/const.py
@@ -77,9 +77,7 @@ EVENT_JOB = "job"
 UPDATE_KEY_SUPERVISOR = "supervisor"
 STARTUP_COMPLETE = "complete"

-MAIN_COORDINATOR = "hassio_main_coordinator"
 ADDONS_COORDINATOR = "hassio_addons_coordinator"
-STATS_COORDINATOR = "hassio_stats_coordinator"


 DATA_COMPONENT: HassKey[HassIO] = HassKey(DOMAIN)
@@ -96,9 +94,7 @@ DATA_SUPERVISOR_STATS = "hassio_supervisor_stats"
 DATA_ADDONS_INFO = "hassio_addons_info"
 DATA_ADDONS_STATS = "hassio_addons_stats"
 DATA_ADDONS_LIST = "hassio_addons_list"
-HASSIO_MAIN_UPDATE_INTERVAL = timedelta(minutes=5)
-HASSIO_ADDON_UPDATE_INTERVAL = timedelta(minutes=15)
-HASSIO_STATS_UPDATE_INTERVAL = timedelta(seconds=60)
+HASSIO_UPDATE_INTERVAL = timedelta(minutes=5)

 ATTR_AUTO_UPDATE = "auto_update"
 ATTR_VERSION = "version"
--- a/homeassistant/components/hassio/coordinator.py
+++ b/homeassistant/components/hassio/coordinator.py
@@ -7,7 +7,7 @@ from collections import defaultdict
 from collections.abc import Awaitable
 from copy import deepcopy
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast

 from aiohasupervisor import SupervisorError, SupervisorNotFoundError
 from aiohasupervisor.models import (
@@ -15,9 +15,9 @@ from aiohasupervisor.models import (
    CIFSMountResponse,
    InstalledAddon,
    NFSMountResponse,
-    ResponseData,
    StoreInfo,
 )
+from aiohasupervisor.models.base import ResponseData

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_MANUFACTURER, ATTR_NAME
@@ -35,11 +35,13 @@ from .const import (
    ATTR_SLUG,
    ATTR_URL,
    ATTR_VERSION,
+    CONTAINER_INFO,
    CONTAINER_STATS,
    CORE_CONTAINER,
    DATA_ADDONS_INFO,
    DATA_ADDONS_LIST,
    DATA_ADDONS_STATS,
+    DATA_COMPONENT,
    DATA_CORE_INFO,
    DATA_CORE_STATS,
    DATA_HOST_INFO,
@@ -57,9 +59,7 @@ from .const import (
    DATA_SUPERVISOR_INFO,
    DATA_SUPERVISOR_STATS,
    DOMAIN,
-    HASSIO_ADDON_UPDATE_INTERVAL,
-    HASSIO_MAIN_UPDATE_INTERVAL,
-    HASSIO_STATS_UPDATE_INTERVAL,
+    HASSIO_UPDATE_INTERVAL,
    REQUEST_REFRESH_DELAY,
    SUPERVISOR_CONTAINER,
    SupervisorEntityModel,
@@ -318,314 +318,7 @@ def async_remove_devices_from_dev_reg(
            dev_reg.async_remove_device(dev.id)


-class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Class to retrieve Hass.io container stats."""
-
-    config_entry: ConfigEntry
-
-    def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry) -> None:
-        """Initialize coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=HASSIO_STATS_UPDATE_INTERVAL,
-            request_refresh_debouncer=Debouncer(
-                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
-            ),
-        )
-        self.supervisor_client = get_supervisor_client(hass)
-        self._container_updates: defaultdict[str, dict[str, set[str]]] = defaultdict(
-            lambda: defaultdict(set)
-        )
-
-    async def _async_update_data(self) -> dict[str, Any]:
-        """Update stats data via library."""
-        try:
-            await self._fetch_stats()
-        except SupervisorError as err:
-            raise UpdateFailed(f"Error on Supervisor API: {err}") from err
-
-        new_data: dict[str, Any] = {}
-        new_data[DATA_KEY_CORE] = get_core_stats(self.hass)
-        new_data[DATA_KEY_SUPERVISOR] = get_supervisor_stats(self.hass)
-        new_data[DATA_KEY_ADDONS] = get_addons_stats(self.hass)
-        return new_data
-
-    async def _fetch_stats(self) -> None:
-        """Fetch container stats for subscribed entities."""
-        container_updates = self._container_updates
-        data = self.hass.data
-        client = self.supervisor_client
-
-        # Fetch core and supervisor stats
-        updates: dict[str, Awaitable] = {}
-        if container_updates.get(CORE_CONTAINER, {}).get(CONTAINER_STATS):
-            updates[DATA_CORE_STATS] = client.homeassistant.stats()
-        if container_updates.get(SUPERVISOR_CONTAINER, {}).get(CONTAINER_STATS):
-            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
-
-        if updates:
-            api_results: list[ResponseData] = await asyncio.gather(*updates.values())
-            for key, result in zip(updates, api_results, strict=True):
-                data[key] = result.to_dict()
-
-        # Fetch addon stats
-        addons_list = get_addons_list(self.hass) or []
-        started_addons = {
-            addon[ATTR_SLUG]
-            for addon in addons_list
-            if addon.get("state") in {AddonState.STARTED, AddonState.STARTUP}
-        }
-
-        addons_stats: dict[str, Any] = data.setdefault(DATA_ADDONS_STATS, {})
-
-        # Clean up cache for stopped/removed addons
-        for slug in addons_stats.keys() - started_addons:
-            del addons_stats[slug]
-
-        # Fetch stats for addons with subscribed entities
-        addon_stats_results = dict(
-            await asyncio.gather(
-                *[
-                    self._update_addon_stats(slug)
-                    for slug in started_addons
-                    if container_updates.get(slug, {}).get(CONTAINER_STATS)
-                ]
-            )
-        )
-        addons_stats.update(addon_stats_results)
-
-    async def _update_addon_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
-        """Update single addon stats."""
-        try:
-            stats = await self.supervisor_client.addons.addon_stats(slug)
-        except SupervisorError as err:
-            _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
-            return (slug, None)
-        return (slug, stats.to_dict())
-
-    @callback
-    def async_enable_container_updates(
-        self, slug: str, entity_id: str, types: set[str]
-    ) -> CALLBACK_TYPE:
-        """Enable stats updates for a container."""
-        enabled_updates = self._container_updates[slug]
-        for key in types:
-            enabled_updates[key].add(entity_id)
-
-        @callback
-        def _remove() -> None:
-            for key in types:
-                enabled_updates[key].discard(entity_id)
-                if not enabled_updates[key]:
-                    del enabled_updates[key]
-            if not enabled_updates:
-                self._container_updates.pop(slug, None)
-
-        return _remove
-
-
-class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Class to retrieve Hass.io Add-on status."""
-
-    config_entry: ConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: ConfigEntry,
-        dev_reg: dr.DeviceRegistry,
-        jobs: SupervisorJobs,
-    ) -> None:
-        """Initialize coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=HASSIO_ADDON_UPDATE_INTERVAL,
-            # We don't want an immediate refresh since we want to avoid
-            # hammering the Supervisor API on startup
-            request_refresh_debouncer=Debouncer(
-                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
-            ),
-        )
-        self.entry_id = config_entry.entry_id
-        self.dev_reg = dev_reg
-        self._addon_info_subscriptions: defaultdict[str, set[str]] = defaultdict(set)
-        self.supervisor_client = get_supervisor_client(hass)
-        self.jobs = jobs
-
-    async def _async_update_data(self) -> dict[str, Any]:
-        """Update data via library."""
-        is_first_update = not self.data
-        client = self.supervisor_client
-
-        try:
-            installed_addons: list[InstalledAddon] = await client.addons.list()
-            all_addons = {addon.slug for addon in installed_addons}
-
-            # Fetch addon info for all addons on first update, or only
-            # for addons with subscribed entities on subsequent updates.
-            addon_info_results = dict(
-                await asyncio.gather(
-                    *[
-                        self._update_addon_info(slug)
-                        for slug in all_addons
-                        if is_first_update or self._addon_info_subscriptions.get(slug)
-                    ]
-                )
-            )
-        except SupervisorError as err:
-            raise UpdateFailed(f"Error on Supervisor API: {err}") from err
-
-        # Update hass.data for legacy accessor functions
-        data = self.hass.data
-        addons_list_dicts = [addon.to_dict() for addon in installed_addons]
-        data[DATA_ADDONS_LIST] = addons_list_dicts
-
-        # Update addon info cache in hass.data
-        addon_info_cache: dict[str, Any] = data.setdefault(DATA_ADDONS_INFO, {})
-        for slug in addon_info_cache.keys() - all_addons:
-            del addon_info_cache[slug]
-        addon_info_cache.update(addon_info_results)
-
-        # Deprecated 2026.4.0: Folding addons.list results into supervisor_info
-        # for compatibility. Written to hass.data only, not coordinator data.
-        if DATA_SUPERVISOR_INFO in data:
-            data[DATA_SUPERVISOR_INFO]["addons"] = addons_list_dicts
-
-        # Build clean coordinator data
-        store_data = get_store(self.hass)
-        if store_data:
-            repositories = {
-                repo.slug: repo.name
-                for repo in StoreInfo.from_dict(store_data).repositories
-            }
-        else:
-            repositories = {}
-
-        new_data: dict[str, Any] = {}
-        new_data[DATA_KEY_ADDONS] = {
-            (slug := addon[ATTR_SLUG]): {
-                **addon,
-                ATTR_AUTO_UPDATE: (addon_info_cache.get(slug) or {}).get(
-                    ATTR_AUTO_UPDATE, False
-                ),
-                ATTR_REPOSITORY: repositories.get(
-                    repo_slug := addon.get(ATTR_REPOSITORY, ""), repo_slug
-                ),
-            }
-            for addon in addons_list_dicts
-        }
-
-        # If this is the initial refresh, register all addons
-        if is_first_update:
-            async_register_addons_in_dev_reg(
-                self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
-            )
-
-        # Remove add-ons that are no longer installed from device registry
-        supervisor_addon_devices = {
-            list(device.identifiers)[0][1]
-            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
-                self.entry_id
-            )
-            if device.model == SupervisorEntityModel.ADDON
-        }
-        if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
-            async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
-
-        # If there are new add-ons, we should reload the config entry so we can
-        # create new devices and entities. We can return an empty dict because
-        # coordinator will be recreated.
-        if self.data and (
-            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
-        ):
-            self.hass.async_create_task(
-                self.hass.config_entries.async_reload(self.entry_id)
-            )
-            return {}
-
-        return new_data
-
-    async def get_changelog(self, addon_slug: str) -> str | None:
-        """Get the changelog for an add-on."""
-        try:
-            return await self.supervisor_client.store.addon_changelog(addon_slug)
-        except SupervisorNotFoundError:
-            return None
-
-    async def _update_addon_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
-        """Return the info for an addon."""
-        try:
-            info = await self.supervisor_client.addons.addon_info(slug)
-        except SupervisorError as err:
-            _LOGGER.warning("Could not fetch info for %s: %s", slug, err)
-            return (slug, None)
-        # Translate to legacy hassio names for compatibility
-        info_dict = info.to_dict()
-        info_dict["hassio_api"] = info_dict.pop("supervisor_api")
-        info_dict["hassio_role"] = info_dict.pop("supervisor_role")
-        return (slug, info_dict)
-
-    @callback
-    def async_enable_addon_info_updates(
-        self, slug: str, entity_id: str
-    ) -> CALLBACK_TYPE:
-        """Enable info updates for an add-on."""
-        self._addon_info_subscriptions[slug].add(entity_id)
-
-        @callback
-        def _remove() -> None:
-            self._addon_info_subscriptions[slug].discard(entity_id)
-            if not self._addon_info_subscriptions[slug]:
-                del self._addon_info_subscriptions[slug]
-
-        return _remove
-
-    async def _async_refresh(
-        self,
-        log_failures: bool = True,
-        raise_on_auth_failed: bool = False,
-        scheduled: bool = False,
-        raise_on_entry_error: bool = False,
-    ) -> None:
-        """Refresh data."""
-        if not scheduled and not raise_on_auth_failed:
-            # Force reloading add-on updates for non-scheduled
-            # updates.
-            #
-            # If `raise_on_auth_failed` is set, it means this is
-            # the first refresh and we do not want to delay
-            # startup or cause a timeout so we only refresh the
-            # updates if this is not a scheduled refresh and
-            # we are not doing the first refresh.
-            try:
-                await self.supervisor_client.store.reload()
-            except SupervisorError as err:
-                _LOGGER.warning("Error on Supervisor API: %s", err)
-
-        await super()._async_refresh(
-            log_failures, raise_on_auth_failed, scheduled, raise_on_entry_error
-        )
-
-    async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
-        """Force refresh of addon info data for a specific addon."""
-        try:
-            slug, info = await self._update_addon_info(addon_slug)
-            if info is not None and DATA_KEY_ADDONS in self.data:
-                if slug in self.data[DATA_KEY_ADDONS]:
-                    data = deepcopy(self.data)
-                    data[DATA_KEY_ADDONS][slug].update(info)
-                    self.async_set_updated_data(data)
-        except SupervisorError as err:
-            _LOGGER.warning("Could not refresh info for %s: %s", addon_slug, err)
-
-
-class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+class HassioDataUpdateCoordinator(DataUpdateCoordinator):
    """Class to retrieve Hass.io status."""

    config_entry: ConfigEntry
@@ -639,77 +332,82 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
            _LOGGER,
            config_entry=config_entry,
            name=DOMAIN,
-            update_interval=HASSIO_MAIN_UPDATE_INTERVAL,
+            update_interval=HASSIO_UPDATE_INTERVAL,
            # We don't want an immediate refresh since we want to avoid
-            # hammering the Supervisor API on startup
+            # fetching the container stats right away and avoid hammering
+            # the Supervisor API on startup
            request_refresh_debouncer=Debouncer(
                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
            ),
        )
+        self.hassio = hass.data[DATA_COMPONENT]
+        self.data = {}
        self.entry_id = config_entry.entry_id
        self.dev_reg = dev_reg
        self.is_hass_os = (get_info(self.hass) or {}).get("hassos") is not None
+        self._container_updates: defaultdict[str, dict[str, set[str]]] = defaultdict(
+            lambda: defaultdict(set)
+        )
        self.supervisor_client = get_supervisor_client(hass)
        self.jobs = SupervisorJobs(hass)

    async def _async_update_data(self) -> dict[str, Any]:
        """Update data via library."""
        is_first_update = not self.data
-        client = self.supervisor_client

        try:
-            (
-                info,
-                core_info,
-                supervisor_info,
-                os_info,
-                host_info,
-                store_info,
-                network_info,
-            ) = await asyncio.gather(
-                client.info(),
-                client.homeassistant.info(),
-                client.supervisor.info(),
-                client.os.info(),
-                client.host.info(),
-                client.store.info(),
-                client.network.info(),
-            )
-            mounts_info = await client.mounts.info()
-            await self.jobs.refresh_data(is_first_update)
+            await self.force_data_refresh(is_first_update)
        except SupervisorError as err:
            raise UpdateFailed(f"Error on Supervisor API: {err}") from err

-        # Build clean coordinator data
        new_data: dict[str, Any] = {}
-        new_data[DATA_KEY_CORE] = core_info.to_dict()
-        new_data[DATA_KEY_SUPERVISOR] = supervisor_info.to_dict()
-        new_data[DATA_KEY_HOST] = host_info.to_dict()
-        new_data[DATA_KEY_MOUNTS] = {mount.name: mount for mount in mounts_info.mounts}
+        supervisor_info = get_supervisor_info(self.hass) or {}
+        addons_info = get_addons_info(self.hass) or {}
+        addons_stats = get_addons_stats(self.hass)
+        store_data = get_store(self.hass)
+        mounts_info = await self.supervisor_client.mounts.info()
+        addons_list = get_addons_list(self.hass) or []
+
+        if store_data:
+            repositories = {
+                repo.slug: repo.name
+                for repo in StoreInfo.from_dict(store_data).repositories
+            }
+        else:
+            repositories = {}
+
+        new_data[DATA_KEY_ADDONS] = {
+            (slug := addon[ATTR_SLUG]): {
+                **addon,
+                **(addons_stats.get(slug) or {}),
+                ATTR_AUTO_UPDATE: (addons_info.get(slug) or {}).get(
+                    ATTR_AUTO_UPDATE, False
+                ),
+                ATTR_REPOSITORY: repositories.get(
+                    repo_slug := addon.get(ATTR_REPOSITORY, ""), repo_slug
+                ),
+            }
+            for addon in addons_list
+        }
        if self.is_hass_os:
-            new_data[DATA_KEY_OS] = os_info.to_dict()
+            new_data[DATA_KEY_OS] = get_os_info(self.hass)

-        # Update hass.data for legacy accessor functions
-        data = self.hass.data
-        data[DATA_INFO] = info.to_dict()
-        data[DATA_CORE_INFO] = new_data[DATA_KEY_CORE]
-        data[DATA_OS_INFO] = new_data.get(DATA_KEY_OS, os_info.to_dict())
-        data[DATA_HOST_INFO] = new_data[DATA_KEY_HOST]
-        data[DATA_STORE] = store_info.to_dict()
-        data[DATA_NETWORK_INFO] = network_info.to_dict()
-        # Separate dict for hass.data supervisor info since we add deprecated
-        # compat keys that should not be in coordinator data
-        supervisor_info_dict = supervisor_info.to_dict()
-        # Deprecated 2026.4.0: Folding repositories and addons into
-        # supervisor_info for compatibility. Written to hass.data only, not
-        # coordinator data. Preserve the addons key from the addon coordinator.
-        supervisor_info_dict["repositories"] = data[DATA_STORE][ATTR_REPOSITORIES]
-        if (prev := data.get(DATA_SUPERVISOR_INFO)) and "addons" in prev:
-            supervisor_info_dict["addons"] = prev["addons"]
-        data[DATA_SUPERVISOR_INFO] = supervisor_info_dict
+        new_data[DATA_KEY_CORE] = {
+            **(get_core_info(self.hass) or {}),
+            **get_core_stats(self.hass),
+        }
+        new_data[DATA_KEY_SUPERVISOR] = {
+            **supervisor_info,
+            **get_supervisor_stats(self.hass),
+        }
+        new_data[DATA_KEY_HOST] = get_host_info(self.hass) or {}
+        new_data[DATA_KEY_MOUNTS] = {mount.name: mount for mount in mounts_info.mounts}

-        # If this is the initial refresh, register all main components
+        # If this is the initial refresh, register all addons and return the dict
        if is_first_update:
+            async_register_addons_in_dev_reg(
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
+            )
            async_register_mounts_in_dev_reg(
                self.entry_id, self.dev_reg, new_data[DATA_KEY_MOUNTS].values()
            )
@@ -725,6 +423,17 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                    self.entry_id, self.dev_reg, new_data[DATA_KEY_OS]
                )

+        # Remove add-ons that are no longer installed from device registry
+        supervisor_addon_devices = {
+            list(device.identifiers)[0][1]
+            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
+                self.entry_id
+            )
+            if device.model == SupervisorEntityModel.ADDON
+        }
+        if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
+            async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
+
        # Remove mounts that no longer exists from device registry
        supervisor_mount_devices = {
            device.name
@@ -744,11 +453,12 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
            # Remove the OS device if it exists and the installation is not hassos
            self.dev_reg.async_remove_device(dev.id)

-        # If there are new mounts, we should reload the config entry so we can
+        # If there are new add-ons or mounts, we should reload the config entry so we can
        # create new devices and entities. We can return an empty dict because
        # coordinator will be recreated.
        if self.data and (
-            set(new_data[DATA_KEY_MOUNTS]) - set(self.data.get(DATA_KEY_MOUNTS, {}))
+            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
+            or set(new_data[DATA_KEY_MOUNTS]) - set(self.data[DATA_KEY_MOUNTS])
        ):
            self.hass.async_create_task(
                self.hass.config_entries.async_reload(self.entry_id)
@@ -757,6 +467,146 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):

        return new_data

+    async def get_changelog(self, addon_slug: str) -> str | None:
+        """Get the changelog for an add-on."""
+        try:
+            return await self.supervisor_client.store.addon_changelog(addon_slug)
+        except SupervisorNotFoundError:
+            return None
+
+    async def force_data_refresh(self, first_update: bool) -> None:
+        """Force update of the addon info."""
+        container_updates = self._container_updates
+
+        data = self.hass.data
+        client = self.supervisor_client
+
+        updates: dict[str, Awaitable[ResponseData]] = {
+            DATA_INFO: client.info(),
+            DATA_CORE_INFO: client.homeassistant.info(),
+            DATA_SUPERVISOR_INFO: client.supervisor.info(),
+            DATA_OS_INFO: client.os.info(),
+            DATA_STORE: client.store.info(),
+        }
+        if CONTAINER_STATS in container_updates[CORE_CONTAINER]:
+            updates[DATA_CORE_STATS] = client.homeassistant.stats()
+        if CONTAINER_STATS in container_updates[SUPERVISOR_CONTAINER]:
+            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
+
+        # Pull off addons.list results for further processing before caching
+        addons_list, *results = await asyncio.gather(
+            client.addons.list(), *updates.values()
+        )
+        for key, result in zip(updates, cast(list[ResponseData], results), strict=True):
+            data[key] = result.to_dict()
+
+        installed_addons = cast(list[InstalledAddon], addons_list)
+        data[DATA_ADDONS_LIST] = [addon.to_dict() for addon in installed_addons]
+
+        # Deprecated 2026.4.0: Folding repositories and addons.list results into supervisor_info for compatibility
+        # Can drop this after removal period
+        data[DATA_SUPERVISOR_INFO].update(
+            {
+                "repositories": data[DATA_STORE][ATTR_REPOSITORIES],
+                "addons": [addon.to_dict() for addon in installed_addons],
+            }
+        )
+
+        all_addons = {addon.slug for addon in installed_addons}
+        started_addons = {
+            addon.slug
+            for addon in installed_addons
+            if addon.state in {AddonState.STARTED, AddonState.STARTUP}
+        }
+
+        #
+        # Update addon info if its the first update or
+        # there is at least one entity that needs the data.
+        #
+        # When entities are added they call async_enable_container_updates
+        # to enable updates for the endpoints they need via
+        # async_added_to_hass. This ensures that we only update
+        # the data for the endpoints that are needed to avoid unnecessary
+        # API calls since otherwise we would fetch stats for all containers
+        # and throw them away.
+        #
+        for data_key, update_func, enabled_key, wanted_addons, needs_first_update in (
+            (
+                DATA_ADDONS_STATS,
+                self._update_addon_stats,
+                CONTAINER_STATS,
+                started_addons,
+                False,
+            ),
+            (
+                DATA_ADDONS_INFO,
+                self._update_addon_info,
+                CONTAINER_INFO,
+                all_addons,
+                True,
+            ),
+        ):
+            container_data: dict[str, Any] = data.setdefault(data_key, {})
+
+            # Clean up cache
+            for slug in container_data.keys() - wanted_addons:
+                del container_data[slug]
+
+            # Update cache from API
+            container_data.update(
+                dict(
+                    await asyncio.gather(
+                        *[
+                            update_func(slug)
+                            for slug in wanted_addons
+                            if (first_update and needs_first_update)
+                            or enabled_key in container_updates[slug]
+                        ]
+                    )
+                )
+            )
+
+        # Refresh jobs data
+        await self.jobs.refresh_data(first_update)
+
+    async def _update_addon_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
+        """Update single addon stats."""
+        try:
+            stats = await self.supervisor_client.addons.addon_stats(slug)
+        except SupervisorError as err:
+            _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
+            return (slug, None)
+        return (slug, stats.to_dict())
+
+    async def _update_addon_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
+        """Return the info for an addon."""
+        try:
+            info = await self.supervisor_client.addons.addon_info(slug)
+        except SupervisorError as err:
+            _LOGGER.warning("Could not fetch info for %s: %s", slug, err)
+            return (slug, None)
+        # Translate to legacy hassio names for compatibility
+        info_dict = info.to_dict()
+        info_dict["hassio_api"] = info_dict.pop("supervisor_api")
+        info_dict["hassio_role"] = info_dict.pop("supervisor_role")
+        return (slug, info_dict)
+
+    @callback
+    def async_enable_container_updates(
+        self, slug: str, entity_id: str, types: set[str]
+    ) -> CALLBACK_TYPE:
+        """Enable updates for an add-on."""
+        enabled_updates = self._container_updates[slug]
+        for key in types:
+            enabled_updates[key].add(entity_id)
+
+        @callback
+        def _remove() -> None:
+            for key in types:
+                enabled_updates[key].remove(entity_id)
+
+        return _remove
+
    async def _async_refresh(
        self,
        log_failures: bool = True,
@@ -766,16 +616,14 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
    ) -> None:
        """Refresh data."""
        if not scheduled and not raise_on_auth_failed:
-            # Force reloading updates of main components for
-            # non-scheduled updates.
-            #
+            # Force refreshing updates for non-scheduled updates
            # If `raise_on_auth_failed` is set, it means this is
            # the first refresh and we do not want to delay
            # startup or cause a timeout so we only refresh the
            # updates if this is not a scheduled refresh and
            # we are not doing the first refresh.
            try:
-                await self.supervisor_client.reload_updates()
+                await self.supervisor_client.refresh_updates()
            except SupervisorError as err:
                _LOGGER.warning("Error on Supervisor API: %s", err)

@@ -783,6 +631,18 @@ class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
            log_failures, raise_on_auth_failed, scheduled, raise_on_entry_error
        )

+    async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
+        """Force refresh of addon info data for a specific addon."""
+        try:
+            slug, info = await self._update_addon_info(addon_slug)
+            if info is not None and DATA_KEY_ADDONS in self.data:
+                if slug in self.data[DATA_KEY_ADDONS]:
+                    data = deepcopy(self.data)
+                    data[DATA_KEY_ADDONS][slug].update(info)
+                    self.async_set_updated_data(data)
+        except SupervisorError as err:
+            _LOGGER.warning("Could not refresh info for %s: %s", addon_slug, err)
+
    @callback
    def unload(self) -> None:
        """Clean up when config entry unloaded."""
--- a/homeassistant/components/hassio/diagnostics.py
+++ b/homeassistant/components/hassio/diagnostics.py
@@ -11,12 +11,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er

-from .const import ADDONS_COORDINATOR, MAIN_COORDINATOR, STATS_COORDINATOR
-from .coordinator import (
-    HassioAddOnDataUpdateCoordinator,
-    HassioMainDataUpdateCoordinator,
-    HassioStatsDataUpdateCoordinator,
-)
+from .const import ADDONS_COORDINATOR
+from .coordinator import HassioDataUpdateCoordinator


 async def async_get_config_entry_diagnostics(
@@ -24,9 +20,7 @@ async def async_get_config_entry_diagnostics(
    config_entry: ConfigEntry,
 ) -> dict[str, Any]:
    """Return diagnostics for a config entry."""
-    coordinator: HassioMainDataUpdateCoordinator = hass.data[MAIN_COORDINATOR]
-    addons_coordinator: HassioAddOnDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
-    stats_coordinator: HassioStatsDataUpdateCoordinator = hass.data[STATS_COORDINATOR]
+    coordinator: HassioDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
    device_registry = dr.async_get(hass)
    entity_registry = er.async_get(hass)

@@ -59,7 +53,5 @@ async def async_get_config_entry_diagnostics(

    return {
        "coordinator_data": coordinator.data,
-        "addons_coordinator_data": addons_coordinator.data,
-        "stats_coordinator_data": stats_coordinator.data,
        "devices": devices,
    }
--- a/homeassistant/components/hassio/entity.py
+++ b/homeassistant/components/hassio/entity.py
@@ -13,6 +13,7 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from .const import (
    ATTR_SLUG,
    CONTAINER_STATS,
+    CORE_CONTAINER,
    DATA_KEY_ADDONS,
    DATA_KEY_CORE,
    DATA_KEY_HOST,
@@ -20,79 +21,20 @@ from .const import (
    DATA_KEY_OS,
    DATA_KEY_SUPERVISOR,
    DOMAIN,
+    KEY_TO_UPDATE_TYPES,
+    SUPERVISOR_CONTAINER,
 )
-from .coordinator import (
-    HassioAddOnDataUpdateCoordinator,
-    HassioMainDataUpdateCoordinator,
-    HassioStatsDataUpdateCoordinator,
-)
+from .coordinator import HassioDataUpdateCoordinator


-class HassioStatsEntity(CoordinatorEntity[HassioStatsDataUpdateCoordinator]):
-    """Base entity for container stats (CPU, memory)."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: HassioStatsDataUpdateCoordinator,
-        entity_description: EntityDescription,
-        *,
-        container_id: str,
-        data_key: str,
-        device_id: str,
-        unique_id_prefix: str,
-    ) -> None:
-        """Initialize base entity."""
-        super().__init__(coordinator)
-        self.entity_description = entity_description
-        self._container_id = container_id
-        self._data_key = data_key
-        self._attr_unique_id = f"{unique_id_prefix}_{entity_description.key}"
-        self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, device_id)})
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        if self._data_key == DATA_KEY_ADDONS:
-            return (
-                super().available
-                and DATA_KEY_ADDONS in self.coordinator.data
-                and self.entity_description.key
-                in (
-                    self.coordinator.data[DATA_KEY_ADDONS].get(self._container_id) or {}
-                )
-            )
-        return (
-            super().available
-            and self._data_key in self.coordinator.data
-            and self.entity_description.key in self.coordinator.data[self._data_key]
-        )
-
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to stats updates."""
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self.coordinator.async_enable_container_updates(
-                self._container_id, self.entity_id, {CONTAINER_STATS}
-            )
-        )
-        # Stats are only fetched for containers with subscribed entities.
-        # The first coordinator refresh (before entities exist) has no
-        # subscribers, so no stats are fetched. Schedule a debounced
-        # refresh so that all stats entities registering during platform
-        # setup are batched into a single API call.
-        await self.coordinator.async_request_refresh()
-
-
-class HassioAddonEntity(CoordinatorEntity[HassioAddOnDataUpdateCoordinator]):
+class HassioAddonEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
    """Base entity for a Hass.io add-on."""

    _attr_has_entity_name = True

    def __init__(
        self,
-        coordinator: HassioAddOnDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
        entity_description: EntityDescription,
        addon: dict[str, Any],
    ) -> None:
@@ -114,23 +56,26 @@ class HassioAddonEntity(CoordinatorEntity[HassioAddOnDataUpdateCoordinator]):
        )

    async def async_added_to_hass(self) -> None:
-        """Subscribe to addon info updates."""
+        """Subscribe to updates."""
        await super().async_added_to_hass()
+        update_types = KEY_TO_UPDATE_TYPES[self.entity_description.key]
        self.async_on_remove(
-            self.coordinator.async_enable_addon_info_updates(
-                self._addon_slug, self.entity_id
+            self.coordinator.async_enable_container_updates(
+                self._addon_slug, self.entity_id, update_types
            )
        )
+        if CONTAINER_STATS in update_types:
+            await self.coordinator.async_request_refresh()


-class HassioOSEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+class HassioOSEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
    """Base Entity for Hass.io OS."""

    _attr_has_entity_name = True

    def __init__(
        self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
        entity_description: EntityDescription,
    ) -> None:
        """Initialize base entity."""
@@ -149,14 +94,14 @@ class HassioOSEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
        )


-class HassioHostEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+class HassioHostEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
    """Base Entity for Hass.io host."""

    _attr_has_entity_name = True

    def __init__(
        self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
        entity_description: EntityDescription,
    ) -> None:
        """Initialize base entity."""
@@ -175,14 +120,14 @@ class HassioHostEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
        )


-class HassioSupervisorEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+class HassioSupervisorEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
    """Base Entity for Supervisor."""

    _attr_has_entity_name = True

    def __init__(
        self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
        entity_description: EntityDescription,
    ) -> None:
        """Initialize base entity."""
@@ -201,15 +146,27 @@ class HassioSupervisorEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator])
            in self.coordinator.data[DATA_KEY_SUPERVISOR]
        )

+    async def async_added_to_hass(self) -> None:
+        """Subscribe to updates."""
+        await super().async_added_to_hass()
+        update_types = KEY_TO_UPDATE_TYPES[self.entity_description.key]
+        self.async_on_remove(
+            self.coordinator.async_enable_container_updates(
+                SUPERVISOR_CONTAINER, self.entity_id, update_types
+            )
+        )
+        if CONTAINER_STATS in update_types:
+            await self.coordinator.async_request_refresh()

-class HassioCoreEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+
+class HassioCoreEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
    """Base Entity for Core."""

    _attr_has_entity_name = True

    def __init__(
        self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
        entity_description: EntityDescription,
    ) -> None:
        """Initialize base entity."""
@@ -227,15 +184,27 @@ class HassioCoreEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
            and self.entity_description.key in self.coordinator.data[DATA_KEY_CORE]
        )

+    async def async_added_to_hass(self) -> None:
+        """Subscribe to updates."""
+        await super().async_added_to_hass()
+        update_types = KEY_TO_UPDATE_TYPES[self.entity_description.key]
+        self.async_on_remove(
+            self.coordinator.async_enable_container_updates(
+                CORE_CONTAINER, self.entity_id, update_types
+            )
+        )
+        if CONTAINER_STATS in update_types:
+            await self.coordinator.async_request_refresh()

-class HassioMountEntity(CoordinatorEntity[HassioMainDataUpdateCoordinator]):
+
+class HassioMountEntity(CoordinatorEntity[HassioDataUpdateCoordinator]):
    """Base Entity for Mount."""

    _attr_has_entity_name = True

    def __init__(
        self,
-        coordinator: HassioMainDataUpdateCoordinator,
+        coordinator: HassioDataUpdateCoordinator,
        entity_description: EntityDescription,
        mount: CIFSMountResponse | NFSMountResponse,
    ) -> None:
--- a/homeassistant/components/hassio/issues.py
+++ b/homeassistant/components/hassio/issues.py
@@ -28,6 +28,7 @@ from homeassistant.helpers.issue_registry import (
 )

 from .const import (
+    ADDONS_COORDINATOR,
    ATTR_DATA,
    ATTR_HEALTHY,
    ATTR_SLUG,
@@ -53,7 +54,6 @@ from .const import (
    ISSUE_KEY_SYSTEM_DOCKER_CONFIG,
    ISSUE_KEY_SYSTEM_FREE_SPACE,
    ISSUE_MOUNT_MOUNT_FAILED,
-    MAIN_COORDINATOR,
    PLACEHOLDER_KEY_ADDON,
    PLACEHOLDER_KEY_ADDON_URL,
    PLACEHOLDER_KEY_FREE_SPACE,
@@ -62,7 +62,7 @@ from .const import (
    STARTUP_COMPLETE,
    UPDATE_KEY_SUPERVISOR,
 )
-from .coordinator import HassioMainDataUpdateCoordinator, get_addons_list, get_host_info
+from .coordinator import HassioDataUpdateCoordinator, get_addons_list, get_host_info
 from .handler import get_supervisor_client

 ISSUE_KEY_UNHEALTHY = "unhealthy"
@@ -417,8 +417,8 @@ class SupervisorIssues:

    def _async_coordinator_refresh(self) -> None:
        """Refresh coordinator to update latest data in entities."""
-        coordinator: HassioMainDataUpdateCoordinator | None
-        if coordinator := self._hass.data.get(MAIN_COORDINATOR):
+        coordinator: HassioDataUpdateCoordinator | None
+        if coordinator := self._hass.data.get(ADDONS_COORDINATOR):
            coordinator.config_entry.async_create_task(
                self._hass, coordinator.async_refresh()
            )
--- a/homeassistant/components/hassio/sensor.py
+++ b/homeassistant/components/hassio/sensor.py
@@ -17,24 +17,20 @@ from .const import (
    ADDONS_COORDINATOR,
    ATTR_CPU_PERCENT,
    ATTR_MEMORY_PERCENT,
-    ATTR_SLUG,
    ATTR_VERSION,
    ATTR_VERSION_LATEST,
-    CORE_CONTAINER,
    DATA_KEY_ADDONS,
    DATA_KEY_CORE,
    DATA_KEY_HOST,
    DATA_KEY_OS,
    DATA_KEY_SUPERVISOR,
-    MAIN_COORDINATOR,
-    STATS_COORDINATOR,
-    SUPERVISOR_CONTAINER,
 )
 from .entity import (
    HassioAddonEntity,
+    HassioCoreEntity,
    HassioHostEntity,
    HassioOSEntity,
-    HassioStatsEntity,
+    HassioSupervisorEntity,
 )

 COMMON_ENTITY_DESCRIPTIONS = (
@@ -67,7 +63,10 @@ STATS_ENTITY_DESCRIPTIONS = (
    ),
 )

+ADDON_ENTITY_DESCRIPTIONS = COMMON_ENTITY_DESCRIPTIONS + STATS_ENTITY_DESCRIPTIONS
+CORE_ENTITY_DESCRIPTIONS = STATS_ENTITY_DESCRIPTIONS
 OS_ENTITY_DESCRIPTIONS = COMMON_ENTITY_DESCRIPTIONS
+SUPERVISOR_ENTITY_DESCRIPTIONS = STATS_ENTITY_DESCRIPTIONS

 HOST_ENTITY_DESCRIPTIONS = (
    SensorEntityDescription(
@@ -115,64 +114,36 @@ async def async_setup_entry(
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
    """Sensor set up for Hass.io config entry."""
-    addons_coordinator = hass.data[ADDONS_COORDINATOR]
-    coordinator = hass.data[MAIN_COORDINATOR]
-    stats_coordinator = hass.data[STATS_COORDINATOR]
+    coordinator = hass.data[ADDONS_COORDINATOR]

-    entities: list[SensorEntity] = []
-
-    # Add-on non-stats sensors (version, version_latest)
-    entities.extend(
+    entities: list[
+        HassioOSSensor | HassioAddonSensor | CoreSensor | SupervisorSensor | HostSensor
+    ] = [
        HassioAddonSensor(
            addon=addon,
-            coordinator=addons_coordinator,
+            coordinator=coordinator,
            entity_description=entity_description,
        )
-        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
-        for entity_description in COMMON_ENTITY_DESCRIPTIONS
-    )
+        for addon in coordinator.data[DATA_KEY_ADDONS].values()
+        for entity_description in ADDON_ENTITY_DESCRIPTIONS
+    ]

-    # Add-on stats sensors (cpu_percent, memory_percent)
    entities.extend(
-        HassioStatsSensor(
-            coordinator=stats_coordinator,
+        CoreSensor(
+            coordinator=coordinator,
            entity_description=entity_description,
-            container_id=addon[ATTR_SLUG],
-            data_key=DATA_KEY_ADDONS,
-            device_id=addon[ATTR_SLUG],
-            unique_id_prefix=addon[ATTR_SLUG],
        )
-        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
-        for entity_description in STATS_ENTITY_DESCRIPTIONS
+        for entity_description in CORE_ENTITY_DESCRIPTIONS
    )

-    # Core stats sensors
    entities.extend(
-        HassioStatsSensor(
-            coordinator=stats_coordinator,
+        SupervisorSensor(
+            coordinator=coordinator,
            entity_description=entity_description,
-            container_id=CORE_CONTAINER,
-            data_key=DATA_KEY_CORE,
-            device_id="core",
-            unique_id_prefix="home_assistant_core",
        )
-        for entity_description in STATS_ENTITY_DESCRIPTIONS
+        for entity_description in SUPERVISOR_ENTITY_DESCRIPTIONS
    )

-    # Supervisor stats sensors
-    entities.extend(
-        HassioStatsSensor(
-            coordinator=stats_coordinator,
-            entity_description=entity_description,
-            container_id=SUPERVISOR_CONTAINER,
-            data_key=DATA_KEY_SUPERVISOR,
-            device_id="supervisor",
-            unique_id_prefix="home_assistant_supervisor",
-        )
-        for entity_description in STATS_ENTITY_DESCRIPTIONS
-    )
-
-    # Host sensors
    entities.extend(
        HostSensor(
            coordinator=coordinator,
@@ -181,7 +152,6 @@ async def async_setup_entry(
        for entity_description in HOST_ENTITY_DESCRIPTIONS
    )

-    # OS sensors
    if coordinator.is_hass_os:
        entities.extend(
            HassioOSSensor(
@@ -205,21 +175,8 @@ class HassioAddonSensor(HassioAddonEntity, SensorEntity):
        ]


-class HassioStatsSensor(HassioStatsEntity, SensorEntity):
-    """Sensor to track container stats."""
-
-    @property
-    def native_value(self) -> str:
-        """Return native value of entity."""
-        if self._data_key == DATA_KEY_ADDONS:
-            return self.coordinator.data[DATA_KEY_ADDONS][self._container_id][
-                self.entity_description.key
-            ]
-        return self.coordinator.data[self._data_key][self.entity_description.key]
-
-
 class HassioOSSensor(HassioOSEntity, SensorEntity):
-    """Sensor to track a Hass.io OS attribute."""
+    """Sensor to track a Hass.io add-on attribute."""

    @property
    def native_value(self) -> str:
@@ -227,6 +184,24 @@ class HassioOSSensor(HassioOSEntity, SensorEntity):
        return self.coordinator.data[DATA_KEY_OS][self.entity_description.key]


+class CoreSensor(HassioCoreEntity, SensorEntity):
+    """Sensor to track a core attribute."""
+
+    @property
+    def native_value(self) -> str:
+        """Return native value of entity."""
+        return self.coordinator.data[DATA_KEY_CORE][self.entity_description.key]
+
+
+class SupervisorSensor(HassioSupervisorEntity, SensorEntity):
+    """Sensor to track a supervisor attribute."""
+
+    @property
+    def native_value(self) -> str:
+        """Return native value of entity."""
+        return self.coordinator.data[DATA_KEY_SUPERVISOR][self.entity_description.key]
+
+
 class HostSensor(HassioHostEntity, SensorEntity):
    """Sensor to track a host attribute."""

--- a/homeassistant/components/hassio/services.py
+++ b/homeassistant/components/hassio/services.py
@@ -32,6 +32,7 @@ from homeassistant.helpers import (
 from homeassistant.util.dt import now

 from .const import (
+    ADDONS_COORDINATOR,
    ATTR_ADDON,
    ATTR_ADDONS,
    ATTR_APP,
@@ -45,10 +46,9 @@ from .const import (
    ATTR_PASSWORD,
    ATTR_SLUG,
    DOMAIN,
-    MAIN_COORDINATOR,
    SupervisorEntityModel,
 )
-from .coordinator import HassioMainDataUpdateCoordinator, get_addons_info
+from .coordinator import HassioDataUpdateCoordinator, get_addons_info

 SERVICE_ADDON_START = "addon_start"
 SERVICE_ADDON_STOP = "addon_stop"
@@ -406,7 +406,7 @@ def async_register_network_storage_services(

    async def async_mount_reload(service: ServiceCall) -> None:
        """Handle service calls for Hass.io."""
-        coordinator: HassioMainDataUpdateCoordinator | None = None
+        coordinator: HassioDataUpdateCoordinator | None = None

        if (device := dev_reg.async_get(service.data[ATTR_DEVICE_ID])) is None:
            raise ServiceValidationError(
@@ -417,7 +417,7 @@ def async_register_network_storage_services(
        if (
            device.name is None
            or device.model != SupervisorEntityModel.MOUNT
-            or (coordinator := hass.data.get(MAIN_COORDINATOR)) is None
+            or (coordinator := hass.data.get(ADDONS_COORDINATOR)) is None
            or coordinator.entry_id not in device.config_entries
        ):
            raise ServiceValidationError(
--- a/homeassistant/components/hassio/update.py
+++ b/homeassistant/components/hassio/update.py
@@ -29,7 +29,6 @@ from .const import (
    DATA_KEY_CORE,
    DATA_KEY_OS,
    DATA_KEY_SUPERVISOR,
-    MAIN_COORDINATOR,
 )
 from .entity import (
    HassioAddonEntity,
@@ -52,9 +51,9 @@ async def async_setup_entry(
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
    """Set up Supervisor update based on a config entry."""
-    coordinator = hass.data[MAIN_COORDINATOR]
+    coordinator = hass.data[ADDONS_COORDINATOR]

-    entities: list[UpdateEntity] = [
+    entities = [
        SupervisorSupervisorUpdateEntity(
            coordinator=coordinator,
            entity_description=ENTITY_DESCRIPTION,
@@ -65,6 +64,15 @@ async def async_setup_entry(
        ),
    ]

+    entities.extend(
+        SupervisorAddonUpdateEntity(
+            addon=addon,
+            coordinator=coordinator,
+            entity_description=ENTITY_DESCRIPTION,
+        )
+        for addon in coordinator.data[DATA_KEY_ADDONS].values()
+    )
+
    if coordinator.is_hass_os:
        entities.append(
            SupervisorOSUpdateEntity(
@@ -73,16 +81,6 @@ async def async_setup_entry(
            )
        )

-    addons_coordinator = hass.data[ADDONS_COORDINATOR]
-    entities.extend(
-        SupervisorAddonUpdateEntity(
-            addon=addon,
-            coordinator=addons_coordinator,
-            entity_description=ENTITY_DESCRIPTION,
-        )
-        for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
-    )
-
    async_add_entities(entities)


--- a/homeassistant/components/hdmi_cec/entity.py
+++ b/homeassistant/components/hdmi_cec/entity.py
@@ -4,7 +4,6 @@ from __future__ import annotations

 from typing import Any

-from homeassistant.core import callback
 from homeassistant.helpers.entity import Entity

 from .const import DOMAIN, EVENT_HDMI_CEC_UNAVAILABLE
@@ -56,10 +55,9 @@ class CecEntity(Entity):
        else:
            self._attr_name = f"{self._device.type_name} {self._logical_address} ({self._device.osd_name})"

-    @callback
    def _hdmi_cec_unavailable(self, callback_event):
        self._attr_available = False
-        self.async_write_ha_state()
+        self.schedule_update_ha_state(False)

    async def async_added_to_hass(self) -> None:
        """Register HDMI callbacks after initialization."""
--- a/homeassistant/components/hdmi_cec/media_player.py
+++ b/homeassistant/components/hdmi_cec/media_player.py
@@ -3,6 +3,7 @@
 from __future__ import annotations

 import logging
+from typing import Any

 from pycec.commands import CecCommand, KeyPressCommand, KeyReleaseCommand
 from pycec.const import (
@@ -30,6 +31,7 @@ from homeassistant.components.media_player import (
    MediaPlayerEntity,
    MediaPlayerEntityFeature,
    MediaPlayerState,
+    MediaType,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -43,20 +45,20 @@ _LOGGER = logging.getLogger(__name__)
 ENTITY_ID_FORMAT = MP_DOMAIN + ".{}"


-async def async_setup_platform(
+def setup_platform(
    hass: HomeAssistant,
    config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
+    add_entities: AddEntitiesCallback,
    discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Find and return HDMI devices as media players."""
+    """Find and return HDMI devices as +switches."""
    if discovery_info and ATTR_NEW in discovery_info:
        _LOGGER.debug("Setting up HDMI devices %s", discovery_info[ATTR_NEW])
        entities = []
        for device in discovery_info[ATTR_NEW]:
            hdmi_device = hass.data[DOMAIN][device]
            entities.append(CecPlayerEntity(hdmi_device, hdmi_device.logical_address))
-        async_add_entities(entities, True)
+        add_entities(entities, True)


 class CecPlayerEntity(CecEntity, MediaPlayerEntity):
@@ -77,61 +79,78 @@ class CecPlayerEntity(CecEntity, MediaPlayerEntity):

    def send_playback(self, key):
        """Send playback status to CEC adapter."""
-        self._device.send_command(CecCommand(key, dst=self._logical_address))
+        self._device.async_send_command(CecCommand(key, dst=self._logical_address))

-    async def async_mute_volume(self, mute: bool) -> None:
+    def mute_volume(self, mute: bool) -> None:
        """Mute volume."""
        self.send_keypress(KEY_MUTE_TOGGLE)

-    async def async_media_previous_track(self) -> None:
+    def media_previous_track(self) -> None:
        """Go to previous track."""
        self.send_keypress(KEY_BACKWARD)

-    async def async_turn_on(self) -> None:
+    def turn_on(self) -> None:
        """Turn device on."""
        self._device.turn_on()
        self._attr_state = MediaPlayerState.ON
-        self.async_write_ha_state()

-    async def async_turn_off(self) -> None:
+    def clear_playlist(self) -> None:
+        """Clear players playlist."""
+        raise NotImplementedError
+
+    def turn_off(self) -> None:
        """Turn device off."""
        self._device.turn_off()
        self._attr_state = MediaPlayerState.OFF
-        self.async_write_ha_state()

-    async def async_media_stop(self) -> None:
+    def media_stop(self) -> None:
        """Stop playback."""
        self.send_keypress(KEY_STOP)
        self._attr_state = MediaPlayerState.IDLE
-        self.async_write_ha_state()

-    async def async_media_next_track(self) -> None:
+    def play_media(
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
+    ) -> None:
+        """Not supported."""
+        raise NotImplementedError
+
+    def media_next_track(self) -> None:
        """Skip to next track."""
        self.send_keypress(KEY_FORWARD)

-    async def async_media_pause(self) -> None:
+    def media_seek(self, position: float) -> None:
+        """Not supported."""
+        raise NotImplementedError
+
+    def set_volume_level(self, volume: float) -> None:
+        """Set volume level, range 0..1."""
+        raise NotImplementedError
+
+    def media_pause(self) -> None:
        """Pause playback."""
        self.send_keypress(KEY_PAUSE)
        self._attr_state = MediaPlayerState.PAUSED
-        self.async_write_ha_state()

-    async def async_media_play(self) -> None:
+    def select_source(self, source: str) -> None:
+        """Not supported."""
+        raise NotImplementedError
+
+    def media_play(self) -> None:
        """Start playback."""
        self.send_keypress(KEY_PLAY)
        self._attr_state = MediaPlayerState.PLAYING
-        self.async_write_ha_state()

-    async def async_volume_up(self) -> None:
+    def volume_up(self) -> None:
        """Increase volume."""
        _LOGGER.debug("%s: volume up", self._logical_address)
        self.send_keypress(KEY_VOLUME_UP)

-    async def async_volume_down(self) -> None:
+    def volume_down(self) -> None:
        """Decrease volume."""
        _LOGGER.debug("%s: volume down", self._logical_address)
        self.send_keypress(KEY_VOLUME_DOWN)

-    async def async_update(self) -> None:
+    def update(self) -> None:
        """Update device status."""
        device = self._device
        if device.power_status in [POWER_OFF, 3]:
--- a/homeassistant/components/hdmi_cec/switch.py
+++ b/homeassistant/components/hdmi_cec/switch.py
@@ -20,10 +20,10 @@ _LOGGER = logging.getLogger(__name__)
 ENTITY_ID_FORMAT = SWITCH_DOMAIN + ".{}"


-async def async_setup_platform(
+def setup_platform(
    hass: HomeAssistant,
    config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
+    add_entities: AddEntitiesCallback,
    discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
    """Find and return HDMI devices as switches."""
@@ -33,7 +33,7 @@ async def async_setup_platform(
        for device in discovery_info[ATTR_NEW]:
            hdmi_device = hass.data[DOMAIN][device]
            entities.append(CecSwitchEntity(hdmi_device, hdmi_device.logical_address))
-        async_add_entities(entities, True)
+        add_entities(entities, True)


 class CecSwitchEntity(CecEntity, SwitchEntity):
@@ -44,19 +44,19 @@ class CecSwitchEntity(CecEntity, SwitchEntity):
        CecEntity.__init__(self, device, logical)
        self.entity_id = f"{SWITCH_DOMAIN}.hdmi_{hex(self._logical_address)[2:]}"

-    async def async_turn_on(self, **kwargs: Any) -> None:
+    def turn_on(self, **kwargs: Any) -> None:
        """Turn device on."""
        self._device.turn_on()
        self._attr_is_on = True
-        self.async_write_ha_state()
+        self.schedule_update_ha_state(force_refresh=False)

-    async def async_turn_off(self, **kwargs: Any) -> None:
+    def turn_off(self, **kwargs: Any) -> None:
        """Turn device off."""
        self._device.turn_off()
        self._attr_is_on = False
-        self.async_write_ha_state()
+        self.schedule_update_ha_state(force_refresh=False)

-    async def async_update(self) -> None:
+    def update(self) -> None:
        """Update device status."""
        device = self._device
        if device.power_status in {POWER_OFF, 3}:
--- a/homeassistant/components/homeassistant/strings.json
+++ b/homeassistant/components/homeassistant/strings.json
@@ -148,7 +148,7 @@
        },
        "step": {
          "init": {
-            "description": "The integration `{domain}` could not be found. This happens when a (custom) integration was removed from Home Assistant, but there are still configurations for this `integration`. Please use the buttons below to either remove the previous configurations for `{domain}` or ignore this.",
+            "description": "The integration `{domain}` could not be found. This happens when a (community) integration was removed from Home Assistant, but there are still configurations for this `integration`. Please use the buttons below to either remove the previous configurations for `{domain}` or ignore this.",
            "menu_options": {
              "confirm": "Remove previous configurations",
              "ignore": "Ignore"
@@ -236,7 +236,7 @@
      "description": "Restarts Home Assistant.",
      "fields": {
        "safe_mode": {
-          "description": "Disable custom integrations and custom cards.",
+          "description": "Disable community integrations and community cards.",
          "name": "Safe mode"
        }
      },
--- a/homeassistant/components/homeassistant_hardware/manifest.json
+++ b/homeassistant/components/homeassistant_hardware/manifest.json
@@ -7,7 +7,7 @@
  "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
  "integration_type": "system",
  "requirements": [
-    "serialx==1.2.2",
+    "serialx==1.1.1",
    "universal-silabs-flasher==1.0.3",
    "ha-silabs-firmware-client==0.3.0"
  ]
--- a/homeassistant/components/homekit/manifest.json
+++ b/homeassistant/components/homekit/manifest.json
@@ -10,7 +10,7 @@
  "loggers": ["pyhap"],
  "requirements": [
    "HAP-python==5.0.0",
-    "fnv-hash-fast==2.0.2",
+    "fnv-hash-fast==2.0.0",
    "homekit-audio-proxy==1.2.1",
    "PyQRCode==1.2.1",
    "base36==0.1.1"
--- a/homeassistant/components/homekit/util.py
+++ b/homeassistant/components/homekit/util.py
@@ -625,13 +625,10 @@ def _get_test_socket() -> socket.socket:
@callback
 def async_port_is_available(port: int) -> bool:
    """Check to see if a port is available."""
-    test_socket = _get_test_socket()
    try:
-        test_socket.bind(("", port))
+        _get_test_socket().bind(("", port))
    except OSError:
        return False
-    finally:
-        test_socket.close()
    return True


--- a/homeassistant/components/homematicip_cloud/manifest.json
+++ b/homeassistant/components/homematicip_cloud/manifest.json
@@ -7,5 +7,5 @@
  "integration_type": "hub",
  "iot_class": "cloud_push",
  "loggers": ["homematicip"],
-  "requirements": ["homematicip==2.8.0"]
+  "requirements": ["homematicip==2.7.0"]
 }
--- a/homeassistant/components/husqvarna_automower_ble/manifest.json
+++ b/homeassistant/components/husqvarna_automower_ble/manifest.json
@@ -13,5 +13,5 @@
  "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
  "integration_type": "device",
  "iot_class": "local_polling",
-  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.4.0"]
+  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.3.0"]
 }
--- a/homeassistant/components/iaqualink/binary_sensor.py
+++ b/homeassistant/components/iaqualink/binary_sensor.py
@@ -42,6 +42,7 @@ class HassAqualinkBinarySensor(
    ) -> None:
        """Initialize AquaLink binary sensor."""
        super().__init__(coordinator, dev)
+        self._attr_name = dev.label
        if dev.label == "Freeze Protection":
            self._attr_device_class = BinarySensorDeviceClass.COLD

--- a/homeassistant/components/iaqualink/climate.py
+++ b/homeassistant/components/iaqualink/climate.py
@@ -57,6 +57,7 @@ class HassAqualinkThermostat(AqualinkEntity[AqualinkThermostat], ClimateEntity):
    ) -> None:
        """Initialize AquaLink thermostat."""
        super().__init__(coordinator, dev)
+        self._attr_name = dev.label.split(" ")[0]
        self._attr_temperature_unit = (
            UnitOfTemperature.FAHRENHEIT
            if dev.unit == "F"
--- a/homeassistant/components/iaqualink/entity.py
+++ b/homeassistant/components/iaqualink/entity.py
@@ -22,9 +22,6 @@ class AqualinkEntity[AqualinkDeviceT: AqualinkDevice](
    entity update flow.
    """

-    _attr_has_entity_name = True
-    _attr_name = None
-
    def __init__(
        self, coordinator: AqualinkDataUpdateCoordinator, dev: AqualinkDeviceT
    ) -> None:
--- a/homeassistant/components/iaqualink/light.py
+++ b/homeassistant/components/iaqualink/light.py
@@ -46,6 +46,7 @@ class HassAqualinkLight(AqualinkEntity[AqualinkLight], LightEntity):
    ) -> None:
        """Initialize AquaLink light."""
        super().__init__(coordinator, dev)
+        self._attr_name = dev.label
        if dev.supports_effect:
            self._attr_effect_list = list(dev.supported_effects)
            self._attr_supported_features = LightEntityFeature.EFFECT
--- a/homeassistant/components/iaqualink/sensor.py
+++ b/homeassistant/components/iaqualink/sensor.py
@@ -38,6 +38,7 @@ class HassAqualinkSensor(AqualinkEntity[AqualinkSensor], SensorEntity):
    ) -> None:
        """Initialize AquaLink sensor."""
        super().__init__(coordinator, dev)
+        self._attr_name = dev.label
        if not dev.name.endswith("_temp"):
            return
        self._attr_device_class = SensorDeviceClass.TEMPERATURE
--- a/homeassistant/components/iaqualink/switch.py
+++ b/homeassistant/components/iaqualink/switch.py
@@ -40,7 +40,7 @@ class HassAqualinkSwitch(AqualinkEntity[AqualinkSwitch], SwitchEntity):
    ) -> None:
        """Initialize AquaLink switch."""
        super().__init__(coordinator, dev)
-        name = dev.label
+        name = self._attr_name = dev.label
        if name == "Cleaner":
            self._attr_icon = "mdi:robot-vacuum"
        elif name == "Waterfall" or name.endswith("Dscnt"):
--- a/homeassistant/components/image_upload/manifest.json
+++ b/homeassistant/components/image_upload/manifest.json
@@ -7,5 +7,5 @@
  "documentation": "https://www.home-assistant.io/integrations/image_upload",
  "integration_type": "system",
  "quality_scale": "internal",
-  "requirements": ["Pillow==12.2.0"]
+  "requirements": ["Pillow==12.1.1"]
 }
--- a/homeassistant/components/jellyfin/media_player.py
+++ b/homeassistant/components/jellyfin/media_player.py
@@ -57,6 +57,8 @@ async def async_setup_entry(
 class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
    """Represents a Jellyfin Player device."""

+    _attr_media_image_remotely_accessible = False
+
    def __init__(
        self,
        coordinator: JellyfinDataUpdateCoordinator,
--- a/homeassistant/components/keyboard_remote/manifest.json
+++ b/homeassistant/components/keyboard_remote/manifest.json
@@ -7,5 +7,5 @@
  "iot_class": "local_push",
  "loggers": ["aionotify", "evdev"],
  "quality_scale": "legacy",
-  "requirements": ["evdev==1.9.3", "asyncinotify==4.4.4"]
+  "requirements": ["evdev==1.9.3", "asyncinotify==4.4.0"]
 }
--- a/homeassistant/components/litterrobot/manifest.json
+++ b/homeassistant/components/litterrobot/manifest.json
@@ -16,5 +16,5 @@
  "iot_class": "cloud_push",
  "loggers": ["pylitterbot"],
  "quality_scale": "platinum",
-  "requirements": ["pylitterbot==2025.3.2"]
+  "requirements": ["pylitterbot==2025.2.1"]
 }
--- a/homeassistant/components/logbook/helpers.py
+++ b/homeassistant/components/logbook/helpers.py
@@ -11,9 +11,7 @@ from homeassistant.const import (
    ATTR_DEVICE_ID,
    ATTR_DOMAIN,
    ATTR_ENTITY_ID,
-    ATTR_SERVICE_DATA,
    ATTR_UNIT_OF_MEASUREMENT,
-    EVENT_CALL_SERVICE,
    EVENT_LOGBOOK_ENTRY,
    EVENT_STATE_CHANGED,
 )
@@ -106,22 +104,10 @@ def async_determine_event_types(


@callback
-def extract_attr(
-    event_type: EventType[Any] | str, source: Mapping[str, Any], attr: str
-) -> list[str]:
-    """Extract an attribute as a list or string.
-
-    For EVENT_CALL_SERVICE events, the entity_id is inside service_data,
-    not at the top level. Check service_data as a fallback.
-    """
+def extract_attr(source: Mapping[str, Any], attr: str) -> list[str]:
+    """Extract an attribute as a list or string."""
    if (value := source.get(attr)) is None:
-        # Early return to avoid unnecessary dict lookups for non-service events
-        if event_type != EVENT_CALL_SERVICE:
-            return []
-        if service_data := source.get(ATTR_SERVICE_DATA):
-            value = service_data.get(attr)
-        if value is None:
-            return []
+        return []
    if isinstance(value, list):
        return value
    return str(value).split(",")
@@ -149,7 +135,7 @@ def event_forwarder_filtered(
        def _forward_events_filtered_by_entities_filter(event: Event) -> None:
            assert entities_filter is not None
            event_data = event.data
-            entity_ids = extract_attr(event.event_type, event_data, ATTR_ENTITY_ID)
+            entity_ids = extract_attr(event_data, ATTR_ENTITY_ID)
            if entity_ids and not any(
                entities_filter(entity_id) for entity_id in entity_ids
            ):
@@ -171,12 +157,9 @@ def event_forwarder_filtered(
    @callback
    def _forward_events_filtered_by_device_entity_ids(event: Event) -> None:
        event_data = event.data
-        event_type = event.event_type
        if entity_ids_set.intersection(
-            extract_attr(event_type, event_data, ATTR_ENTITY_ID)
-        ) or device_ids_set.intersection(
-            extract_attr(event_type, event_data, ATTR_DEVICE_ID)
-        ):
+            extract_attr(event_data, ATTR_ENTITY_ID)
+        ) or device_ids_set.intersection(extract_attr(event_data, ATTR_DEVICE_ID)):
            target(event)

    return _forward_events_filtered_by_device_entity_ids
--- a/homeassistant/components/logbook/models.py
+++ b/homeassistant/components/logbook/models.py
@@ -162,10 +162,7 @@ def async_event_to_row(event: Event) -> EventAsRow:
    # that are missing new_state or old_state
    # since the logbook does not show these
    new_state: State = event.data["new_state"]
-    # Use the event's context rather than the state's context because
-    # State.expire() replaces the context with a copy that loses
-    # origin_event, which is needed for context augmentation.
-    context = event.context
+    context = new_state.context
    return EventAsRow(
        row_id=hash(event),
        event_type=None,
--- a/homeassistant/components/logbook/processor.py
+++ b/homeassistant/components/logbook/processor.py
@@ -3,16 +3,14 @@
 from __future__ import annotations

 from collections.abc import Callable, Generator, Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime as dt
 import logging
 import time
 from typing import TYPE_CHECKING, Any

-from lru import LRU
 from sqlalchemy.engine import Result
 from sqlalchemy.engine.row import Row
-from sqlalchemy.orm import Session

 from homeassistant.components.recorder import get_instance
 from homeassistant.components.recorder.filters import Filters
@@ -39,7 +37,6 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant, split_entity_id
 from homeassistant.helpers import entity_registry as er
 from homeassistant.util import dt as dt_util
-from homeassistant.util.collection import chunked_or_all
 from homeassistant.util.event_type import EventType

 from .const import (
@@ -83,18 +80,10 @@ from .models import (
    async_event_to_row,
 )
 from .queries import statement_for_request
-from .queries.common import (
-    PSEUDO_EVENT_STATE_CHANGED,
-    select_context_user_ids_for_context_ids,
-)
+from .queries.common import PSEUDO_EVENT_STATE_CHANGED

 _LOGGER = logging.getLogger(__name__)

-# Bound for the parent-context user-id cache — only needs to bridge the
-# historical→live handoff, so the in-flight set is realistically ~tens with
-# peak bursts of ~100. Ceiling bounds memory in pathological cases.
-MAX_CONTEXT_USER_IDS_CACHE = 256
-

@dataclass(slots=True)
 class LogbookRun:
@@ -110,14 +99,6 @@ class LogbookRun:
    include_entity_name: bool
    timestamp: bool
    memoize_new_contexts: bool = True
-    # True when this run will switch to a live stream; gates population of
-    # context_user_ids (wasted work for one-shot REST/get_events callers).
-    for_live_stream: bool = False
-    # context_id -> user_id for parent context attribution; persisted across
-    # batches so child rows can inherit user_id from a parent seen earlier.
-    context_user_ids: LRU[bytes, bytes] = field(
-        default_factory=lambda: LRU(MAX_CONTEXT_USER_IDS_CACHE)
-    )


 class EventProcessor:
@@ -132,7 +113,6 @@ class EventProcessor:
        context_id: str | None = None,
        timestamp: bool = False,
        include_entity_name: bool = True,
-        for_live_stream: bool = False,
    ) -> None:
        """Init the event stream."""
        assert not (context_id and (entity_ids or device_ids)), (
@@ -153,7 +133,6 @@ class EventProcessor:
            entity_name_cache=EntityNameCache(self.hass),
            include_entity_name=include_entity_name,
            timestamp=timestamp,
-            for_live_stream=for_live_stream,
        )
        self.context_augmenter = ContextAugmenter(self.logbook_run)

@@ -201,67 +180,13 @@ class EventProcessor:
                self.filters,
                self.context_id,
            )
-            rows = execute_stmt_lambda_element(session, stmt, orm_rows=False)
-            query_parent_user_ids: dict[bytes, bytes] | None = None
-            if self.entity_ids or self.device_ids:
-                # Filtered queries exclude parent call_service rows for
-                # unrelated targets, so child contexts lose user attribution
-                # without a pre-pass. all_stmt already includes them.
-                rows = list(rows)
-                query_parent_user_ids = self._fetch_parent_user_ids(
-                    session, rows, instance.max_bind_vars
-                )
-            return self.humanify(rows, query_parent_user_ids)
-
-    def _fetch_parent_user_ids(
-        self,
-        session: Session,
-        rows: list[Row],
-        max_bind_vars: int,
-    ) -> dict[bytes, bytes] | None:
-        """Resolve parent-context user_ids for rows in a filtered query.
-
-        Done in Python rather than as a SQL union branch because the
-        context_parent_id_bin column is sparsely populated — scanning the
-        States table for non-null parents costs ~40% of the overall query
-        on real datasets. Here we collect only the parent ids we actually
-        need and fetch them via an indexed point-lookup on context_id_bin.
-        """
-        cache = self.logbook_run.context_user_ids
-        pending: set[bytes] = {
-            parent_id
-            for row in rows
-            if (parent_id := row[CONTEXT_PARENT_ID_BIN_POS]) and parent_id not in cache
-        }
-        if not pending:
-            return None
-        query_parent_user_ids: dict[bytes, bytes] = {}
-        # The lambda statement unions events and states, so each id appears
-        # in two IN clauses — halve the chunk size to stay under the
-        # database's max bind variable count.
-        for pending_chunk in chunked_or_all(pending, max_bind_vars // 2):
-            # Schema allows NULL but the query's WHERE clauses exclude it;
-            # explicit checks satisfy the type checker.
-            query_parent_user_ids.update(
-                {
-                    parent_id: user_id
-                    for parent_id, user_id in execute_stmt_lambda_element(
-                        session,
-                        select_context_user_ids_for_context_ids(pending_chunk),
-                        orm_rows=False,
-                    )
-                    if parent_id is not None and user_id is not None
-                }
+            return self.humanify(
+                execute_stmt_lambda_element(session, stmt, orm_rows=False)
            )
-        if self.logbook_run.for_live_stream:
-            cache.update(query_parent_user_ids)
-        return query_parent_user_ids

    def humanify(
-        self,
-        rows: Generator[EventAsRow] | Sequence[Row] | Result,
-        query_parent_user_ids: dict[bytes, bytes] | None = None,
-    ) -> list[dict[str, Any]]:
+        self, rows: Generator[EventAsRow] | Sequence[Row] | Result
+    ) -> list[dict[str, str]]:
        """Humanify rows."""
        return list(
            _humanify(
@@ -270,7 +195,6 @@ class EventProcessor:
                self.ent_reg,
                self.logbook_run,
                self.context_augmenter,
-                query_parent_user_ids,
            )
        )

@@ -281,7 +205,6 @@ def _humanify(
    ent_reg: er.EntityRegistry,
    logbook_run: LogbookRun,
    context_augmenter: ContextAugmenter,
-    query_parent_user_ids: dict[bytes, bytes] | None,
 ) -> Generator[dict[str, Any]]:
    """Generate a converted list of events into entries."""
    # Continuous sensors, will be excluded from the logbook
@@ -297,21 +220,11 @@ def _humanify(
    context_id_bin: bytes
    data: dict[str, Any]

-    context_user_ids = logbook_run.context_user_ids
-    # Skip the LRU write on one-shot runs — the LogbookRun is discarded.
-    populate_context_user_ids = logbook_run.for_live_stream
-
    # Process rows
    for row in rows:
        context_id_bin = row[CONTEXT_ID_BIN_POS]
        if memoize_new_contexts and context_id_bin not in context_lookup:
            context_lookup[context_id_bin] = row
-        if (
-            populate_context_user_ids
-            and (context_user_id_bin := row[CONTEXT_USER_ID_BIN_POS])
-            and context_id_bin not in context_user_ids
-        ):
-            context_user_ids[context_id_bin] = context_user_id_bin
        if row[CONTEXT_ONLY_POS]:
            continue
        event_type = row[EVENT_TYPE_POS]
@@ -369,16 +282,12 @@ def _humanify(
        else:
            continue

-        row_time_fired_ts = row[TIME_FIRED_TS_POS]
-        # Explicit None check: 0.0 is a valid epoch.
-        time_fired_ts: float = (
-            row_time_fired_ts if row_time_fired_ts is not None else time.time()
-        )
+        time_fired_ts = row[TIME_FIRED_TS_POS]
        if timestamp:
-            when: str | float = time_fired_ts
+            when = time_fired_ts or time.time()
        else:
            when = process_timestamp_to_utc_isoformat(
-                dt_util.utc_from_timestamp(time_fired_ts)
+                dt_util.utc_from_timestamp(time_fired_ts) or dt_util.utcnow()
            )
        data[LOGBOOK_ENTRY_WHEN] = when

@@ -398,28 +307,6 @@ def _humanify(
        ):
            context_augmenter.augment(data, context_row)

-        # Fall back to the parent context for child contexts that inherit
-        # user attribution (e.g., generic_thermostat -> switch turn_on).
-        # Read from context_lookup directly instead of get_context() to
-        # avoid the origin_event fallback which would return the *child*
-        # row's origin event, not the parent's.
-        if CONTEXT_USER_ID not in data and (
-            context_parent_id_bin := row[CONTEXT_PARENT_ID_BIN_POS]
-        ):
-            parent_user_id_bin: bytes | None = context_user_ids.get(
-                context_parent_id_bin
-            )
-            if parent_user_id_bin is None and query_parent_user_ids is not None:
-                parent_user_id_bin = query_parent_user_ids.get(context_parent_id_bin)
-            if (
-                parent_user_id_bin is None
-                and (parent_row := context_lookup.get(context_parent_id_bin))
-                is not None
-            ):
-                parent_user_id_bin = parent_row[CONTEXT_USER_ID_BIN_POS]
-            if parent_user_id_bin:
-                data[CONTEXT_USER_ID] = bytes_to_uuid_hex_or_none(parent_user_id_bin)
-
        yield data


--- a/homeassistant/components/logbook/queries/common.py
+++ b/homeassistant/components/logbook/queries/common.py
@@ -2,14 +2,12 @@

 from __future__ import annotations

-from collections.abc import Collection
 from typing import Final

 import sqlalchemy
-from sqlalchemy import lambda_stmt, select, union_all
+from sqlalchemy import select
 from sqlalchemy.sql.elements import BooleanClauseList, ColumnElement
 from sqlalchemy.sql.expression import literal
-from sqlalchemy.sql.lambdas import StatementLambdaElement
 from sqlalchemy.sql.selectable import Select

 from homeassistant.components.recorder.db_schema import (
@@ -124,26 +122,6 @@ def select_events_context_id_subquery(
    )


-def select_context_user_ids_for_context_ids(
-    context_ids: Collection[bytes],
-) -> StatementLambdaElement:
-    """Select (context_id_bin, context_user_id_bin) for the given context ids.
-
-    Union of events and states since a parent context can originate from
-    either table (e.g., a state set directly via the API).
-    """
-    return lambda_stmt(
-        lambda: union_all(
-            select(Events.context_id_bin, Events.context_user_id_bin)
-            .where(Events.context_id_bin.in_(context_ids))
-            .where(Events.context_user_id_bin.is_not(None)),
-            select(States.context_id_bin, States.context_user_id_bin)
-            .where(States.context_id_bin.in_(context_ids))
-            .where(States.context_user_id_bin.is_not(None)),
-        )
-    )
-
-
 def select_events_context_only() -> Select:
    """Generate an events query that mark them as for context_only.

--- a/homeassistant/components/logbook/websocket_api.py
+++ b/homeassistant/components/logbook/websocket_api.py
@@ -14,13 +14,11 @@ import voluptuous as vol
 from homeassistant.components import websocket_api
 from homeassistant.components.recorder import get_instance
 from homeassistant.components.websocket_api import ActiveConnection, messages
-from homeassistant.const import EVENT_CALL_SERVICE
 from homeassistant.core import CALLBACK_TYPE, Event, HomeAssistant, callback
 from homeassistant.helpers.event import async_track_point_in_utc_time
 from homeassistant.helpers.json import json_bytes
 from homeassistant.util import dt as dt_util
 from homeassistant.util.async_ import create_eager_task
-from homeassistant.util.event_type import EventType

 from .const import DOMAIN
 from .helpers import (
@@ -291,8 +289,6 @@ async def ws_event_stream(
            return

    event_types = async_determine_event_types(hass, entity_ids, device_ids)
-    # A past end_time makes this a one-shot fetch that never goes live.
-    will_go_live = not (end_time and end_time <= utc_now)
    event_processor = EventProcessor(
        hass,
        event_types,
@@ -301,7 +297,6 @@ async def ws_event_stream(
        None,
        timestamp=True,
        include_entity_name=False,
-        for_live_stream=will_go_live,
    )

    if end_time and end_time <= utc_now:
@@ -362,20 +357,11 @@ async def ws_event_stream(
        logbook_config: LogbookConfig = hass.data[DOMAIN]
        entities_filter = logbook_config.entity_filter

-    # Live subscription needs call_service events so the live consumer can
-    # cache parent user_ids as they fire. Historical queries don't — the
-    # context_only join fetches them by context_id regardless of type.
-    # Unfiltered streams already include it via BUILT_IN_EVENTS.
-    live_event_types: tuple[EventType[Any] | str, ...] = (
-        event_types
-        if EVENT_CALL_SERVICE in event_types
-        else (*event_types, EVENT_CALL_SERVICE)
-    )
    async_subscribe_events(
        hass,
        subscriptions,
        _queue_or_cancel,
-        live_event_types,
+        event_types,
        entities_filter,
        entity_ids,
        device_ids,
--- a/homeassistant/components/luftdaten/coordinator.py
+++ b/homeassistant/components/luftdaten/coordinator.py
@@ -9,7 +9,7 @@ from __future__ import annotations
 import logging

 from luftdaten import Luftdaten
-from luftdaten.exceptions import LuftdatenConnectionError, LuftdatenError
+from luftdaten.exceptions import LuftdatenError

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -47,22 +47,11 @@ class LuftdatenDataUpdateCoordinator(DataUpdateCoordinator[dict[str, float | int
        """Update sensor/binary sensor data."""
        try:
            await self._sensor_community.get_data()
-        except LuftdatenConnectionError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="communication_error",
-            ) from err
        except LuftdatenError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="unknown_error",
-            ) from err
+            raise UpdateFailed("Unable to retrieve data from Sensor.Community") from err

        if not self._sensor_community.values:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="no_data_received",
-            )
+            raise UpdateFailed("Did not receive sensor data from Sensor.Community")

        data: dict[str, float | int] = self._sensor_community.values
        data.update(self._sensor_community.meta)
--- a/homeassistant/components/luftdaten/sensor.py
+++ b/homeassistant/components/luftdaten/sensor.py
@@ -27,8 +27,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from .const import ATTR_SENSOR_ID, CONF_SENSOR_ID, DOMAIN
 from .coordinator import LuftdatenConfigEntry, LuftdatenDataUpdateCoordinator

-PARALLEL_UPDATES = 0
-
 SENSORS: tuple[SensorEntityDescription, ...] = (
    SensorEntityDescription(
        key="temperature",
--- a/homeassistant/components/luftdaten/strings.json
+++ b/homeassistant/components/luftdaten/strings.json
@@ -21,16 +21,5 @@
    "sensor": {
      "pressure_at_sealevel": { "name": "Pressure at sea level" }
    }
-  },
-  "exceptions": {
-    "communication_error": {
-      "message": "An error occurred while communicating with the Sensor.Community service."
-    },
-    "no_data_received": {
-      "message": "Did not receive sensor data from the Sensor.Community service."
-    },
-    "unknown_error": {
-      "message": "An unknown error occurred while communicating with the Sensor.Community service."
-    }
  }
 }
--- a/homeassistant/components/lutron/init.py
+++ b/homeassistant/components/lutron/init.py
@@ -92,15 +92,83 @@ async def async_setup_entry(
    for area in lutron_client.areas:
        _LOGGER.debug("Working on area %s", area.name)
        for output in area.outputs:
-            _setup_output(
-                hass, entry_data, output, area.name, entity_registry, device_registry
+            platform = None
+            _LOGGER.debug("Working on output %s", output.type)
+            if output.type == "SYSTEM_SHADE":
+                entry_data.covers.append((area.name, output))
+                platform = Platform.COVER
+            elif output.type == "CEILING_FAN_TYPE":
+                entry_data.fans.append((area.name, output))
+                platform = Platform.FAN
+            elif output.is_dimmable:
+                entry_data.lights.append((area.name, output))
+                platform = Platform.LIGHT
+            else:
+                entry_data.switches.append((area.name, output))
+                platform = Platform.SWITCH
+
+            _async_check_entity_unique_id(
+                hass,
+                entity_registry,
+                platform,
+                output.uuid,
+                output.legacy_uuid,
+                entry_data.client.guid,
+            )
+            _async_check_device_identifiers(
+                hass,
+                device_registry,
+                output.uuid,
+                output.legacy_uuid,
+                entry_data.client.guid,
            )

        for keypad in area.keypads:
-            _setup_keypad(
-                hass, entry_data, keypad, area.name, entity_registry, device_registry
+            _async_check_keypad_identifiers(
+                hass,
+                device_registry,
+                keypad.id,
+                keypad.uuid,
+                keypad.legacy_uuid,
+                entry_data.client.guid,
            )
+            for button in keypad.buttons:
+                # If the button has a function assigned to it, add it as a scene
+                if button.name != "Unknown Button" and button.button_type in (
+                    "SingleAction",
+                    "Toggle",
+                    "SingleSceneRaiseLower",
+                    "MasterRaiseLower",
+                    "AdvancedToggle",
+                ):
+                    # Associate an LED with a button if there is one
+                    led = next(
+                        (led for led in keypad.leds if led.number == button.number),
+                        None,
+                    )
+                    entry_data.scenes.append((area.name, keypad, button, led))

+                    platform = Platform.SCENE
+                    _async_check_entity_unique_id(
+                        hass,
+                        entity_registry,
+                        platform,
+                        button.uuid,
+                        button.legacy_uuid,
+                        entry_data.client.guid,
+                    )
+                    if led is not None:
+                        platform = Platform.SWITCH
+                        _async_check_entity_unique_id(
+                            hass,
+                            entity_registry,
+                            platform,
+                            led.uuid,
+                            led.legacy_uuid,
+                            entry_data.client.guid,
+                        )
+                if button.button_type:
+                    entry_data.buttons.append((area.name, keypad, button))
        if area.occupancy_group is not None:
            entry_data.binary_sensors.append((area.name, area.occupancy_group))
            platform = Platform.BINARY_SENSOR
@@ -134,99 +202,6 @@ async def async_setup_entry(
    return True


-def _setup_output(
-    hass: HomeAssistant,
-    entry_data: LutronData,
-    output: Output,
-    area_name: str,
-    entity_registry: er.EntityRegistry,
-    device_registry: dr.DeviceRegistry,
-) -> None:
-    """Set up a Lutron output."""
-    _LOGGER.debug("Working on output %s", output.type)
-    if output.type == "SYSTEM_SHADE":
-        entry_data.covers.append((area_name, output))
-        platform = Platform.COVER
-    elif output.type == "CEILING_FAN_TYPE":
-        entry_data.fans.append((area_name, output))
-        platform = Platform.FAN
-    elif output.is_dimmable:
-        entry_data.lights.append((area_name, output))
-        platform = Platform.LIGHT
-    else:
-        entry_data.switches.append((area_name, output))
-        platform = Platform.SWITCH
-
-    _async_check_entity_unique_id(
-        hass,
-        entity_registry,
-        platform,
-        output.uuid,
-        output.legacy_uuid,
-        entry_data.client.guid,
-    )
-    _async_check_device_identifiers(
-        hass,
-        device_registry,
-        output.uuid,
-        output.legacy_uuid,
-        entry_data.client.guid,
-    )
-
-
-def _setup_keypad(
-    hass: HomeAssistant,
-    entry_data: LutronData,
-    keypad: Keypad,
-    area_name: str,
-    entity_registry: er.EntityRegistry,
-    device_registry: dr.DeviceRegistry,
-) -> None:
-    """Set up a Lutron keypad."""
-
-    _async_check_keypad_identifiers(
-        hass,
-        device_registry,
-        keypad.id,
-        keypad.uuid,
-        keypad.legacy_uuid,
-        entry_data.client.guid,
-    )
-    leds_by_number = {led.number: led for led in keypad.leds}
-    for button in keypad.buttons:
-        # If the button has a function assigned to it, add it as a scene
-        if button.name != "Unknown Button" and button.button_type in (
-            "SingleAction",
-            "Toggle",
-            "SingleSceneRaiseLower",
-            "MasterRaiseLower",
-            "AdvancedToggle",
-        ):
-            # Associate an LED with a button if there is one
-            led = leds_by_number.get(button.number)
-            entry_data.scenes.append((area_name, keypad, button, led))
-
-            _async_check_entity_unique_id(
-                hass,
-                entity_registry,
-                Platform.SCENE,
-                button.uuid,
-                button.legacy_uuid,
-                entry_data.client.guid,
-            )
-            if led is not None:
-                _async_check_entity_unique_id(
-                    hass,
-                    entity_registry,
-                    Platform.SWITCH,
-                    led.uuid,
-                    led.legacy_uuid,
-                    entry_data.client.guid,
-                )
-        if button.button_type:
-            entry_data.buttons.append((area_name, keypad, button))
-
-
 def _async_check_entity_unique_id(
    hass: HomeAssistant,
    entity_registry: er.EntityRegistry,
--- a/homeassistant/components/mastodon/const.py
+++ b/homeassistant/components/mastodon/const.py
@@ -15,7 +15,6 @@ DEFAULT_NAME: Final = "Mastodon"
 ATTR_ACCOUNT_NAME = "account_name"
 ATTR_STATUS = "status"
 ATTR_VISIBILITY = "visibility"
-ATTR_QUOTE_APPROVAL_POLICY = "quote_approval_policy"
 ATTR_IDEMPOTENCY_KEY = "idempotency_key"
 ATTR_CONTENT_WARNING = "content_warning"
 ATTR_MEDIA_WARNING = "media_warning"
--- a/homeassistant/components/mastodon/manifest.json
+++ b/homeassistant/components/mastodon/manifest.json
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["mastodon"],
  "quality_scale": "gold",
-  "requirements": ["Mastodon.py==2.2.1"]
+  "requirements": ["Mastodon.py==2.1.2"]
 }
--- a/homeassistant/components/mastodon/services.py
+++ b/homeassistant/components/mastodon/services.py
@@ -52,7 +52,6 @@ from .const import (
    ATTR_MEDIA_DESCRIPTION,
    ATTR_MEDIA_WARNING,
    ATTR_NOTE,
-    ATTR_QUOTE_APPROVAL_POLICY,
    ATTR_STATUS,
    ATTR_VALUE,
    ATTR_VISIBILITY,
@@ -74,14 +73,6 @@ class StatusVisibility(StrEnum):
    DIRECT = "direct"


-class QuoteApprovalPolicy(StrEnum):
-    """QuoteApprovalPolicy model."""
-
-    PUBLIC = "public"
-    FOLLOWERS = "followers"
-    NOBODY = "nobody"
-
-
 SERVICE_GET_ACCOUNT = "get_account"
 SERVICE_GET_ACCOUNT_SCHEMA = vol.Schema(
    {
@@ -116,9 +107,6 @@ SERVICE_POST_SCHEMA = vol.Schema(
        vol.Required(ATTR_CONFIG_ENTRY_ID): str,
        vol.Required(ATTR_STATUS): str,
        vol.Optional(ATTR_VISIBILITY): vol.In([x.lower() for x in StatusVisibility]),
-        vol.Optional(ATTR_QUOTE_APPROVAL_POLICY): vol.In(
-            [x.lower() for x in QuoteApprovalPolicy]
-        ),
        vol.Optional(ATTR_IDEMPOTENCY_KEY): str,
        vol.Optional(ATTR_CONTENT_WARNING): str,
        vol.Optional(ATTR_LANGUAGE): str,
@@ -299,11 +287,6 @@ async def _async_post(call: ServiceCall) -> ServiceResponse:
        if ATTR_VISIBILITY in call.data
        else None
    )
-    quote_approval_policy: str | None = (
-        QuoteApprovalPolicy(call.data[ATTR_QUOTE_APPROVAL_POLICY])
-        if ATTR_QUOTE_APPROVAL_POLICY in call.data
-        else None
-    )
    idempotency_key: str | None = call.data.get(ATTR_IDEMPOTENCY_KEY)
    spoiler_text: str | None = call.data.get(ATTR_CONTENT_WARNING)
    language: str | None = call.data.get(ATTR_LANGUAGE)
@@ -324,7 +307,6 @@ async def _async_post(call: ServiceCall) -> ServiceResponse:
            client=client,
            status=status,
            visibility=visibility,
-            quote_approval_policy=quote_approval_policy,
            idempotency_key=idempotency_key,
            spoiler_text=spoiler_text,
            language=language,
--- a/homeassistant/components/mastodon/services.yaml
+++ b/homeassistant/components/mastodon/services.yaml
@@ -50,14 +50,6 @@ post:
            - private
            - direct
          translation_key: post_visibility
-    quote_approval_policy:
-      selector:
-        select:
-          options:
-            - public
-            - followers
-            - nobody
-          translation_key: quote_approval_policy
    idempotency_key:
      selector:
        text:
--- a/homeassistant/components/mastodon/strings.json
+++ b/homeassistant/components/mastodon/strings.json
@@ -152,13 +152,6 @@
        "public": "Public - Visible to everyone",
        "unlisted": "Unlisted - Public but not shown in public timelines"
      }
-    },
-    "quote_approval_policy": {
-      "options": {
-        "followers": "Followers - Only accounts that follow you can quote this post",
-        "nobody": "Nobody - No one but you can quote this post",
-        "public": "Public - Anyone can quote this post"
-      }
    }
  },
  "services": {
@@ -229,10 +222,6 @@
          "description": "If an image or video is attached, will mark the media as sensitive (default: no media warning).",
          "name": "Media warning"
        },
-        "quote_approval_policy": {
-          "description": "Who can quote this post (default: account setting).\nIgnored if visibility is private or direct.",
-          "name": "Who can quote"
-        },
        "status": {
          "description": "The status to post.",
          "name": "Status"
--- a/homeassistant/components/matrix/init.py
+++ b/homeassistant/components/matrix/init.py
@@ -127,12 +127,6 @@ CONFIG_SCHEMA = vol.Schema(
 )


-def _read_image_size(image_path: str) -> tuple[int, int]:
-    """Open image to determine image size."""
-    with Image.open(image_path) as image:
-        return image.size
-
-
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    """Set up the Matrix bot component."""
    config = config[DOMAIN]
@@ -510,9 +504,8 @@ class MatrixBot:
            return

        # Get required image metadata.
-        (width, height) = await self.hass.async_add_executor_job(
-            _read_image_size, image_path
-        )
+        image = await self.hass.async_add_executor_job(Image.open, image_path)
+        (width, height) = image.size
        mime_type = mimetypes.guess_type(image_path)[0]
        file_stat = await aiofiles.os.stat(image_path)

--- a/homeassistant/components/matrix/manifest.json
+++ b/homeassistant/components/matrix/manifest.json
@@ -6,5 +6,5 @@
  "iot_class": "cloud_push",
  "loggers": ["matrix_client"],
  "quality_scale": "legacy",
-  "requirements": ["matrix-nio==0.25.2", "Pillow==12.2.0", "aiofiles==24.1.0"]
+  "requirements": ["matrix-nio==0.25.2", "Pillow==12.1.1", "aiofiles==24.1.0"]
 }
--- a/homeassistant/components/mcp_server/http.py
+++ b/homeassistant/components/mcp_server/http.py
@@ -24,8 +24,6 @@ See https://modelcontextprotocol.io/docs/concepts/transports
 """

 import asyncio
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from http import HTTPStatus
 import logging
@@ -104,29 +102,17 @@ class Streams:
    write_stream: MemoryObjectSendStream[SessionMessage]
    write_stream_reader: MemoryObjectReceiveStream[SessionMessage]

-    async def aclose(self) -> None:
-        """Close open memory streams."""
-        await self.read_stream.aclose()
-        await self.read_stream_writer.aclose()
-        await self.write_stream.aclose()
-        await self.write_stream_reader.aclose()

-
-@asynccontextmanager
-async def create_streams() -> AsyncGenerator[Streams]:
+def create_streams() -> Streams:
    """Create a new pair of streams for MCP server communication."""
    read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
    write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-    streams = Streams(
+    return Streams(
        read_stream=read_stream,
        read_stream_writer=read_stream_writer,
        write_stream=write_stream,
        write_stream_reader=write_stream_reader,
    )
-    try:
-        yield streams
-    finally:
-        await streams.aclose()


 async def create_mcp_server(
@@ -169,9 +155,9 @@ class ModelContextProtocolSSEView(HomeAssistantView):
        session_manager = entry.runtime_data

        server, options = await create_mcp_server(hass, self.context(request), entry)
+        streams = create_streams()

        async with (
-            create_streams() as streams,
            sse_response(request) as response,
            session_manager.create(Session(streams.read_stream_writer)) as session_id,
        ):
@@ -275,24 +261,21 @@ class ModelContextProtocolStreamableView(HomeAssistantView):
        # request is sent to the MCP server and we wait for a single response
        # then shut down the server.
        server, options = await create_mcp_server(hass, self.context(request), entry)
+        streams = create_streams()

-        async with create_streams() as streams:
-
-            async def run_server() -> None:
-                await server.run(
-                    streams.read_stream, streams.write_stream, options, stateless=True
-                )
-
-            async with asyncio.timeout(TIMEOUT), anyio.create_task_group() as tg:
-                tg.start_soon(run_server)
-
-                await streams.read_stream_writer.send(SessionMessage(message))
-                session_message = await anext(streams.write_stream_reader)
-                tg.cancel_scope.cancel()
-
-            _LOGGER.debug("Sending response: %s", session_message)
-            return web.json_response(
-                data=session_message.message.model_dump(
-                    by_alias=True, exclude_none=True
-                ),
+        async def run_server() -> None:
+            await server.run(
+                streams.read_stream, streams.write_stream, options, stateless=True
            )
+
+        async with asyncio.timeout(TIMEOUT), anyio.create_task_group() as tg:
+            tg.start_soon(run_server)
+
+            await streams.read_stream_writer.send(SessionMessage(message))
+            session_message = await anext(streams.write_stream_reader)
+            tg.cancel_scope.cancel()
+
+        _LOGGER.debug("Sending response: %s", session_message)
+        return web.json_response(
+            data=session_message.message.model_dump(by_alias=True, exclude_none=True),
+        )
--- a/homeassistant/components/media_player/init.py
+++ b/homeassistant/components/media_player/init.py
@@ -75,6 +75,7 @@ from .const import (  # noqa: F401
    ATTR_GROUP_MEMBERS,
    ATTR_INPUT_SOURCE,
    ATTR_INPUT_SOURCE_LIST,
+    ATTR_LAST_NON_BUFFERING_STATE,
    ATTR_MEDIA_ALBUM_ARTIST,
    ATTR_MEDIA_ALBUM_NAME,
    ATTR_MEDIA_ANNOUNCE,
@@ -587,6 +588,8 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
    _attr_volume_level: float | None = None
    _attr_volume_step: float

+    __last_non_buffering_state: MediaPlayerState | None = None
+
    # Implement these for your media player
    @cached_property
    def device_class(self) -> MediaPlayerDeviceClass | None:
@@ -1124,7 +1127,12 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
    @property
    def state_attributes(self) -> dict[str, Any]:
        """Return the state attributes."""
-        state_attr: dict[str, Any] = {}
+        if (state := self.state) != MediaPlayerState.BUFFERING:
+            self.__last_non_buffering_state = state
+
+        state_attr: dict[str, Any] = {
+            ATTR_LAST_NON_BUFFERING_STATE: self.__last_non_buffering_state
+        }

        if self.support_grouping:
            state_attr[ATTR_GROUP_MEMBERS] = self.group_members
--- a/homeassistant/components/media_player/const.py
+++ b/homeassistant/components/media_player/const.py
@@ -13,6 +13,7 @@ ATTR_ENTITY_PICTURE_LOCAL = "entity_picture_local"
 ATTR_GROUP_MEMBERS = "group_members"
 ATTR_INPUT_SOURCE = "source"
 ATTR_INPUT_SOURCE_LIST = "source_list"
+ATTR_LAST_NON_BUFFERING_STATE = "last_non_buffering_state"
 ATTR_MEDIA_ANNOUNCE = "announce"
 ATTR_MEDIA_ALBUM_ARTIST = "media_album_artist"
 ATTR_MEDIA_ALBUM_NAME = "media_album_name"
--- a/Show More
+++ b/Show More