feat(ecovacs): add trace map image entity for mowers

Mower devices (Ecovacs GOAT family) do not expose a ``map=`` capability
in their hardware definitions, so the existing ``EcovacsMap`` image
entity is not created for them — yet recent mower firmwares actively
push trajectory points via ``MapTraceEvent``.

This adds a sibling ``EcovacsMowerTraceMap`` image entity that is
created for any device whose ``capabilities.device_type is MOWER``.
It subscribes directly to ``MapTraceEvent`` on the device's event bus,
parses the ``"x,y;x,y;..."`` payload into a list of points, and
renders a simple SVG polyline of the cumulative trajectory.

Implementation notes:

- The trace is accumulated in memory (cap at 5 000 points to bound
  memory; older points are dropped FIFO).
- Y axis is flipped because the mower coordinate frame is bottom-up
  while SVG is top-down.
- ``viewBox`` is computed per push from the bounding box, with a 5%
  padding, so the entire trajectory remains visible regardless of
  garden size.
- ``stroke-width`` scales with the bounding-box width so the line
  remains visible on both small and large lawns.

Requires ``deebot-client>=18.3.0`` (which ships ``OnMapTrace`` —
DeebotUniverse/client.py#1567).

Tests pending — opening as draft for design feedback first.

Author: Beennnn

homeassistant/components/ecovacs/image.py

@@ -1,10 +1,11 @@
 """Ecovacs image entities."""
 
+from datetime import UTC, datetime
 from typing import cast
 
-from deebot_client.capabilities import CapabilityMap
+from deebot_client.capabilities import Capabilities, CapabilityMap, DeviceType
 from deebot_client.device import Device
-from deebot_client.events.map import CachedMapInfoEvent, MapChangedEvent
+from deebot_client.events.map import CachedMapInfoEvent, MapChangedEvent, MapTraceEvent
 from deebot_client.map import Map
 
 from homeassistant.components.image import ImageEntity
@@ -15,6 +16,8 @@
 from . import EcovacsConfigEntry
 from .entity import EcovacsEntity
 
+_TRACE_MAX_POINTS = 5000
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -23,11 +26,16 @@ async def async_setup_entry(
 ) -> None:
     """Add entities for passed config_entry in HA."""
     controller = config_entry.runtime_data
-    entities = [
+    entities: list[ImageEntity] = [
         EcovacsMap(device, caps, hass)
         for device in controller.devices
         if (caps := device.capabilities.map)
     ]
+    entities.extend(
+        EcovacsMowerTraceMap(device, hass)
+        for device in controller.devices
+        if device.capabilities.device_type is DeviceType.MOWER
+    )
 
     if entities:
         async_add_entities(entities)
@@ -87,3 +95,82 @@ async def async_update(self) -> None:
         """
         await super().async_update()
         self._map.refresh()
+
+
+class EcovacsMowerTraceMap(
+    EcovacsEntity[Capabilities],
+    ImageEntity,
+):
+    """Mower trajectory image rendered from MapTraceEvent."""
+
+    _attr_content_type = "image/svg+xml"
+
+    entity_description = EntityDescription(
+        key="trace_map",
+        translation_key="trace_map",
+    )
+
+    def __init__(self, device: Device, hass: HomeAssistant) -> None:
+        """Initialize entity."""
+        super().__init__(device, device.capabilities, hass=hass)
+        self._points: list[tuple[int, int]] = []
+        self._svg_cache: bytes | None = None
+
+    def image(self) -> bytes | None:
+        """Return bytes of image or None."""
+        if not self._points:
+            return None
+        if self._svg_cache is None:
+            self._svg_cache = self._render_svg().encode()
+        return self._svg_cache
+
+    def _render_svg(self) -> str:
+        xs = [p[0] for p in self._points]
+        ys = [p[1] for p in self._points]
+        min_x, max_x = min(xs), max(xs)
+        min_y, max_y = min(ys), max(ys)
+        padding = max(50, (max(max_x - min_x, max_y - min_y)) // 20)
+        min_x -= padding
+        max_x += padding
+        min_y -= padding
+        max_y += padding
+        width = max_x - min_x
+        height = max_y - min_y
+        # Mower coordinates use bottom-up Y; flip for SVG top-down rendering.
+        flipped = " ".join(f"{x},{max_y + min_y - y}" for x, y in self._points)
+        stroke_width = max(20, width // 200)
+        return (
+            f'<svg xmlns="http://www.w3.org/2000/svg" '
+            f'viewBox="{min_x} {min_y} {width} {height}" '
+            f'preserveAspectRatio="xMidYMid meet">'
+            f'<polyline points="{flipped}" fill="none" '
+            f'stroke="#1976d2" stroke-width="{stroke_width}" '
+            f'stroke-linejoin="round" stroke-linecap="round"/>'
+            f"</svg>"
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """Set up the event listeners now that hass is ready."""
+        await super().async_added_to_hass()
+
+        async def on_trace(event: MapTraceEvent) -> None:
+            new_points: list[tuple[int, int]] = []
+            for token in event.data.split(";"):
+                token = token.strip()
+                if not token:
+                    continue
+                try:
+                    x_str, y_str = token.split(",")
+                    new_points.append((int(x_str), int(y_str)))
+                except ValueError:
+                    continue
+            if not new_points:
+                return
+            self._points.extend(new_points)
+            if len(self._points) > _TRACE_MAX_POINTS:
+                self._points = self._points[-_TRACE_MAX_POINTS:]
+            self._svg_cache = None
+            self._attr_image_last_updated = datetime.now(tz=UTC)
+            self.async_write_ha_state()
+
+        self._subscribe(MapTraceEvent, on_trace)

homeassistant/components/ecovacs/strings.json

@@ -109,6 +109,9 @@
     "image": {
       "map": {
         "name": "Map"
+      },
+      "trace_map": {
+        "name": "Trace map"
       }
     },
     "number": {