fix: HA light target — brightness source, transition=0, dashboard type label

- Add brightness_value_source_id to HALightOutputTarget model, to_dict,
  from_dict, update_fields, register_with_manager, API response
- Wire value stream in HALightTargetProcessor: acquire/release on
  start/stop, multiply brightness in _update_lights loop
- Fix transition=0 not saving (parseFloat("0") || 0.5 was falsy)
- Fix dashboard showing "Key Colors" for HA targets — now "Home Assistant"
- Fix dashboard FPS showing 0/2 — HA targets show target/target
- Add CSS source subtitle to HA target dashboard cards

custom_components/wled_screen_controller/sensor.py

@@ -1,8 +1,8 @@
 """Sensor platform for LED Screen Controller."""
+
 from __future__ import annotations
 
 import logging
-from collections.abc import Callable
 from typing import Any
 
 from homeassistant.components.sensor import (
@@ -17,12 +17,10 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
     DOMAIN,
-    TARGET_TYPE_KEY_COLORS,
+    TARGET_TYPE_HA_LIGHT,
     DATA_COORDINATOR,
-    DATA_WS_MANAGER,
 )
 from .coordinator import WLEDScreenControllerCoordinator
-from .ws_manager import KeyColorsWebSocketManager
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -35,34 +33,19 @@ async def async_setup_entry(
     """Set up LED Screen Controller sensors."""
     data = hass.data[DOMAIN][entry.entry_id]
     coordinator: WLEDScreenControllerCoordinator = data[DATA_COORDINATOR]
-    ws_manager: KeyColorsWebSocketManager = data[DATA_WS_MANAGER]
 
     entities: list[SensorEntity] = []
     if coordinator.data and "targets" in coordinator.data:
         for target_id, target_data in coordinator.data["targets"].items():
+            entities.append(WLEDScreenControllerFPSSensor(coordinator, target_id, entry.entry_id))
             entities.append(
-                WLEDScreenControllerFPSSensor(coordinator, target_id, entry.entry_id)
-            )
-            entities.append(
-                WLEDScreenControllerStatusSensor(
-                    coordinator, target_id, entry.entry_id
-                )
+                WLEDScreenControllerStatusSensor(coordinator, target_id, entry.entry_id)
             )
 
-            # Add color sensors for Key Colors targets
+            # Add mapped lights sensor for HA Light targets
             info = target_data["info"]
-            if info.get("target_type") == TARGET_TYPE_KEY_COLORS:
-                rectangles = target_data.get("rectangles", [])
-                for rect in rectangles:
-                    entities.append(
-                        WLEDScreenControllerColorSensor(
-                            coordinator=coordinator,
-                            ws_manager=ws_manager,
-                            target_id=target_id,
-                            rectangle_name=rect["name"],
-                            entry_id=entry.entry_id,
-                        )
-                    )
+            if info.get("target_type") == TARGET_TYPE_HA_LIGHT:
+                entities.append(HALightMappedLightsSensor(coordinator, target_id, entry.entry_id))
 
     async_add_entities(entities)
 
@@ -177,79 +160,58 @@ class WLEDScreenControllerStatusSensor(CoordinatorEntity, SensorEntity):
         return self.coordinator.data.get("targets", {}).get(self._target_id)
 
 
-class WLEDScreenControllerColorSensor(CoordinatorEntity, SensorEntity):
-    """Color sensor reporting the extracted screen color for a Key Colors rectangle."""
+class HALightMappedLightsSensor(CoordinatorEntity, SensorEntity):
+    """Sensor showing the number of mapped HA lights for an HA Light target."""
 
     _attr_has_entity_name = True
-    _attr_icon = "mdi:palette"
+    _attr_icon = "mdi:lightbulb-group"
 
     def __init__(
         self,
         coordinator: WLEDScreenControllerCoordinator,
-        ws_manager: KeyColorsWebSocketManager,
         target_id: str,
-        rectangle_name: str,
         entry_id: str,
     ) -> None:
-        """Initialize the color sensor."""
+        """Initialize the sensor."""
         super().__init__(coordinator)
         self._target_id = target_id
-        self._rectangle_name = rectangle_name
-        self._ws_manager = ws_manager
         self._entry_id = entry_id
-        self._unregister_ws: Callable[[], None] | None = None
-
-        sanitized = rectangle_name.lower().replace(" ", "_").replace("-", "_")
-        self._attr_unique_id = f"{target_id}_{sanitized}_color"
-        self._attr_translation_key = "rectangle_color"
-        self._attr_translation_placeholders = {"rectangle_name": rectangle_name}
+        self._attr_unique_id = f"{target_id}_mapped_lights"
+        self._attr_translation_key = "mapped_lights"
 
     @property
     def device_info(self) -> dict[str, Any]:
         """Return device information."""
         return {"identifiers": {(DOMAIN, self._target_id)}}
 
-    async def async_added_to_hass(self) -> None:
-        """Register WS callback when entity is added."""
-        await super().async_added_to_hass()
-        self._unregister_ws = self._ws_manager.register_callback(
-            self._target_id, self._handle_color_update
-        )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Unregister WS callback when entity is removed."""
-        if self._unregister_ws:
-            self._unregister_ws()
-            self._unregister_ws = None
-        await super().async_will_remove_from_hass()
-
-    def _handle_color_update(self, colors: dict) -> None:
-        """Handle incoming color update from WebSocket."""
-        if self._rectangle_name in colors:
-            self.async_write_ha_state()
-
     @property
-    def native_value(self) -> str | None:
-        """Return the hex color string (e.g. #FF8800)."""
-        color = self._get_color()
-        if color is None:
+    def native_value(self) -> int | None:
+        """Return the number of mapped lights."""
+        target_data = self._get_target_data()
+        if not target_data:
             return None
-        return f"#{color['r']:02X}{color['g']:02X}{color['b']:02X}"
+        mappings = target_data.get("info", {}).get("light_mappings", [])
+        return len(mappings)
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
-        """Return r, g, b, brightness as attributes."""
-        color = self._get_color()
-        if color is None:
+        """Return light mapping details as attributes."""
+        target_data = self._get_target_data()
+        if not target_data:
             return {}
-        r, g, b = color["r"], color["g"], color["b"]
-        brightness = int(0.299 * r + 0.587 * g + 0.114 * b)
+        mappings = target_data.get("info", {}).get("light_mappings", [])
+        entity_ids = [m.get("entity_id", "") for m in mappings]
         return {
-            "r": r,
-            "g": g,
-            "b": b,
-            "brightness": brightness,
-            "rgb_color": [r, g, b],
+            "entity_ids": entity_ids,
+            "mappings": [
+                {
+                    "entity_id": m.get("entity_id", ""),
+                    "led_start": m.get("led_start", 0),
+                    "led_end": m.get("led_end", -1),
+                    "brightness_scale": m.get("brightness_scale", 1.0),
+                }
+                for m in mappings
+            ],
         }
 
     @property
@@ -257,16 +219,6 @@ class WLEDScreenControllerColorSensor(CoordinatorEntity, SensorEntity):
         """Return if entity is available."""
         return self._get_target_data() is not None
 
-    def _get_color(self) -> dict[str, int] | None:
-        """Get the current color for this rectangle from WS manager."""
-        target_data = self._get_target_data()
-        if not target_data or not target_data.get("state"):
-            return None
-        if not target_data["state"].get("processing"):
-            return None
-        colors = self._ws_manager.get_latest_colors(self._target_id)
-        return colors.get(self._rectangle_name)
-
     def _get_target_data(self) -> dict[str, Any] | None:
         if not self.coordinator.data:
             return None