Add live preview streaming for capture tests via WebSocket

Replace blocking REST-based capture tests with WebSocket endpoints that
stream intermediate frame thumbnails at ~100ms intervals, giving real-time
visual feedback during capture. Preview resolution adapts dynamically to
the client viewport size and device pixel ratio.

- New shared helper (_test_helpers.py) with engine_factory pattern to
  avoid MSS thread-affinity issues
- WS endpoints for stream, capture template, and PP template tests
- Enhanced overlay spinner with live preview image and stats
- Frontend _runTestViaWS shared helper replaces three REST test runners

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

server/src/wled_controller/api/routes/postprocessing.py

@@ -7,7 +7,7 @@ import time
 import httpx
 import numpy as np
 from PIL import Image
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Query, WebSocket, WebSocketDisconnect
 
 from wled_controller.api.auth import AuthRequired
 from wled_controller.api.dependencies import (
@@ -330,3 +330,104 @@ async def test_pp_template(
                 stream.cleanup()
             except Exception:
                 pass
+
+
+# ===== REAL-TIME PP TEMPLATE TEST WEBSOCKET =====
+
+
+@router.websocket("/api/v1/postprocessing-templates/{template_id}/test/ws")
+async def test_pp_template_ws(
+    websocket: WebSocket,
+    template_id: str,
+    token: str = Query(""),
+    duration: float = Query(5.0),
+    source_stream_id: str = Query(""),
+    preview_width: int = Query(0),
+):
+    """WebSocket for PP template test with intermediate frame previews."""
+    from wled_controller.api.routes._test_helpers import (
+        authenticate_ws_token,
+        stream_capture_test,
+    )
+    from wled_controller.api.dependencies import (
+        get_picture_source_store as _get_ps_store,
+        get_template_store as _get_t_store,
+        get_pp_template_store as _get_pp_store,
+    )
+
+    if not authenticate_ws_token(token):
+        await websocket.close(code=4001, reason="Unauthorized")
+        return
+
+    if not source_stream_id:
+        await websocket.close(code=4003, reason="source_stream_id is required")
+        return
+
+    pp_store = _get_pp_store()
+    stream_store = _get_ps_store()
+    template_store = _get_t_store()
+
+    # Get PP template
+    try:
+        pp_template = pp_store.get_template(template_id)
+    except ValueError as e:
+        await websocket.close(code=4004, reason=str(e))
+        return
+
+    # Resolve source stream chain
+    try:
+        chain = stream_store.resolve_stream_chain(source_stream_id)
+    except ValueError as e:
+        await websocket.close(code=4004, reason=str(e))
+        return
+
+    raw_stream = chain["raw_stream"]
+
+    if isinstance(raw_stream, StaticImagePictureSource):
+        await websocket.close(code=4003, reason="Static image streams don't support live test")
+        return
+
+    if not isinstance(raw_stream, ScreenCapturePictureSource):
+        await websocket.close(code=4003, reason="Unsupported stream type for live test")
+        return
+
+    # Create capture engine
+    try:
+        capture_template = template_store.get_template(raw_stream.capture_template_id)
+    except ValueError as e:
+        await websocket.close(code=4004, reason=str(e))
+        return
+
+    if capture_template.engine_type not in EngineRegistry.get_available_engines():
+        await websocket.close(code=4003, reason=f"Engine '{capture_template.engine_type}' not available")
+        return
+
+    # Resolve PP filters
+    pp_filters = pp_store.resolve_filter_instances(pp_template.filters) or None
+
+    # Engine factory — creates + initializes engine inside the capture thread
+    # to avoid thread-affinity issues (e.g. MSS uses thread-local state)
+    _engine_type = capture_template.engine_type
+    _display_index = raw_stream.display_index
+    _engine_config = capture_template.engine_config
+
+    def engine_factory():
+        s = EngineRegistry.create_stream(_engine_type, _display_index, _engine_config)
+        s.initialize()
+        return s
+
+    await websocket.accept()
+    logger.info(f"PP template test WS connected for {template_id} ({duration}s)")
+
+    try:
+        await stream_capture_test(
+            websocket, engine_factory, duration,
+            pp_filters=pp_filters,
+            preview_width=preview_width or None,
+        )
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        logger.error(f"PP template test WS error for {template_id}: {e}")
+    finally:
+        logger.info(f"PP template test WS disconnected for {template_id}")