fix: endpoints result

fix: tasks endpoint response
feat: implement complete JSON serialization system with response classes
2025-09-23 21:29:18 +02:00 · 2025-09-23 21:03:13 +02:00 · 2025-09-22 21:55:25 +02:00
62 changed files with 1111 additions and 7166 deletions
--- a/README.md
+++ b/README.md
@@ -9,8 +9,6 @@ SPORE is a cluster engine for ESP8266 microcontrollers that provides automatic n
 - [Features](#features)
 - [Supported Hardware](#supported-hardware)
 - [Architecture](#architecture)
- [Cluster Broadcast](#cluster-broadcast)
- [Streaming API](#streaming-api)
 - [API Reference](#api-reference)
 - [Configuration](#configuration)
 - [Development](#development)
@@ -28,8 +26,6 @@ SPORE is a cluster engine for ESP8266 microcontrollers that provides automatic n
 - **Service Registry**: Dynamic API endpoint discovery and registration
 - **Health Monitoring**: Real-time node status tracking with resource monitoring
 - **Event System**: Local and cluster-wide event publishing/subscription
- **Cluster Broadcast**: Centralized UDP broadcast of events (CLUSTER_EVENT)
- **Streaming API**: WebSocket bridge for real-time event send/receive
 - **Over-The-Air Updates**: Seamless firmware updates across the cluster
 - **REST API**: HTTP-based cluster management and monitoring
 - **Capability Discovery**: Automatic API endpoint and service capability detection
@@ -107,52 +103,6 @@ void setup() {

 **Examples:** See [`examples/base/`](./examples/base/) for basic usage and [`examples/relay/`](./examples/relay/) for custom service integration.

-## Cluster Broadcast
-
-Broadcast an event to all peers using the centralized core broadcaster. Services never touch UDP directly; instead they fire a local event that the core transmits as a `CLUSTER_EVENT`.
-
-Usage:
-
-```cpp
-// 1) Apply locally via the same event your service already handles
-JsonDocument payload;
-payload["pattern"] = "rainbow_cycle";
-payload["brightness"] = 100;
-String payloadStr; serializeJson(payload, payloadStr);
-ctx.fire("api/neopattern", &payloadStr);
-
-// 2) Broadcast to peers via the core
-JsonDocument envelope;
-envelope["event"] = "api/neopattern";
-envelope["data"] = payloadStr; // JSON string
-String eventJson; serializeJson(envelope, eventJson);
-ctx.fire("cluster/broadcast", &eventJson);
-```
-
-Notes:
- The core sends subnet-directed broadcasts (e.g., 192.168.1.255) for reliability.
- Peers receive `CLUSTER_EVENT` and forward to local subscribers with `ctx.fire(event, data)`.
- `data` can be a JSON string or nested JSON; receivers handle both.
-
-📖 See the dedicated guide: [`docs/ClusterBroadcast.md`](./docs/ClusterBroadcast.md)
-
-## Streaming API
-
-Real-time event bridge available at `/ws` using WebSocket.
-
- Send JSON `{ event, payload }` to dispatch events via `ctx.fire`.
- Receive all local events as `{ event, payload }`.
-
-Examples:
-```json
-{ "event": "api/neopattern/color", "payload": { "color": "#FF0000", "brightness": 128 } }
-```
-```json
-{ "event": "cluster/broadcast", "payload": { "event": "api/neopattern/color", "data": { "color": "#00FF00" } } }
-```
-
-📖 See the dedicated guide: [`docs/StreamingAPI.md`](./docs/StreamingAPI.md)
-
 ## API Reference

 The system provides a comprehensive RESTful API for monitoring and controlling the embedded device. All endpoints return JSON responses and support standard HTTP status codes.
--- a/docs/API.md
+++ b/docs/API.md
@@ -15,18 +15,12 @@ The SPORE system provides a comprehensive RESTful API for monitoring and control

 | Endpoint | Method | Description | Response |
 |----------|--------|-------------|----------|
-| `/api/node/status` | GET | System resource information | System metrics |
+| `/api/node/status` | GET | System resource information and API endpoint registry | System metrics and API catalog |
 | `/api/node/endpoints` | GET | API endpoints and parameters | Detailed endpoint specifications |
 | `/api/cluster/members` | GET | Cluster membership and node health information | Cluster topology and health status |
 | `/api/node/update` | POST | Handle firmware updates via OTA | Update progress and status |
 | `/api/node/restart` | POST | Trigger system restart | Restart confirmation |

-### Monitoring API
-
-| Endpoint | Method | Description | Response |
-|----------|--------|-------------|----------|
-| `/api/monitoring/resources` | GET | CPU, memory, filesystem, and uptime | System resource metrics |
-
 ### Network Management API

 | Endpoint | Method | Description | Response |
@@ -146,7 +140,7 @@ Controls the execution state of individual tasks. Supports enabling, disabling,

 #### GET /api/node/status

-Returns comprehensive system resource information including memory usage and chip details. For a list of available API endpoints, use `/api/node/endpoints`.
+Returns comprehensive system resource information including memory usage, chip details, and a registry of all available API endpoints.

 **Response Fields:**
 - `freeHeap`: Available RAM in bytes
@@ -174,7 +168,7 @@ Returns comprehensive system resource information including memory usage and chi

 #### GET /api/node/endpoints

-Returns detailed information about all available API endpoints, including their parameters, types, and validation rules. Methods are returned as strings (e.g., "GET", "POST").
+Returns detailed information about all available API endpoints, including their parameters, types, and validation rules.

 **Response Fields:**
 - `endpoints[]`: Array of endpoint capability objects
@@ -242,54 +236,6 @@ Initiates an over-the-air firmware update. The firmware file should be uploaded

 Triggers a system restart. The response will be sent before the restart occurs.

-### Monitoring
-
-#### GET /api/monitoring/resources
-
-Returns real-time system resource metrics.
-
-Response Fields:
- `cpu.current_usage`: Current CPU usage percent
- `cpu.average_usage`: Average CPU usage percent
- `cpu.max_usage`: Max observed CPU usage
- `cpu.min_usage`: Min observed CPU usage
- `cpu.measurement_count`: Number of measurements
- `cpu.is_measuring`: Whether measurement is active
- `memory.free_heap`: Free heap bytes
- `memory.total_heap`: Total heap bytes (approximate)
- `memory.heap_fragmentation`: Fragmentation percent (0 on ESP8266)
- `filesystem.total_bytes`: LittleFS total bytes
- `filesystem.used_bytes`: Used bytes
- `filesystem.free_bytes`: Free bytes
- `filesystem.usage_percent`: Usage percent
- `system.uptime_ms`: Uptime in milliseconds
-Example Response:
-```json
-{
-  "cpu": {
-    "current_usage": 3.5,
-    "average_usage": 2.1,
-    "max_usage": 15.2,
-    "min_usage": 0.0,
-    "measurement_count": 120,
-    "is_measuring": true
-  },
-  "memory": {
-    "free_heap": 48748,
-    "total_heap": 81920,
-    "heap_fragmentation": 0
-  },
-  "filesystem": {
-    "total_bytes": 65536,
-    "used_bytes": 10240,
-    "free_bytes": 55296,
-    "usage_percent": 15.6
-  },
-  "system": {
-    "uptime_ms": 123456
-  }
-}
-```
 ### Network Management

 #### GET /api/network/status
--- a/docs/Architecture.md
+++ b/docs/Architecture.md
@@ -25,9 +25,9 @@ The system architecture consists of several key components working together:
 - **Service Registry**: Track available services across the cluster

 ### Task Scheduler
- **Cooperative Multitasking**: Background task management system (`TaskManager`)
- **Task Lifecycle Management**: Enable/disable tasks and set intervals at runtime
- **Execution Model**: Tasks run in `Spore::loop()` when their interval elapses
+- **Cooperative Multitasking**: Background task management system
+- **Task Lifecycle Management**: Automatic task execution and monitoring
+- **Resource Optimization**: Efficient task scheduling and execution

 ### Node Context
 - **Central Context**: Shared resources and configuration
@@ -40,75 +40,27 @@ The cluster uses a UDP-based discovery protocol for automatic node detection:

 ### Discovery Process

-1. **Discovery Broadcast**: Nodes periodically send UDP packets on port `udp_port` (default 4210)
-2. **Response Handling**: Nodes respond with `CLUSTER_RESPONSE:<hostname>`
-3. **Member Management**: Discovered nodes are added/updated in the cluster
-4. **Node Info via UDP**: Heartbeat triggers peers to send `CLUSTER_NODE_INFO:<hostname>:<json>`
+1. **Discovery Broadcast**: Nodes periodically send UDP packets on port 4210
+2. **Response Handling**: Nodes respond with their hostname and IP address
+3. **Member Management**: Discovered nodes are automatically added to the cluster
+4. **Health Monitoring**: Continuous status checking via HTTP API calls

 ### Protocol Details

- **UDP Port**: 4210 (configurable via `Config.udp_port`)
+- **UDP Port**: 4210 (configurable)
 - **Discovery Message**: `CLUSTER_DISCOVERY`
 - **Response Message**: `CLUSTER_RESPONSE`
- **Heartbeat Message**: `CLUSTER_HEARTBEAT`
- **Node Info Message**: `CLUSTER_NODE_INFO:<hostname>:<json>`
 - **Broadcast Address**: 255.255.255.255
- **Discovery Interval**: `Config.discovery_interval_ms` (default 1000 ms)
- **Listen Interval**: `Config.cluster_listen_interval_ms` (default 10 ms)
- **Heartbeat Interval**: `Config.heartbeat_interval_ms` (default 5000 ms)
-
-### Message Formats
-
- **Discovery**: `CLUSTER_DISCOVERY`
-  - Sender: any node, broadcast to 255.255.255.255:`udp_port`
-  - Purpose: announce presence and solicit peer identification
- **Response**: `CLUSTER_RESPONSE:<hostname>`
-  - Sender: node receiving a discovery; unicast to requester IP
-  - Purpose: provide hostname so requester can register/update member
- **Heartbeat**: `CLUSTER_HEARTBEAT:<hostname>`
-  - Sender: each node, broadcast to 255.255.255.255:`udp_port` on interval
-  - Purpose: prompt peers to reply with their node info and keep liveness
- **Node Info**: `CLUSTER_NODE_INFO:<hostname>:<json>`
-  - Sender: node receiving a heartbeat; unicast to heartbeat sender IP
-  - JSON fields: freeHeap, chipId, sdkVersion, cpuFreqMHz, flashChipSize, optional labels
-
-### Discovery Flow
-
-1. **Sender broadcasts** `CLUSTER_DISCOVERY`
-2. **Each receiver responds** with `CLUSTER_RESPONSE:<hostname>` to the sender IP
-3. **Sender registers/updates** the node using hostname and source IP
-
-### Heartbeat Flow
-
-1. **A node broadcasts** `CLUSTER_HEARTBEAT:<hostname>`
-2. **Each receiver replies** with `CLUSTER_NODE_INFO:<hostname>:<json>` to the heartbeat sender IP
-3. **The sender**:
-   - Ensures the node exists or creates it with `hostname` and sender IP
-   - Parses JSON and updates resources, labels, `status = ACTIVE`, `lastSeen = now`
-   - Sets `latency = now - lastHeartbeatSentAt` (per-node, measured at heartbeat origin)
-
-### Listener Behavior
-
-The `cluster_listen` task parses one UDP packet per run and dispatches by prefix to:
- **Discovery** → send `CLUSTER_RESPONSE`
- **Heartbeat** → send `CLUSTER_NODE_INFO` JSON
- **Response** → add/update node using provided hostname and source IP
- **Node Info** → update resources/status/labels and record latency
-
-### Timing and Intervals
-
- **UDP Port**: `Config.udp_port` (default 4210)
- **Discovery Interval**: `Config.discovery_interval_ms` (default 1000 ms)
- **Listen Interval**: `Config.cluster_listen_interval_ms` (default 10 ms)
- **Heartbeat Interval**: `Config.heartbeat_interval_ms` (default 5000 ms)
+- **Discovery Interval**: 1 second (configurable)
+- **Listen Interval**: 100ms (configurable)

 ### Node Status Categories

 Nodes are automatically categorized by their activity:

- **ACTIVE**: lastSeen < `node_inactive_threshold_ms` (default 10s)
- **INACTIVE**: < `node_dead_threshold_ms` (default 120s)
- **DEAD**: ≥ `node_dead_threshold_ms`
+- **ACTIVE**: Responding within 10 seconds
+- **INACTIVE**: No response for 10-60 seconds  
+- **DEAD**: No response for over 60 seconds

 ## Task Scheduling System

@@ -116,14 +68,14 @@ The system runs several background tasks at different intervals:

 ### Core System Tasks

-| Task | Interval (default) | Purpose |
-|------|--------------------|---------|
-| `cluster_discovery` | 1000 ms | Send UDP discovery packets |
-| `cluster_listen` | 10 ms | Listen for discovery/heartbeat/node-info |
-| `status_update` | 1000 ms | Update node status categories, purge dead |
-| `heartbeat` | 5000 ms | Broadcast heartbeat and update local resources |
-| `cluster_update_members_info` | 10000 ms | Reserved; no-op (info via UDP) |
-| `print_members` | 5000 ms | Log current member list |
+| Task | Interval | Purpose |
+|------|----------|---------|
+| **Discovery Send** | 1 second | Send UDP discovery packets |
+| **Discovery Listen** | 100ms | Listen for discovery responses |
+| **Status Updates** | 1 second | Monitor cluster member health |
+| **Heartbeat** | 2 seconds | Maintain cluster connectivity |
+| **Member Info** | 10 seconds | Update detailed node information |
+| **Debug Output** | 5 seconds | Print cluster status |

 ### Task Management Features

@@ -160,7 +112,10 @@ ctx.fire("cluster_updated", &clusterData);

 ### Available Events

- **`node_discovered`**: New node added or local node refreshed
+- **`node_discovered`**: New node added to cluster
+- **`cluster_updated`**: Cluster membership changed
+- **`resource_update`**: Node resources updated
+- **`health_check`**: Node health status changed

 ## Resource Monitoring

@@ -200,8 +155,10 @@ The system includes automatic WiFi fallback for robust operation:

 ### Configuration

- **Hostname**: Derived from MAC (`esp-<mac>`) and assigned to `ctx.hostname`
- **AP Mode**: If STA connection fails, device switches to AP mode with configured SSID/password
+- **SSID Format**: `SPORE_<MAC_LAST_4>`
+- **Password**: Configurable fallback password
+- **IP Range**: 192.168.4.x subnet
+- **Gateway**: 192.168.4.1

 ## Cluster Topology

@@ -213,30 +170,32 @@ The system includes automatic WiFi fallback for robust operation:

 ### Network Architecture

- UDP broadcast-based discovery and heartbeats on local subnet
- Optional HTTP polling (disabled by default; node info exchanged via UDP)
+- **Mesh-like Structure**: Nodes can communicate with each other
+- **Dynamic Routing**: Automatic path discovery between nodes
+- **Load Distribution**: Tasks distributed across available nodes
+- **Fault Tolerance**: Automatic failover and recovery

 ## Data Flow

 ### Node Discovery
 1. **UDP Broadcast**: Nodes broadcast discovery packets on port 4210
-2. **UDP Response**: Receiving nodes respond with hostname
+2. **UDP Response**: Receiving nodes responds with hostname
 3. **Registration**: Discovered nodes are added to local cluster member list

 ### Health Monitoring
-1. **Periodic Checks**: Cluster manager updates node status categories
-2. **Status Collection**: Each node updates resources via UDP node-info messages
+1. **Periodic Checks**: Cluster manager polls member nodes every 1 second
+2. **Status Collection**: Each node returns resource usage and health metrics

 ### Task Management
-1. **Scheduling**: `TaskManager` executes registered tasks at configured intervals
-2. **Execution**: Tasks run cooperatively in the main loop without preemption
-3. **Monitoring**: Task status is exposed via REST (`/api/tasks/status`)
+1. **Scheduling**: TaskScheduler executes registered tasks at configured intervals
+2. **Execution**: Tasks run cooperatively, yielding control to other tasks
+3. **Monitoring**: Task status and results are exposed via REST API endpoints

 ## Performance Characteristics

 ### Memory Usage

- **Base System**: ~15-20KB RAM (device dependent)
+- **Base System**: ~15-20KB RAM
 - **Per Task**: ~100-200 bytes per task
 - **Cluster Members**: ~50-100 bytes per member
 - **API Endpoints**: ~20-30 bytes per endpoint
@@ -260,7 +219,7 @@ The system includes automatic WiFi fallback for robust operation:
 ### Current Implementation

 - **Network Access**: Local network only (no internet exposure)
- **Authentication**: None currently implemented; LAN-only access assumed
+- **Authentication**: None currently implemented
 - **Data Validation**: Basic input validation
 - **Resource Limits**: Memory and processing constraints

--- a/docs/ClusterBroadcast.md
+++ b/docs/ClusterBroadcast.md
@@ -1,91 +0,0 @@
-## Cluster Broadcast (CLUSTER_EVENT)
-
-### Overview
-
-Spore supports cluster-wide event broadcasting via UDP. Services publish a local event, and the core broadcasts it to peers as a `CLUSTER_EVENT`. Peers receive the event and forward it to local subscribers through the internal event bus.
-
- **Local trigger**: `ctx.fire("cluster/broadcast", eventJson)`
- **UDP message**: `CLUSTER_EVENT:{json}`
- **Receiver action**: Parses `{json}` and calls `ctx.fire(event, data)`
-
-This centralizes network broadcast in core, so services never touch UDP directly.
-
-### Message format
-
- UDP payload prefix: `CLUSTER_EVENT:`
- JSON body:
-```json
-{
-  "event": "<event-name>",
-  "data": "<json-string>" // or an inline JSON object/array
-}
-```
-
-Notes:
- The receiver accepts `data` as either a JSON string or a nested JSON object/array. Nested JSON is serialized back to a string before firing the local event.
- Keep payloads small (UDP, default buffer 512 bytes).
-
-### Core responsibilities
-
- `ClusterManager` registers a centralized handler:
-  - Subscribes to `cluster/broadcast` to send the provided event JSON over UDP broadcast.
-  - Listens for incoming UDP `CLUSTER_EVENT` messages and forwards them to local subscribers via `ctx.fire(event, data)`.
- Broadcast target uses subnet-directed broadcast (e.g., `192.168.1.255`) for better reliability. Both nodes must share the same `udp_port`.
-
-### Service responsibilities
-
-Services send and receive events using the local event bus.
-
-1) Subscribe to an event name and apply state from `data`:
-```cpp
-ctx.on("api/neopattern", [this](void* dataPtr) {
-    String* jsonStr = static_cast<String*>(dataPtr);
-    if (!jsonStr) return;
-    JsonDocument doc;
-    if (deserializeJson(doc, *jsonStr)) return;
-    JsonObject obj = doc.as<JsonObject>();
-    // Parse and apply fields from obj
-});
-```
-
-2) Build a control payload and update locally via the same event:
-```cpp
-JsonDocument payload;
-payload["pattern"] = "rainbow_cycle"; // example
-payload["brightness"] = 100;
-String payloadStr; serializeJson(payload, payloadStr);
-ctx.fire("api/neopattern", &payloadStr);
-``;
-
-3) Broadcast to peers by delegating to core:
-```cpp
-JsonDocument envelope;
-envelope["event"] = "api/neopattern";
-envelope["data"] = payloadStr; // JSON string
-String eventJson; serializeJson(envelope, eventJson);
-ctx.fire("cluster/broadcast", &eventJson);
-```
-
-With this flow, services have a single codepath for applying state (the event handler). Broadcasting simply reuses the same payload.
-
-### Logging
-
- Core logs source IP, payload length, and event name for received `CLUSTER_EVENT`s.
- Services can log when submitting `cluster/broadcast` and when applying control events.
-
-### Networking considerations
-
- Ensure all nodes:
-  - Listen on the same `udp_port`.
-  - Are in the same subnet (for subnet-directed broadcast).
- Some networks may block global broadcast (`255.255.255.255`). Subnet-directed broadcast is used by default.
-
-### Troubleshooting
-
- If peers do not react:
-  - Confirm logs show `CLUSTER_EVENT raw from <ip>` on the receiver.
-  - Verify UDP port alignment and WiFi connection/subnet.
-  - Check payload size (<512 bytes by default) and JSON validity.
-  - Ensure the service subscribed to the correct `event` name and handles `data`.
-
-
--- a/docs/Development.md
+++ b/docs/Development.md
@@ -20,99 +20,57 @@

 ```
 spore/
-├── src/                    # Source code (framework under src/spore)
-│   └── spore/
-│       ├── Spore.cpp               # Framework lifecycle (setup/begin/loop)
-│       ├── core/                   # Core components
-│       │   ├── ApiServer.cpp       # HTTP API server implementation
-│       │   ├── ClusterManager.cpp  # Cluster management logic
-│       │   ├── NetworkManager.cpp  # WiFi and network handling
-│       │   ├── TaskManager.cpp     # Background task management
-│       │   └── NodeContext.cpp     # Central context and events
-│       ├── services/               # Built-in services
-│       │   ├── NodeService.cpp
-│       │   ├── NetworkService.cpp
-│       │   ├── ClusterService.cpp
-│       │   ├── TaskService.cpp
-│       │   ├── StaticFileService.cpp
-│       │   └── MonitoringService.cpp
-│       └── types/                  # Shared types
+├── src/                    # Source code
+│   ├── main.cpp           # Main application entry point
+│   ├── ApiServer.cpp      # HTTP API server implementation
+│   ├── ClusterManager.cpp # Cluster management logic
+│   ├── NetworkManager.cpp # WiFi and network handling
+│   ├── TaskManager.cpp    # Background task management
+│   └── NodeContext.cpp    # Central context and events
 ├── include/                # Header files
-├── examples/               # Example apps per env (base, relay, neopattern)
+├── lib/                    # Library files
 ├── docs/                   # Documentation
 ├── api/                    # OpenAPI specification
-├── platformio.ini          # PlatformIO configuration
-└── ctl.sh                  # Build and deployment scripts
+├── examples/               # Example code
+├── test/                   # Test files
+├── platformio.ini         # PlatformIO configuration
+└── ctl.sh                 # Build and deployment scripts
 ```

 ## PlatformIO Configuration

 ### Framework and Board

-The project uses PlatformIO with the following configuration (excerpt):
+The project uses PlatformIO with the following configuration:

 ```ini
-[platformio]
-default_envs = base
-src_dir = .
-data_dir = ${PROJECT_DIR}/examples/${PIOENV}/data
-
-[common]
-monitor_speed = 115200
-lib_deps = 
-    esp32async/ESPAsyncWebServer@^3.8.0
-    bblanchon/ArduinoJson@^7.4.2
-
-[env:base]
+[env:esp01_1m]
 platform = platformio/espressif8266@^4.2.1
 board = esp01_1m
 framework = arduino
 upload_speed = 115200
-monitor_speed = 115200
-board_build.f_cpu = 80000000L
-board_build.flash_mode = qio
-board_build.filesystem = littlefs
-; note: somehow partition table is not working, so we need to use the ldscript
-board_build.ldscript = eagle.flash.1m64.ld
-lib_deps = ${common.lib_deps}
-build_src_filter = 
-    +<examples/base/*.cpp>
-    +<src/spore/*.cpp>
-    +<src/spore/core/*.cpp>
-    +<src/spore/services/*.cpp>
-    +<src/spore/types/*.cpp>
-    +<src/spore/util/*.cpp>
-    +<src/internal/*.cpp>
-
-[env:d1_mini]
-platform = platformio/espressif8266@^4.2.1
-board = d1_mini
-framework = arduino
-upload_speed = 115200
-monitor_speed = 115200
-board_build.filesystem = littlefs
-board_build.flash_mode = dio           ; D1 Mini uses DIO on 4 Mbit flash
-board_build.flash_size = 4M
-board_build.ldscript = eagle.flash.4m1m.ld
-lib_deps = ${common.lib_deps}
-build_src_filter = 
-    +<examples/base/*.cpp>
-    +<src/spore/*.cpp>
-    +<src/spore/core/*.cpp>
-    +<src/spore/services/*.cpp>
-    +<src/spore/types/*.cpp>
-    +<src/spore/util/*.cpp>
-    +<src/internal/*.cpp>
+flash_mode = dout
 ```

+### Key Configuration Details
+
+- **Framework**: Arduino
+- **Board**: ESP-01 with 1MB flash
+- **Upload Speed**: 115200 baud
+- **Flash Mode**: DOUT (required for ESP-01S)
+- **Build Type**: Release (optimized for production)
+
 ### Dependencies

-The project requires the following libraries (resolved via PlatformIO):
+The project requires the following libraries:

 ```ini
 lib_deps =
    esp32async/ESPAsyncWebServer@^3.8.0
    bblanchon/ArduinoJson@^7.4.2
+    arkhipenko/TaskScheduler@^3.8.5
+    ESP8266HTTPClient@1.2
+    ESP8266WiFi@1.0
 ```

 ### Filesystem, Linker Scripts, and Flash Layout
@@ -145,6 +103,7 @@ Notes:
 - If you need a different FS size, select an appropriate ldscript variant and keep `board_build.filesystem = littlefs`.
 - On ESP8266, custom partition CSVs are not used for layout; the linker script defines the flash map. This project removed prior `board_build.partitions` usage in favor of explicit `board_build.ldscript` entries per environment.

+
 ## Building

 ### Basic Build Commands
@@ -349,7 +308,7 @@ export API_NODE=192.168.1.100
 Key configuration files:

 - **`platformio.ini`**: Build and upload configuration
- **`src/spore/types/Config.cpp`**: Default runtime configuration
+- **`src/Config.cpp`**: Application configuration
 - **`.env`**: Environment variables
 - **`ctl.sh`**: Build and deployment scripts

--- a/docs/MonitoringService.md
+++ b/docs/MonitoringService.md
@@ -1,79 +0,0 @@
-# Monitoring Service
-
-Exposes system resource metrics via HTTP for observability.
-
-## Overview
-
- **Service name**: `MonitoringService`
- **Endpoint**: `GET /api/monitoring/resources`
- **Metrics**: CPU usage, memory, filesystem, uptime
-
-## Endpoint
-
-### GET /api/monitoring/resources
-
-Returns real-time system resource metrics.
-
-Response fields:
- `cpu.current_usage`: Current CPU usage percent
- `cpu.average_usage`: Average CPU usage percent
- `cpu.max_usage`: Max observed CPU usage
- `cpu.min_usage`: Min observed CPU usage
- `cpu.measurement_count`: Number of measurements
- `cpu.is_measuring`: Whether measurement is active
- `memory.free_heap`: Free heap bytes
- `memory.total_heap`: Total heap bytes (approximate)
- `memory.min_free_heap`: Minimum free heap (0 on ESP8266)
- `memory.max_alloc_heap`: Max allocatable heap (0 on ESP8266)
- `memory.heap_fragmentation`: Fragmentation percent (0 on ESP8266)
- `filesystem.total_bytes`: LittleFS total bytes
- `filesystem.used_bytes`: Used bytes
- `filesystem.free_bytes`: Free bytes
- `filesystem.usage_percent`: Usage percent
- `system.uptime_ms`: Uptime in milliseconds
- `system.uptime_seconds`: Uptime in seconds
- `system.uptime_formatted`: Human-readable uptime
-
-Example:
-```json
-{
-  "cpu": {
-    "current_usage": 3.5,
-    "average_usage": 2.1,
-    "max_usage": 15.2,
-    "min_usage": 0.0,
-    "measurement_count": 120,
-    "is_measuring": true
-  },
-  "memory": {
-    "free_heap": 48748,
-    "total_heap": 81920,
-    "min_free_heap": 0,
-    "max_alloc_heap": 0,
-    "heap_fragmentation": 0,
-    "heap_usage_percent": 40.4
-  },
-  "filesystem": {
-    "total_bytes": 65536,
-    "used_bytes": 10240,
-    "free_bytes": 55296,
-    "usage_percent": 15.6
-  },
-  "system": {
-    "uptime_ms": 123456,
-    "uptime_seconds": 123,
-    "uptime_formatted": "0h 2m 3s"
-  }
-}
-```
-
-## Implementation Notes
-
- `MonitoringService` reads from `CpuUsage` and ESP8266 SDK APIs.
- Filesystem metrics are gathered from LittleFS.
- CPU measurement is bracketed by `Spore::loop()` calling `cpuUsage.startMeasurement()` and `cpuUsage.endMeasurement()`.
-
-## Troubleshooting
-
- If `filesystem.total_bytes` is zero, ensure LittleFS is enabled in `platformio.ini` and an FS image is uploaded.
- CPU usage values remain zero until the main loop runs and CPU measurement is started.
--- a/docs/README.md
+++ b/docs/README.md
@@ -15,8 +15,15 @@ Complete API reference with detailed endpoint documentation, examples, and integ
 - Task management workflows
 - Cluster monitoring examples

-### 📖 [MonitoringService.md](./MonitoringService.md)
-System resource monitoring API for CPU, memory, filesystem, and uptime.
+### 📖 [TaskManager.md](./TaskManager.md)
+Comprehensive guide to the TaskManager system for background task management.
+
+**Includes:**
+- Basic usage examples
+- Advanced binding techniques
+- Task status monitoring
+- API integration details
+- Performance considerations

 ### 📖 [TaskManagement.md](./TaskManagement.md)
 Complete guide to the task management system with examples and best practices.
--- a/docs/StreamingAPI.md
+++ b/docs/StreamingAPI.md
@@ -1,80 +0,0 @@
-## Streaming API (WebSocket)
-
-### Overview
-
-The streaming API exposes an event-driven WebSocket at `/ws`. It bridges between external clients and the internal event bus:
-
- Incoming WebSocket JSON `{ event, payload }` → `ctx.fire(event, payload)`
- Local events → broadcasted to all connected WebSocket clients as `{ event, payload }`
-
-This allows real-time control and observation of the system without polling.
-
-### URL
-
- `ws://<device-ip>/ws`
-
-### Message Format
-
- Client → Device
-```json
-{
-  "event": "<event-name>",
-  "payload": "<json-string>" | { /* inline JSON */ }
-}
-```
-
- Device → Client
-```json
-{
-  "event": "<event-name>",
-  "payload": "<json-string>"
-}
-```
-
-Notes:
- The device accepts `payload` as a string or a JSON object/array. Objects are serialized into a string before dispatching to local subscribers to keep a consistent downstream contract.
- A minimal ack `{ "ok": true }` is sent after a valid inbound message.
-
-#### Echo suppression (origin tagging)
-
- To prevent the sender from receiving an immediate echo of its own message, the server injects a private field into JSON payloads:
-  - `_origin: "ws:<clientId>"`
- When re-broadcasting local events to WebSocket clients, the server:
-  - Strips the `_origin` field from the outgoing payload
-  - Skips the originating `clientId` so only other clients receive the message
-  - If a payload is not valid JSON (plain string), no origin tag is injected and the message may be echoed
-
-### Event Bus Integration
-
- The WebSocket registers an `onAny` subscriber to `NodeContext` so that all local events are mirrored to clients.
- Services should subscribe to specific events via `ctx.on("<name>", ...)`.
-
-### Examples
-
-1) Set a solid color on NeoPattern:
-```json
-{
-  "event": "api/neopattern/color",
-  "payload": { "color": "#FF0000", "brightness": 128 }
-}
-```
-
-2) Broadcast a cluster event (delegated to core):
-```json
-{
-  "event": "cluster/broadcast",
-  "payload": {
-    "event": "api/neopattern/color",
-    "data": { "color": "#00FF00", "brightness": 128 }
-  }
-}
-```
-
-### Reference Implementation
-
- WebSocket setup and bridging are implemented in `ApiServer`.
- Global event subscription uses `NodeContext::onAny`.
-
-Related docs:
- [`ClusterBroadcast.md`](./ClusterBroadcast.md) — centralized UDP broadcasting and CLUSTER_EVENT format
-
--- a/docs/TaskManagement.md
+++ b/docs/TaskManagement.md
@@ -319,18 +319,18 @@ curl -X POST http://192.168.1.100/api/tasks/control \
 ### Before (with wrapper functions):
 ```cpp
 void discoverySendTask() { cluster.sendDiscovery(); }
-void clusterListenTask() { cluster.listen(); }
+void discoveryListenTask() { cluster.listenForDiscovery(); }

 taskManager.registerTask("discovery_send", interval, discoverySendTask);
-taskManager.registerTask("cluster_listen", interval, clusterListenTask);
+taskManager.registerTask("discovery_listen", interval, discoveryListenTask);
 ```

 ### After (with std::bind):
 ```cpp
 taskManager.registerTask("discovery_send", interval, 
                       std::bind(&ClusterManager::sendDiscovery, &cluster));
-taskManager.registerTask("cluster_listen", interval, 
-                       std::bind(&ClusterManager::listen, &cluster));
+taskManager.registerTask("discovery_listen", interval, 
+                       std::bind(&ClusterManager::listenForDiscovery, &cluster));
 ```

 ## Compatibility
--- a/examples/neopattern/NeoPatternService.cpp
+++ b/examples/neopattern/NeoPatternService.cpp
@@ -1,13 +1,10 @@
 #include "NeoPatternService.h"
 #include "spore/core/ApiServer.h"
 #include "spore/util/Logging.h"
-#include "spore/internal/Globals.h"
 #include <ArduinoJson.h>
-#include <ESP8266WiFi.h>

-NeoPatternService::NeoPatternService(NodeContext& ctx, TaskManager& taskMgr, const NeoPixelConfig& config)
+NeoPatternService::NeoPatternService(TaskManager& taskMgr, const NeoPixelConfig& config)
    : taskManager(taskMgr),
-      ctx(ctx),
      config(config),
      activePattern(NeoPatternType::RAINBOW_CYCLE),
      direction(NeoDirection::FORWARD),
@@ -35,7 +32,6 @@ NeoPatternService::NeoPatternService(NodeContext& ctx, TaskManager& taskMgr, con
    
    registerPatterns();
    registerTasks();
-    registerEventHandlers();
    initialized = true;
    
    LOG_INFO("NeoPattern", "Service initialized");
@@ -68,8 +64,7 @@ void NeoPatternService::registerEndpoints(ApiServer& api) {
            ParamSpec{String("brightness"), false, String("body"), String("numberRange"), {}, String("80")},
            ParamSpec{String("total_steps"), false, String("body"), String("numberRange"), {}, String("16")},
            ParamSpec{String("direction"), false, String("body"), String("string"), {String("forward"), String("reverse")}},
-            ParamSpec{String("interval"), false, String("body"), String("number"), {}, String("100")},
-            ParamSpec{String("broadcast"), false, String("body"), String("boolean"), {}}
+            ParamSpec{String("interval"), false, String("body"), String("number"), {}, String("100")}
        });

    // State endpoint for complex state updates
@@ -124,49 +119,61 @@ void NeoPatternService::handlePatternsRequest(AsyncWebServerRequest* request) {

 void NeoPatternService::handleControlRequest(AsyncWebServerRequest* request) {
    bool updated = false;
-    bool broadcast = false;

-    if (request->hasParam("broadcast", true)) {
-        String b = request->getParam("broadcast", true)->value();
-        broadcast = b.equalsIgnoreCase("true") || b == "1";
+    if (request->hasParam("pattern", true)) {
+        String name = request->getParam("pattern", true)->value();
+        if (isValidPattern(name)) {
+            setPatternByName(name);
+            updated = true;
+        } else {
+            // Invalid pattern name - could add error handling here
+            LOG_WARN("NeoPattern", "Invalid pattern name: " + name);
+        }
    }

-    // Build JSON payload from provided params (single source of truth)
-    JsonDocument payload;
-    bool any = false;
-    if (request->hasParam("pattern", true)) { payload["pattern"] = request->getParam("pattern", true)->value(); any = true; }
-    if (request->hasParam("color", true)) { payload["color"] = request->getParam("color", true)->value(); any = true; }
-    if (request->hasParam("color2", true)) { payload["color2"] = request->getParam("color2", true)->value(); any = true; }
-    if (request->hasParam("brightness", true)) { payload["brightness"] = request->getParam("brightness", true)->value(); any = true; }
-    if (request->hasParam("total_steps", true)) { payload["total_steps"] = request->getParam("total_steps", true)->value(); any = true; }
-    if (request->hasParam("direction", true)) { payload["direction"] = request->getParam("direction", true)->value(); any = true; }
-    if (request->hasParam("interval", true)) { payload["interval"] = request->getParam("interval", true)->value(); any = true; }
-
-    String payloadStr;
-    serializeJson(payload, payloadStr);
-
-    // Always apply locally via event so we have a single codepath for updates
-    if (any) {
-        std::string ev = "api/neopattern";
-        String localData = payloadStr;
-        LOG_INFO("NeoPattern", String("Applying local api/neopattern via event payloadLen=") + String(payloadStr.length()));
-        ctx.fire(ev, &localData);
+    if (request->hasParam("color", true)) {
+        String colorStr = request->getParam("color", true)->value();
+        uint32_t color = parseColor(colorStr);
+        setColor(color);
        updated = true;
    }

-    // Broadcast to peers if requested (delegate to core broadcast handler)
-    if (broadcast && any) {
-        JsonDocument eventDoc;
-        eventDoc["event"] = "api/neopattern";
-        eventDoc["data"] = payloadStr; // data is JSON string
+    if (request->hasParam("color2", true)) {
+        String colorStr = request->getParam("color2", true)->value();
+        uint32_t color = parseColor(colorStr);
+        setColor2(color);
+        updated = true;
+    }

-        String eventJson;
-        serializeJson(eventDoc, eventJson);
+    if (request->hasParam("brightness", true)) {
+        int b = request->getParam("brightness", true)->value().toInt();
+        if (b < 0) b = 0;
+        if (b > 255) b = 255;
+        setBrightness(static_cast<uint8_t>(b));
+        updated = true;
+    }

-        LOG_INFO("NeoPattern", String("Submitting cluster/broadcast for api/neopattern payloadLen=") + String(payloadStr.length()));
-        std::string ev = "cluster/broadcast";
-        String eventStr = eventJson;
-        ctx.fire(ev, &eventStr);
+    if (request->hasParam("total_steps", true)) {
+        int steps = request->getParam("total_steps", true)->value().toInt();
+        if (steps > 0) {
+            setTotalSteps(static_cast<uint16_t>(steps));
+            updated = true;
+        }
+    }
+
+    if (request->hasParam("direction", true)) {
+        String dirStr = request->getParam("direction", true)->value();
+        NeoDirection dir = (dirStr.equalsIgnoreCase("reverse")) ? NeoDirection::REVERSE : NeoDirection::FORWARD;
+        setDirection(dir);
+        updated = true;
+    }
+
+    if (request->hasParam("interval", true)) {
+        unsigned long interval = request->getParam("interval", true)->value().toInt();
+        if (interval > 0) {
+            setUpdateInterval(interval);
+            updated = true;
+        }
    }

    // Return current state
@@ -185,139 +192,6 @@ void NeoPatternService::handleControlRequest(AsyncWebServerRequest* request) {
    serializeJson(resp, json);
    request->send(200, "application/json", json);
 }
-void NeoPatternService::registerEventHandlers() {
-    ctx.on("api/neopattern", [this](void* dataPtr) {
-        String* jsonStr = static_cast<String*>(dataPtr);
-        if (!jsonStr) {
-            LOG_WARN("NeoPattern", "Received api/neopattern with null dataPtr");
-            return;
-        }
-        LOG_INFO("NeoPattern", String("Received api/neopattern event dataLen=") + String(jsonStr->length()));
-        JsonDocument doc;
-        DeserializationError err = deserializeJson(doc, *jsonStr);
-        if (err) {
-            LOG_WARN("NeoPattern", String("Failed to parse CLUSTER_EVENT data: ") + err.c_str());
-            return;
-        }
-        JsonObject obj = doc.as<JsonObject>();
-        bool applied = applyControlParams(obj);
-        if (applied) {
-            LOG_INFO("NeoPattern", "Applied control from CLUSTER_EVENT");
-        }
-    });
-
-    // Solid color event: sets all pixels to the same color
-    ctx.on("api/neopattern/color", [this](void* dataPtr) {
-        String* jsonStr = static_cast<String*>(dataPtr);
-        if (!jsonStr) {
-            LOG_WARN("NeoPattern", "Received api/neopattern/color with null dataPtr");
-            return;
-        }
-        JsonDocument doc;
-        DeserializationError err = deserializeJson(doc, *jsonStr);
-        if (err) {
-            LOG_WARN("NeoPattern", String("Failed to parse color event data: ") + err.c_str());
-            return;
-        }
-        JsonObject obj = doc.as<JsonObject>();
-        // color can be string or number
-        String colorStr;
-        if (obj["color"].is<const char*>() || obj["color"].is<String>()) {
-            colorStr = obj["color"].as<String>();
-        } else if (obj["color"].is<long>() || obj["color"].is<int>()) {
-            colorStr = String(obj["color"].as<long>());
-        } else {
-            LOG_WARN("NeoPattern", "api/neopattern/color missing 'color'");
-            return;
-        }
-
-        // Optional brightness
-        if (obj["brightness"].is<int>() || obj["brightness"].is<long>()) {
-            int b = obj["brightness"].as<int>();
-            if (b < 0) b = 0; if (b > 255) b = 255;
-            setBrightness(static_cast<uint8_t>(b));
-        }
-
-        uint32_t color = parseColor(colorStr);
-        setPattern(NeoPatternType::NONE);
-        setColor(color);
-        LOG_INFO("NeoPattern", String("Set solid color ") + colorStr);
-    });
-}
-
-bool NeoPatternService::applyControlParams(const JsonObject& obj) {
-    bool updated = false;
-    if (obj["pattern"].is<const char*>() || obj["pattern"].is<String>()) {
-        String name = obj["pattern"].as<String>();
-        if (isValidPattern(name)) {
-            setPatternByName(name);
-            updated = true;
-        }
-    }
-    if (obj["color"].is<const char*>() || obj["color"].is<String>() || obj["color"].is<long>() || obj["color"].is<int>()) {
-        String colorStr;
-        if (obj["color"].is<long>() || obj["color"].is<int>()) {
-            colorStr = String(obj["color"].as<long>());
-        } else {
-            colorStr = obj["color"].as<String>();
-        }
-        uint32_t color = parseColor(colorStr);
-        setColor(color);
-        updated = true;
-    }
-    if (obj["color2"].is<const char*>() || obj["color2"].is<String>() || obj["color2"].is<long>() || obj["color2"].is<int>()) {
-        String colorStr;
-        if (obj["color2"].is<long>() || obj["color2"].is<int>()) {
-            colorStr = String(obj["color2"].as<long>());
-        } else {
-            colorStr = obj["color2"].as<String>();
-        }
-        uint32_t color = parseColor(colorStr);
-        setColor2(color);
-        updated = true;
-    }
-    if (obj["brightness"].is<int>() || obj["brightness"].is<long>() || obj["brightness"].is<const char*>() || obj["brightness"].is<String>()) {
-        int b = 0;
-        if (obj["brightness"].is<int>() || obj["brightness"].is<long>()) {
-            b = obj["brightness"].as<int>();
-        } else {
-            b = String(obj["brightness"].as<String>()).toInt();
-        }
-        if (b < 0) {
-            b = 0;
-        }
-        if (b > 255) {
-            b = 255;
-        }
-        setBrightness(static_cast<uint8_t>(b));
-        updated = true;
-    }
-    if (obj["total_steps"].is<int>() || obj["total_steps"].is<long>() || obj["total_steps"].is<const char*>() || obj["total_steps"].is<String>()) {
-        int steps = 0;
-        if (obj["total_steps"].is<int>() || obj["total_steps"].is<long>()) {
-            steps = obj["total_steps"].as<int>();
-        } else {
-            steps = String(obj["total_steps"].as<String>()).toInt();
-        }
-        if (steps > 0) { setTotalSteps(static_cast<uint16_t>(steps)); updated = true; }
-    }
-    if (obj["direction"].is<const char*>() || obj["direction"].is<String>()) {
-        String dirStr = obj["direction"].as<String>();
-        NeoDirection dir = (dirStr.equalsIgnoreCase("reverse")) ? NeoDirection::REVERSE : NeoDirection::FORWARD;
-        setDirection(dir);
-        updated = true;
-    }
-    if (obj["interval"].is<int>() || obj["interval"].is<long>() || obj["interval"].is<const char*>() || obj["interval"].is<String>()) {
-        unsigned long interval = 0;
-        if (obj["interval"].is<int>() || obj["interval"].is<long>()) {
-            interval = obj["interval"].as<unsigned long>();
-        } else {
-            interval = String(obj["interval"].as<String>()).toInt();
-        }
-        if (interval > 0) { setUpdateInterval(interval); updated = true; }
-    }
-    return updated;
-}

 void NeoPatternService::handleStateRequest(AsyncWebServerRequest* request) {
    if (request->contentType() != "application/json") {
--- a/examples/neopattern/NeoPatternService.h
+++ b/examples/neopattern/NeoPatternService.h
@@ -1,7 +1,6 @@
 #pragma once
 #include "spore/Service.h"
 #include "spore/core/TaskManager.h"
-#include "spore/core/NodeContext.h"
 #include "NeoPattern.h"
 #include "NeoPatternState.h"
 #include "NeoPixelConfig.h"
@@ -26,7 +25,7 @@ public:
        REVERSE
    };

-    NeoPatternService(NodeContext& ctx, TaskManager& taskMgr, const NeoPixelConfig& config);
+    NeoPatternService(TaskManager& taskMgr, const NeoPixelConfig& config);
    ~NeoPatternService();

    void registerEndpoints(ApiServer& api) override;
@@ -50,8 +49,6 @@ private:
    void registerTasks();
    void registerPatterns();
    void update();
-    void registerEventHandlers();
-    bool applyControlParams(const JsonObject& obj);
    
    // Pattern updaters
    void updateRainbowCycle();
@@ -83,7 +80,6 @@ private:
    String getPatternDescription(const String& name) const;

    TaskManager& taskManager;
-    NodeContext& ctx;
    NeoPattern* neoPattern;
    NeoPixelConfig config;
    NeoPatternState currentState;
--- a/examples/neopattern/main.cpp
+++ b/examples/neopattern/main.cpp
@@ -45,7 +45,7 @@ void setup() {
    );
    
    // Create and add custom service
-    neoPatternService = new NeoPatternService(spore.getContext(), spore.getTaskManager(), config);
+    neoPatternService = new NeoPatternService(spore.getTaskManager(), config);
    spore.addService(neoPatternService);
    
    // Start the API server and complete initialization
--- a/include/spore/core/ApiServer.h
+++ b/include/spore/core/ApiServer.h
@@ -2,7 +2,6 @@
 #include <Arduino.h>
 #include <ArduinoJson.h>
 #include <ESPAsyncWebServer.h>
-#include <AsyncWebSocket.h>
 #include <Updater.h>
 #include <functional>
 #include <vector>
@@ -12,6 +11,7 @@
 #include "spore/types/NodeInfo.h"
 #include "spore/core/TaskManager.h"
 #include "spore/types/ApiTypes.h"
+#include "spore/util/Logging.h"

 class Service;  // Forward declaration

@@ -20,15 +20,17 @@ public:
    ApiServer(NodeContext& ctx, TaskManager& taskMgr, uint16_t port = 80);
    void begin();
    void addService(Service& service);
-    void addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler);
    void addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
-                    std::function<void(AsyncWebServerRequest*, const String&, size_t, uint8_t*, size_t, bool)> uploadHandler);
-
-    void addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
-                    const std::vector<ParamSpec>& params);
+                    const String& serviceName = "unknown");
    void addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
                    std::function<void(AsyncWebServerRequest*, const String&, size_t, uint8_t*, size_t, bool)> uploadHandler,
-                    const std::vector<ParamSpec>& params);
+                    const String& serviceName = "unknown");
+
+    void addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
+                    const std::vector<ParamSpec>& params, const String& serviceName = "unknown");
+    void addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
+                    std::function<void(AsyncWebServerRequest*, const String&, size_t, uint8_t*, size_t, bool)> uploadHandler,
+                    const std::vector<ParamSpec>& params, const String& serviceName = "unknown");

    // Static file serving
    void serveStatic(const String& uri, fs::FS& fs, const String& path, const String& cache_header = "");
@@ -40,18 +42,13 @@ public:

 private:
    AsyncWebServer server;
-    AsyncWebSocket ws{ "/ws" };
    NodeContext& ctx;
    TaskManager& taskManager;
    std::vector<std::reference_wrapper<Service>> services;
    std::vector<EndpointInfo> endpoints;  // Single source of truth for endpoints
-    std::vector<AsyncWebSocketClient*> wsClients;

    // Internal helpers
    void registerEndpoint(const String& uri, int method, 
                         const std::vector<ParamSpec>& params,
                         const String& serviceName);
-
-    // WebSocket helpers
-    void setupWebSocket();
 };
--- a/include/spore/core/ClusterManager.h
+++ b/include/spore/core/ClusterManager.h
@@ -7,15 +7,13 @@
 #include <ArduinoJson.h>
 #include <ESP8266HTTPClient.h>
 #include <map>
-#include <vector>
-#include <functional>

 class ClusterManager {
 public:
    ClusterManager(NodeContext& ctx, TaskManager& taskMgr);
    void registerTasks();
    void sendDiscovery();
-    void listen();
+    void listenForDiscovery();
    void addOrUpdateNode(const String& nodeHost, IPAddress nodeIP);
    void updateAllNodeStatuses();
    void removeDeadNodes();
@@ -28,23 +26,4 @@ public:
 private:
    NodeContext& ctx;
    TaskManager& taskManager;
-	struct MessageHandler {
-		bool (*predicate)(const char*);
-		std::function<void(const char*)> handle;
-		const char* name;
-	};
-	void initMessageHandlers();
-	void handleIncomingMessage(const char* incoming);
-	static bool isDiscoveryMsg(const char* msg);
-	static bool isHeartbeatMsg(const char* msg);
-	static bool isResponseMsg(const char* msg);
-	static bool isNodeInfoMsg(const char* msg);
-	static bool isClusterEventMsg(const char* msg);
-	void onDiscovery(const char* msg);
-	void onHeartbeat(const char* msg);
-	void onResponse(const char* msg);
-	void onNodeInfo(const char* msg);
-	void onClusterEvent(const char* msg);
-	unsigned long lastHeartbeatSentAt = 0;
-	std::vector<MessageHandler> messageHandlers;
 };
--- a/include/spore/core/NodeContext.h
+++ b/include/spore/core/NodeContext.h
@@ -23,10 +23,7 @@ public:

    using EventCallback = std::function<void(void*)>;
    std::map<std::string, std::vector<EventCallback>> eventRegistry;
-    using AnyEventCallback = std::function<void(const std::string&, void*)>;
-    std::vector<AnyEventCallback> anyEventSubscribers;

    void on(const std::string& event, EventCallback cb);
    void fire(const std::string& event, void* data);
-    void onAny(AnyEventCallback cb);
 };
--- a/include/spore/internal/Globals.h
+++ b/include/spore/internal/Globals.h
@@ -7,12 +7,8 @@
 namespace ClusterProtocol {
    constexpr const char* DISCOVERY_MSG = "CLUSTER_DISCOVERY";
    constexpr const char* RESPONSE_MSG = "CLUSTER_RESPONSE";
-    constexpr const char* HEARTBEAT_MSG = "CLUSTER_HEARTBEAT";
-    constexpr const char* NODE_INFO_MSG = "CLUSTER_NODE_INFO";
-    constexpr const char* CLUSTER_EVENT_MSG = "CLUSTER_EVENT";
    constexpr uint16_t UDP_PORT = 4210;
-    // Increased buffer to accommodate node info JSON over UDP
-    constexpr size_t UDP_BUF_SIZE = 512;
+    constexpr size_t UDP_BUF_SIZE = 64;
    constexpr const char* API_NODE_STATUS = "/api/node/status";
 }

--- a/include/spore/types/ApiResponse.h
+++ b/include/spore/types/ApiResponse.h
@@ -0,0 +1,114 @@
+#pragma once
+#include "spore/util/JsonSerializable.h"
+#include "spore/util/Logging.h"
+#include <ArduinoJson.h>
+
+namespace spore {
+namespace types {
+
+/**
+ * Base class for API responses that can be serialized to JSON
+ * Handles complete JsonDocument creation and serialization
+ */
+class ApiResponse {
+protected:
+    mutable JsonDocument doc;
+
+public:
+    virtual ~ApiResponse() = default;
+    
+    /**
+     * Get the complete JSON string representation of this response
+     * @return JSON string ready to send as HTTP response
+     */
+    virtual String toJsonString() const {
+        String json;
+        serializeJson(doc, json);
+        return json;
+    }
+    
+    /**
+     * Get the JsonDocument for direct manipulation if needed
+     * @return Reference to the internal JsonDocument
+     */
+    JsonDocument& getDocument() { return doc; }
+    const JsonDocument& getDocument() const { return doc; }
+    
+    /**
+     * Clear the document and reset for reuse
+     */
+    virtual void clear() {
+        doc.clear();
+    }
+};
+
+/**
+ * Base class for API responses that contain a collection of serializable items
+ */
+template<typename ItemType>
+class CollectionResponse : public ApiResponse {
+protected:
+    String collectionKey;
+    
+public:
+    explicit CollectionResponse(const String& key) : collectionKey(key) {}
+    
+    /**
+     * Add a serializable item to the collection
+     * @param item The serializable item to add
+     */
+    void addItem(const util::JsonSerializable& item) {
+        // Ensure the array exists and get a reference to it
+        if (!doc[collectionKey].is<JsonArray>()) {
+            doc[collectionKey] = JsonArray();
+        }
+        JsonArray arr = doc[collectionKey].as<JsonArray>();
+        JsonObject obj = arr.add<JsonObject>();
+        item.toJson(obj);
+    }
+    
+    /**
+     * Add a serializable item to the collection (move version)
+     * @param item The serializable item to add
+     */
+    void addItem(util::JsonSerializable&& item) {
+        // Ensure the array exists and get a reference to it
+        if (!doc[collectionKey].is<JsonArray>()) {
+            doc[collectionKey] = JsonArray();
+        }
+        JsonArray arr = doc[collectionKey].as<JsonArray>();
+        JsonObject obj = arr.add<JsonObject>();
+        item.toJson(obj);
+    }
+    
+    /**
+     * Add multiple items from a container
+     * @param items Container of serializable items
+     */
+    template<typename Container>
+    void addItems(const Container& items) {
+        // Ensure the array exists and get a reference to it
+        if (!doc[collectionKey].is<JsonArray>()) {
+            doc[collectionKey] = JsonArray();
+        }
+        JsonArray arr = doc[collectionKey].as<JsonArray>();
+        for (const auto& item : items) {
+            JsonObject obj = arr.add<JsonObject>();
+            item.toJson(obj);
+        }
+    }
+    
+    /**
+     * Get the current number of items in the collection
+     * @return Number of items
+     */
+    size_t getItemCount() const {
+        if (doc[collectionKey].is<JsonArray>()) {
+            return doc[collectionKey].as<JsonArray>().size();
+        }
+        return 0;
+    }
+};
+
+} // namespace types
+} // namespace spore
--- a/include/spore/types/ClusterResponse.h
+++ b/include/spore/types/ClusterResponse.h
@@ -0,0 +1,47 @@
+#pragma once
+#include "ApiResponse.h"
+#include "NodeInfoSerializable.h"
+#include <map>
+
+namespace spore {
+namespace types {
+
+/**
+ * Response class for cluster members endpoint
+ * Handles complete JSON document creation for cluster member data
+ */
+class ClusterMembersResponse : public CollectionResponse<NodeInfoSerializable> {
+public:
+    ClusterMembersResponse() : CollectionResponse("members") {}
+    
+    /**
+     * Add a single node to the response
+     * @param node The NodeInfo to add
+     */
+    void addNode(const NodeInfo& node) {
+        addItem(NodeInfoSerializable(const_cast<NodeInfo&>(node)));
+    }
+    
+    /**
+     * Add multiple nodes from a member list
+     * @param memberList Map of hostname to NodeInfo
+     */
+    void addNodes(const std::map<String, NodeInfo>& memberList) {
+        for (const auto& pair : memberList) {
+            addNode(pair.second);
+        }
+    }
+    
+    /**
+     * Add nodes from a pointer to member list
+     * @param memberList Pointer to map of hostname to NodeInfo
+     */
+    void addNodes(const std::map<String, NodeInfo>* memberList) {
+        if (memberList) {
+            addNodes(*memberList);
+        }
+    }
+};
+
+} // namespace types
+} // namespace spore
--- a/include/spore/types/Config.h
+++ b/include/spore/types/Config.h
@@ -15,7 +15,6 @@ public:
    // Cluster Configuration
    unsigned long discovery_interval_ms;
    unsigned long heartbeat_interval_ms;
-    unsigned long cluster_listen_interval_ms;
    unsigned long status_update_interval_ms;
    unsigned long member_info_update_interval_ms;
    unsigned long print_interval_ms;
--- a/include/spore/types/EndpointInfoSerializable.h
+++ b/include/spore/types/EndpointInfoSerializable.h
@@ -0,0 +1,76 @@
+#pragma once
+#include "ApiTypes.h"
+#include "spore/util/JsonSerializable.h"
+#include <ArduinoJson.h>
+
+namespace spore {
+namespace types {
+
+/**
+ * Serializable wrapper for EndpointInfo that implements JsonSerializable interface
+ * Handles conversion between EndpointInfo struct and JSON representation
+ */
+class EndpointInfoSerializable : public util::JsonSerializable {
+private:
+    const EndpointInfo& endpoint;
+
+public:
+    explicit EndpointInfoSerializable(const EndpointInfo& ep) : endpoint(ep) {}
+    
+    /**
+     * Serialize EndpointInfo to JsonObject
+     */
+    void toJson(JsonObject& obj) const override {
+        obj["uri"] = endpoint.uri;
+        obj["method"] = endpoint.method;
+        
+        // Add parameters if present
+        if (!endpoint.params.empty()) {
+            JsonArray paramsArr = obj["params"].to<JsonArray>();
+            for (const auto& param : endpoint.params) {
+                JsonObject paramObj = paramsArr.add<JsonObject>();
+                paramObj["name"] = param.name;
+                paramObj["location"] = param.location;
+                paramObj["required"] = param.required;
+                paramObj["type"] = param.type;
+                
+                if (!param.values.empty()) {
+                    JsonArray valuesArr = paramObj["values"].to<JsonArray>();
+                    for (const auto& value : param.values) {
+                        valuesArr.add(value);
+                    }
+                }
+                
+                if (param.defaultValue.length() > 0) {
+                    paramObj["default"] = param.defaultValue;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Deserialize EndpointInfo from JsonObject
+     */
+    void fromJson(const JsonObject& obj) override {
+        // Note: This would require modifying the EndpointInfo struct to be mutable
+        // For now, this is a placeholder as EndpointInfo is typically read-only
+        // in the context where this serialization is used
+    }
+};
+
+/**
+ * Convenience function to create a JsonArray from a collection of EndpointInfo objects
+ */
+template<typename Container>
+JsonArray endpointInfoToJsonArray(JsonDocument& doc, const Container& endpoints) {
+    JsonArray arr = doc.to<JsonArray>();
+    for (const auto& endpoint : endpoints) {
+        EndpointInfoSerializable serializable(endpoint);
+        JsonObject obj = arr.add<JsonObject>();
+        serializable.toJson(obj);
+    }
+    return arr;
+}
+
+} // namespace types
+} // namespace spore
--- a/include/spore/types/NodeInfo.h
+++ b/include/spore/types/NodeInfo.h
@@ -17,7 +17,7 @@ struct NodeInfo {
        uint32_t cpuFreqMHz = 0;
        uint32_t flashChipSize = 0;
    } resources;
-    unsigned long latency = 0; // ms from heartbeat broadcast to NODE_INFO receipt
+    unsigned long latency = 0; // ms since lastSeen
    std::vector<EndpointInfo> endpoints; // List of registered endpoints
    std::map<String, String> labels; // Arbitrary node labels (key -> value)
 };
--- a/include/spore/types/NodeInfoSerializable.h
+++ b/include/spore/types/NodeInfoSerializable.h
@@ -0,0 +1,141 @@
+#pragma once
+#include "NodeInfo.h"
+#include "ApiTypes.h"
+#include "spore/util/JsonSerializable.h"
+#include <ArduinoJson.h>
+
+namespace spore {
+namespace types {
+
+/**
+ * Serializable wrapper for NodeInfo that implements JsonSerializable interface
+ * Handles conversion between NodeInfo struct and JSON representation
+ */
+class NodeInfoSerializable : public util::JsonSerializable {
+private:
+    NodeInfo& nodeInfo;
+
+public:
+    explicit NodeInfoSerializable(NodeInfo& node) : nodeInfo(node) {}
+    
+    /**
+     * Serialize NodeInfo to JsonObject
+     * Maps all NodeInfo fields to appropriate JSON structure
+     */
+    void toJson(JsonObject& obj) const override {
+        obj["hostname"] = nodeInfo.hostname;
+        obj["ip"] = nodeInfo.ip.toString();
+        obj["lastSeen"] = nodeInfo.lastSeen;
+        obj["latency"] = nodeInfo.latency;
+        obj["status"] = statusToStr(nodeInfo.status);
+        
+        // Serialize resources
+        JsonObject resources = obj["resources"].to<JsonObject>();
+        resources["freeHeap"] = nodeInfo.resources.freeHeap;
+        resources["chipId"] = nodeInfo.resources.chipId;
+        resources["sdkVersion"] = nodeInfo.resources.sdkVersion;
+        resources["cpuFreqMHz"] = nodeInfo.resources.cpuFreqMHz;
+        resources["flashChipSize"] = nodeInfo.resources.flashChipSize;
+        
+        // Serialize labels if present
+        if (!nodeInfo.labels.empty()) {
+            JsonObject labels = obj["labels"].to<JsonObject>();
+            for (const auto& kv : nodeInfo.labels) {
+                labels[kv.first.c_str()] = kv.second;
+            }
+        }
+        
+        // Serialize endpoints if present
+        if (!nodeInfo.endpoints.empty()) {
+            JsonArray endpoints = obj["api"].to<JsonArray>();
+            for (const auto& endpoint : nodeInfo.endpoints) {
+                JsonObject endpointObj = endpoints.add<JsonObject>();
+                endpointObj["uri"] = endpoint.uri;
+                endpointObj["method"] = endpoint.method;
+            }
+        }
+    }
+    
+    /**
+     * Deserialize NodeInfo from JsonObject
+     * Populates NodeInfo fields from JSON structure
+     */
+    void fromJson(const JsonObject& obj) override {
+        nodeInfo.hostname = obj["hostname"].as<String>();
+        
+        // Parse IP address
+        const char* ipStr = obj["ip"];
+        if (ipStr) {
+            nodeInfo.ip.fromString(ipStr);
+        }
+        
+        nodeInfo.lastSeen = obj["lastSeen"].as<unsigned long>();
+        nodeInfo.latency = obj["latency"].as<unsigned long>();
+        
+        // Parse status
+        const char* statusStr = obj["status"];
+        if (statusStr) {
+            if (strcmp(statusStr, "ACTIVE") == 0) {
+                nodeInfo.status = NodeInfo::ACTIVE;
+            } else if (strcmp(statusStr, "INACTIVE") == 0) {
+                nodeInfo.status = NodeInfo::INACTIVE;
+            } else if (strcmp(statusStr, "DEAD") == 0) {
+                nodeInfo.status = NodeInfo::DEAD;
+            }
+        }
+        
+        // Parse resources
+        if (obj["resources"].is<JsonObject>()) {
+            JsonObject resources = obj["resources"].as<JsonObject>();
+            nodeInfo.resources.freeHeap = resources["freeHeap"].as<uint32_t>();
+            nodeInfo.resources.chipId = resources["chipId"].as<uint32_t>();
+            nodeInfo.resources.sdkVersion = resources["sdkVersion"].as<String>();
+            nodeInfo.resources.cpuFreqMHz = resources["cpuFreqMHz"].as<uint32_t>();
+            nodeInfo.resources.flashChipSize = resources["flashChipSize"].as<uint32_t>();
+        }
+        
+        // Parse labels
+        nodeInfo.labels.clear();
+        if (obj["labels"].is<JsonObject>()) {
+            JsonObject labels = obj["labels"].as<JsonObject>();
+            for (JsonPair kvp : labels) {
+                nodeInfo.labels[kvp.key().c_str()] = kvp.value().as<String>();
+            }
+        }
+        
+        // Parse endpoints
+        nodeInfo.endpoints.clear();
+        if (obj["api"].is<JsonArray>()) {
+            JsonArray endpoints = obj["api"].as<JsonArray>();
+            for (JsonObject endpointObj : endpoints) {
+                EndpointInfo endpoint;
+                endpoint.uri = endpointObj["uri"].as<String>();
+                endpoint.method = endpointObj["method"].as<int>();
+                endpoint.isLocal = false;
+                endpoint.serviceName = "remote";
+                nodeInfo.endpoints.push_back(std::move(endpoint));
+            }
+        }
+    }
+};
+
+/**
+ * Convenience function to create a JsonArray from a collection of NodeInfo objects
+ * @param doc The JsonDocument to create the array in
+ * @param nodes Collection of NodeInfo objects
+ * @return A JsonArray containing all serialized NodeInfo objects
+ */
+template<typename Container>
+JsonArray nodeInfoToJsonArray(JsonDocument& doc, const Container& nodes) {
+    JsonArray arr = doc.to<JsonArray>();
+    for (const auto& pair : nodes) {
+        const NodeInfo& node = pair.second;
+        NodeInfoSerializable serializable(const_cast<NodeInfo&>(node));
+        JsonObject obj = arr.add<JsonObject>();
+        serializable.toJson(obj);
+    }
+    return arr;
+}
+
+} // namespace types
+} // namespace spore
--- a/include/spore/types/NodeResponse.h
+++ b/include/spore/types/NodeResponse.h
@@ -0,0 +1,102 @@
+#pragma once
+#include "ApiResponse.h"
+#include "EndpointInfoSerializable.h"
+#include "NodeInfo.h"
+#include "spore/util/Logging.h"
+#include <vector>
+
+namespace spore {
+namespace types {
+
+/**
+ * Response class for node status endpoint
+ * Handles complete JSON document creation for node status data
+ */
+class NodeStatusResponse : public ApiResponse {
+public:
+    /**
+     * Set basic system information
+     */
+    void setSystemInfo() {
+        doc["freeHeap"] = ESP.getFreeHeap();
+        doc["chipId"] = ESP.getChipId();
+        doc["sdkVersion"] = ESP.getSdkVersion();
+        doc["cpuFreqMHz"] = ESP.getCpuFreqMHz();
+        doc["flashChipSize"] = ESP.getFlashChipSize();
+    }
+    
+    /**
+     * Add labels to the response
+     * @param labels Map of label key-value pairs
+     */
+    void addLabels(const std::map<String, String>& labels) {
+        if (!labels.empty()) {
+            JsonObject labelsObj = doc["labels"].to<JsonObject>();
+            for (const auto& kv : labels) {
+                labelsObj[kv.first.c_str()] = kv.second;
+            }
+        }
+    }
+    
+    /**
+     * Build complete response with system info and labels
+     * @param labels Optional labels to include
+     */
+    void buildCompleteResponse(const std::map<String, String>& labels = {}) {
+        setSystemInfo();
+        addLabels(labels);
+    }
+};
+
+/**
+ * Response class for node endpoints endpoint
+ * Handles complete JSON document creation for endpoint data
+ */
+class NodeEndpointsResponse : public CollectionResponse<EndpointInfoSerializable> {
+public:
+    NodeEndpointsResponse() : CollectionResponse("endpoints") {}
+    
+    /**
+     * Add a single endpoint to the response
+     * @param endpoint The EndpointInfo to add
+     */
+    void addEndpoint(const EndpointInfo& endpoint) {
+        addItem(EndpointInfoSerializable(endpoint));
+    }
+    
+    /**
+     * Add multiple endpoints from a container
+     * @param endpoints Container of EndpointInfo objects
+     */
+    void addEndpoints(const std::vector<EndpointInfo>& endpoints) {
+        for (const auto& endpoint : endpoints) {
+            addEndpoint(endpoint);
+        }
+    }
+};
+
+/**
+ * Response class for simple status operations (update, restart)
+ * Handles simple JSON responses for node operations
+ */
+class NodeOperationResponse : public ApiResponse {
+public:
+    /**
+     * Set success response
+     * @param status Status message
+     */
+    void setSuccess(const String& status) {
+        doc["status"] = status;
+    }
+    
+    /**
+     * Set error response
+     * @param status Error status message
+     */
+    void setError(const String& status) {
+        doc["status"] = status;
+    }
+};
+
+} // namespace types
+} // namespace spore
--- a/include/spore/types/TaskInfoSerializable.h
+++ b/include/spore/types/TaskInfoSerializable.h
@@ -0,0 +1,99 @@
+#pragma once
+#include "spore/util/JsonSerializable.h"
+#include <ArduinoJson.h>
+#include <Arduino.h>
+
+namespace spore {
+namespace types {
+
+/**
+ * Serializable wrapper for task information that implements JsonSerializable interface
+ * Handles conversion between task data and JSON representation
+ */
+class TaskInfoSerializable : public util::JsonSerializable {
+private:
+    String taskName;
+    const JsonObject& taskData;
+
+public:
+    TaskInfoSerializable(const String& name, const JsonObject& data) 
+        : taskName(name), taskData(data) {}
+    
+    TaskInfoSerializable(const std::string& name, const JsonObject& data) 
+        : taskName(name.c_str()), taskData(data) {}
+    
+    /**
+     * Serialize task info to JsonObject
+     */
+    void toJson(JsonObject& obj) const override {
+        obj["name"] = taskName;
+        obj["interval"] = taskData["interval"];
+        obj["enabled"] = taskData["enabled"];
+        obj["running"] = taskData["running"];
+        obj["autoStart"] = taskData["autoStart"];
+    }
+    
+    /**
+     * Deserialize task info from JsonObject
+     * Note: This is read-only for task status, so fromJson is not implemented
+     */
+    void fromJson(const JsonObject& obj) override {
+        // Task info is typically read-only in this context
+        // Implementation would go here if needed
+    }
+};
+
+/**
+ * Serializable wrapper for system information
+ */
+class SystemInfoSerializable : public util::JsonSerializable {
+public:
+    /**
+     * Serialize system info to JsonObject
+     */
+    void toJson(JsonObject& obj) const override {
+        obj["freeHeap"] = ESP.getFreeHeap();
+        obj["uptime"] = millis();
+    }
+    
+    /**
+     * Deserialize system info from JsonObject
+     * Note: System info is typically read-only, so fromJson is not implemented
+     */
+    void fromJson(const JsonObject& obj) override {
+        // System info is typically read-only
+        // Implementation would go here if needed
+    }
+};
+
+/**
+ * Serializable wrapper for task summary information
+ */
+class TaskSummarySerializable : public util::JsonSerializable {
+private:
+    size_t totalTasks;
+    size_t activeTasks;
+
+public:
+    TaskSummarySerializable(size_t total, size_t active) 
+        : totalTasks(total), activeTasks(active) {}
+    
+    /**
+     * Serialize task summary to JsonObject
+     */
+    void toJson(JsonObject& obj) const override {
+        obj["totalTasks"] = totalTasks;
+        obj["activeTasks"] = activeTasks;
+    }
+    
+    /**
+     * Deserialize task summary from JsonObject
+     */
+    void fromJson(const JsonObject& obj) override {
+        totalTasks = obj["totalTasks"].as<size_t>();
+        activeTasks = obj["activeTasks"].as<size_t>();
+    }
+};
+
+} // namespace types
+} // namespace spore
--- a/include/spore/types/TaskResponse.h
+++ b/include/spore/types/TaskResponse.h
@@ -0,0 +1,194 @@
+#pragma once
+#include "ApiResponse.h"
+#include "TaskInfoSerializable.h"
+#include <map>
+
+namespace spore {
+namespace types {
+
+/**
+ * Response class for task status endpoint
+ * Handles complete JSON document creation for task status data
+ */
+class TaskStatusResponse : public ApiResponse {
+public:
+    /**
+     * Set the task summary information
+     * @param totalTasks Total number of tasks
+     * @param activeTasks Number of active tasks
+     */
+    void setSummary(size_t totalTasks, size_t activeTasks) {
+        TaskSummarySerializable summary(totalTasks, activeTasks);
+        JsonObject summaryObj = doc["summary"].to<JsonObject>();
+        summary.toJson(summaryObj);
+    }
+    
+    /**
+     * Add a single task to the response
+     * @param taskName Name of the task
+     * @param taskData Task data as JsonObject
+     */
+    void addTask(const String& taskName, const JsonObject& taskData) {
+        TaskInfoSerializable serializable(taskName, taskData);
+        if (!doc["tasks"].is<JsonArray>()) {
+            doc["tasks"] = JsonArray();
+        }
+        JsonArray tasksArr = doc["tasks"].as<JsonArray>();
+        JsonObject taskObj = tasksArr.add<JsonObject>();
+        serializable.toJson(taskObj);
+    }
+    
+    /**
+     * Add a single task to the response (std::string version)
+     * @param taskName Name of the task
+     * @param taskData Task data as JsonObject
+     */
+    void addTask(const std::string& taskName, const JsonObject& taskData) {
+        TaskInfoSerializable serializable(taskName, taskData);
+        if (!doc["tasks"].is<JsonArray>()) {
+            doc["tasks"] = JsonArray();
+        }
+        JsonArray tasksArr = doc["tasks"].as<JsonArray>();
+        JsonObject taskObj = tasksArr.add<JsonObject>();
+        serializable.toJson(taskObj);
+    }
+    
+    /**
+     * Add multiple tasks from a task statuses map
+     * @param taskStatuses Map of task name to task data
+     */
+    void addTasks(const std::map<String, JsonObject>& taskStatuses) {
+        for (const auto& pair : taskStatuses) {
+            addTask(pair.first, pair.second);
+        }
+    }
+    
+    /**
+     * Set the system information
+     */
+    void setSystemInfo() {
+        SystemInfoSerializable systemInfo;
+        JsonObject systemObj = doc["system"].to<JsonObject>();
+        systemInfo.toJson(systemObj);
+    }
+    
+    /**
+     * Build complete response with all components
+     * @param taskStatuses Map of task name to task data
+     */
+    void buildCompleteResponse(const std::map<String, JsonObject>& taskStatuses) {
+        // Set summary
+        size_t totalTasks = taskStatuses.size();
+        size_t activeTasks = 0;
+        for (const auto& pair : taskStatuses) {
+            if (pair.second["enabled"]) {
+                activeTasks++;
+            }
+        }
+        setSummary(totalTasks, activeTasks);
+        
+        // Add all tasks
+        addTasks(taskStatuses);
+        
+        // Set system info
+        setSystemInfo();
+    }
+    
+    /**
+     * Build complete response with all components from vector
+     * @param taskStatuses Vector of pairs of task name to task data
+     */
+    void buildCompleteResponse(const std::vector<std::pair<std::string, JsonObject>>& taskStatuses) {
+        // Clear the document first since getAllTaskStatuses creates a root array
+        doc.clear();
+        
+        // Set summary
+        size_t totalTasks = taskStatuses.size();
+        size_t activeTasks = 0;
+        for (const auto& pair : taskStatuses) {
+            if (pair.second["enabled"]) {
+                activeTasks++;
+            }
+        }
+        setSummary(totalTasks, activeTasks);
+        
+        // Add all tasks - extract data before clearing to avoid invalid references
+        JsonArray tasksArr = doc["tasks"].to<JsonArray>();
+        for (const auto& pair : taskStatuses) {
+            // Extract data from JsonObject before it becomes invalid
+            String taskName = pair.first.c_str();
+            unsigned long interval = pair.second["interval"];
+            bool enabled = pair.second["enabled"];
+            bool running = pair.second["running"];
+            bool autoStart = pair.second["autoStart"];
+            
+            // Create new JsonObject in our document
+            JsonObject taskObj = tasksArr.add<JsonObject>();
+            taskObj["name"] = taskName;
+            taskObj["interval"] = interval;
+            taskObj["enabled"] = enabled;
+            taskObj["running"] = running;
+            taskObj["autoStart"] = autoStart;
+        }
+        
+        // Set system info
+        setSystemInfo();
+    }
+};
+
+/**
+ * Response class for task control operations
+ * Handles JSON responses for task enable/disable/start/stop operations
+ */
+class TaskControlResponse : public ApiResponse {
+public:
+    /**
+     * Set the response data for a task control operation
+     * @param success Whether the operation was successful
+     * @param message Response message
+     * @param taskName Name of the task
+     * @param action Action performed
+     */
+    void setResponse(bool success, const String& message, const String& taskName, const String& action) {
+        doc["success"] = success;
+        doc["message"] = message;
+        doc["task"] = taskName;
+        doc["action"] = action;
+    }
+    
+    /**
+     * Add detailed task information to the response
+     * @param taskName Name of the task
+     * @param enabled Whether task is enabled
+     * @param running Whether task is running
+     * @param interval Task interval
+     */
+    void addTaskDetails(const String& taskName, bool enabled, bool running, unsigned long interval) {
+        JsonObject taskDetails = doc["taskDetails"].to<JsonObject>();
+        taskDetails["name"] = taskName;
+        taskDetails["enabled"] = enabled;
+        taskDetails["running"] = running;
+        taskDetails["interval"] = interval;
+        
+        // Add system info
+        SystemInfoSerializable systemInfo;
+        JsonObject systemObj = taskDetails["system"].to<JsonObject>();
+        systemInfo.toJson(systemObj);
+    }
+    
+    /**
+     * Set error response
+     * @param message Error message
+     * @param example Optional example for correct usage
+     */
+    void setError(const String& message, const String& example = "") {
+        doc["success"] = false;
+        doc["message"] = message;
+        if (example.length() > 0) {
+            doc["example"] = example;
+        }
+    }
+};
+
+} // namespace types
+} // namespace spore
--- a/include/spore/util/JsonSerializable.h
+++ b/include/spore/util/JsonSerializable.h
@@ -0,0 +1,56 @@
+#pragma once
+#include <ArduinoJson.h>
+
+namespace spore {
+namespace util {
+
+/**
+ * Abstract base class for objects that can be serialized to/from JSON
+ * Provides a clean interface for converting objects to JsonObject and back
+ */
+class JsonSerializable {
+public:
+    virtual ~JsonSerializable() = default;
+    
+    /**
+     * Serialize this object to a JsonObject
+     * @param obj The JsonObject to populate with this object's data
+     */
+    virtual void toJson(JsonObject& obj) const = 0;
+    
+    /**
+     * Deserialize this object from a JsonObject
+     * @param obj The JsonObject containing the data to populate this object
+     */
+    virtual void fromJson(const JsonObject& obj) = 0;
+    
+    /**
+     * Convenience method to create a JsonObject from this object
+     * @param doc The JsonDocument to create the object in
+     * @return A JsonObject containing this object's serialized data
+     */
+    JsonObject toJsonObject(JsonDocument& doc) const {
+        JsonObject obj = doc.to<JsonObject>();
+        toJson(obj);
+        return obj;
+    }
+    
+    /**
+     * Convenience method to create a JsonArray from a collection of serializable objects
+     * @param doc The JsonDocument to create the array in
+     * @param objects Collection of objects implementing JsonSerializable
+     * @return A JsonArray containing all serialized objects
+     */
+    template<typename Container>
+    static JsonArray toJsonArray(JsonDocument& doc, const Container& objects) {
+        JsonArray arr = doc.to<JsonArray>();
+        for (const auto& obj : objects) {
+            JsonObject item = arr.add<JsonObject>();
+            obj.toJson(item);
+        }
+        return arr;
+    }
+};
+
+} // namespace util
+} // namespace spore
--- a/src/spore/core/ApiServer.cpp
+++ b/src/spore/core/ApiServer.cpp
@@ -21,57 +21,31 @@ void ApiServer::registerEndpoint(const String& uri, int method,
                                 const String& serviceName) {
    // Add to local endpoints
    endpoints.push_back(EndpointInfo{uri, method, params, serviceName, true});
-    
-    // Update cluster if needed
-    if (ctx.memberList && !ctx.memberList->empty()) {
-        auto it = ctx.memberList->find(ctx.hostname);
-        if (it != ctx.memberList->end()) {
-            it->second.endpoints.push_back(EndpointInfo{uri, method, params, serviceName, true});
-        }
-    }
 }

-void ApiServer::addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler) {
-    // Get current service name if available
-    String serviceName = "unknown";
-    if (!services.empty()) {
-        serviceName = services.back().get().getName();
-    }
+void ApiServer::addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
+                            const String& serviceName) {
    registerEndpoint(uri, method, {}, serviceName);
    server.on(uri.c_str(), method, requestHandler);
 }

 void ApiServer::addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
-                                std::function<void(AsyncWebServerRequest*, const String&, size_t, uint8_t*, size_t, bool)> uploadHandler) {
-    // Get current service name if available
-    String serviceName = "unknown";
-    if (!services.empty()) {
-        serviceName = services.back().get().getName();
-    }
+                                std::function<void(AsyncWebServerRequest*, const String&, size_t, uint8_t*, size_t, bool)> uploadHandler,
+                                const String& serviceName) {
    registerEndpoint(uri, method, {}, serviceName);
    server.on(uri.c_str(), method, requestHandler, uploadHandler);
 }

 // Overloads that also record minimal capability specs
 void ApiServer::addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
-                                const std::vector<ParamSpec>& params) {
-    // Get current service name if available
-    String serviceName = "unknown";
-    if (!services.empty()) {
-        serviceName = services.back().get().getName();
-    }
+                                const std::vector<ParamSpec>& params, const String& serviceName) {
    registerEndpoint(uri, method, params, serviceName);
    server.on(uri.c_str(), method, requestHandler);
 }

 void ApiServer::addEndpoint(const String& uri, int method, std::function<void(AsyncWebServerRequest*)> requestHandler,
                                std::function<void(AsyncWebServerRequest*, const String&, size_t, uint8_t*, size_t, bool)> uploadHandler,
-                                const std::vector<ParamSpec>& params) {
-    // Get current service name if available
-    String serviceName = "unknown";
-    if (!services.empty()) {
-        serviceName = services.back().get().getName();
-    }
+                                const std::vector<ParamSpec>& params, const String& serviceName) {
    registerEndpoint(uri, method, params, serviceName);
    server.on(uri.c_str(), method, requestHandler, uploadHandler);
 }
@@ -87,10 +61,6 @@ void ApiServer::serveStatic(const String& uri, fs::FS& fs, const String& path, c
 }

 void ApiServer::begin() {
-    // Setup streaming API (WebSocket)
-    setupWebSocket();
-    server.addHandler(&ws);
-    
    // Register all service endpoints
    for (auto& service : services) {
        service.get().registerEndpoints(*this);
@@ -99,90 +69,3 @@ void ApiServer::begin() {
    
    server.begin();
 }
-
-void ApiServer::setupWebSocket() {
-    ws.onEvent([this](AsyncWebSocket* server, AsyncWebSocketClient* client, AwsEventType type, void* arg, uint8_t* data, size_t len) {
-        if (type == WS_EVT_DATA) {
-            AwsFrameInfo* info = (AwsFrameInfo*)arg;
-            if (info->final && info->index == 0 && info->len == len && info->opcode == WS_TEXT) {
-                // Parse directly from the raw buffer with explicit length
-                JsonDocument doc;
-                DeserializationError err = deserializeJson(doc, (const char*)data, len);
-                if (!err) {
-                    LOG_DEBUG("API", "Received event: " + String(doc["event"].as<String>()));
-                    String eventName = doc["event"].as<String>();
-                    String payloadStr;
-                    if (doc["payload"].is<const char*>()) {
-                        payloadStr = doc["payload"].as<const char*>();
-                    } else if (!doc["payload"].isNull()) {
-                        // If payload is an object/array, serialize it
-                        String tmp; serializeJson(doc["payload"], tmp); payloadStr = tmp;
-                    }
-                    // Allow empty payload; services may treat it as defaults
-                    if (eventName.length() > 0) {
-                        // Inject origin tag into payload JSON if possible
-                        String enriched = payloadStr;
-                        if (payloadStr.length() > 0) {
-                            JsonDocument pd;
-                            if (!deserializeJson(pd, payloadStr)) {
-                                pd["_origin"] = String("ws:") + String(client->id());
-                                String tmp; serializeJson(pd, tmp); enriched = tmp;
-                            } else {
-                                // If payload is plain string, leave as-is (no origin)
-                            }
-                        }
-                        std::string ev = eventName.c_str();
-                        ctx.fire(ev, &enriched);
-                        // Acknowledge
-                        client->text("{\"ok\":true}");
-                    } else {
-                        client->text("{\"error\":\"Missing 'event'\"}");
-                    }
-                } else {
-                    client->text("{\"error\":\"Invalid JSON\"}");
-                }
-            }
-        } else if (type == WS_EVT_CONNECT) {
-            client->text("{\"hello\":\"ws connected\"}");
-            wsClients.push_back(client);
-        } else if (type == WS_EVT_DISCONNECT) {
-            wsClients.erase(std::remove(wsClients.begin(), wsClients.end(), client), wsClients.end());
-        }
-    });
-
-    // Subscribe to all local events and forward to websocket clients
-    ctx.onAny([this](const std::string& event, void* dataPtr) {
-        String* payloadStrPtr = static_cast<String*>(dataPtr);
-        String payloadStr = payloadStrPtr ? *payloadStrPtr : String("");
-
-        // Extract and strip origin if present
-        String origin;
-        String cleanedPayload = payloadStr;
-        if (payloadStr.length() > 0) {
-            JsonDocument pd;
-            if (!deserializeJson(pd, payloadStr)) {
-                if (pd["_origin"].is<const char*>()) {
-                    origin = pd["_origin"].as<const char*>();
-                    pd.remove("_origin");
-                    String tmp; serializeJson(pd, tmp); cleanedPayload = tmp;
-                }
-            }
-        }
-
-        JsonDocument outDoc;
-        outDoc["event"] = event.c_str();
-        outDoc["payload"] = cleanedPayload;
-        String out; serializeJson(outDoc, out);
-
-        if (origin.startsWith("ws:")) {
-            uint32_t originId = (uint32_t)origin.substring(3).toInt();
-            for (auto* c : wsClients) {
-                if (c && c->id() != originId) {
-                    c->text(out);
-                }
-            }
-        } else {
-            ws.textAll(out);
-        }
-    });
-}
--- a/src/spore/core/ClusterManager.cpp
+++ b/src/spore/core/ClusterManager.cpp
@@ -8,35 +8,17 @@ ClusterManager::ClusterManager(NodeContext& ctx, TaskManager& taskMgr) : ctx(ctx
        NodeInfo* node = static_cast<NodeInfo*>(data);
        this->addOrUpdateNode(node->hostname, node->ip);
    });
-    // Centralized broadcast handler: services fire 'cluster/broadcast' with CLUSTER_EVENT JSON payload
-    ctx.on("cluster/broadcast", [this](void* data) {
-        String* jsonStr = static_cast<String*>(data);
-        if (!jsonStr) {
-            LOG_WARN("Cluster", "cluster/broadcast called with null data");
-            return;
-        }
-        // Subnet-directed broadcast (more reliable than 255.255.255.255 on some networks)
-        IPAddress ip = WiFi.localIP();
-        IPAddress mask = WiFi.subnetMask();
-        IPAddress bcast(ip[0] | ~mask[0], ip[1] | ~mask[1], ip[2] | ~mask[2], ip[3] | ~mask[3]);
-        LOG_DEBUG("Cluster", String("Broadcasting CLUSTER_EVENT to ") + bcast.toString() + " len=" + String(jsonStr->length()));
-        this->ctx.udp->beginPacket(bcast, this->ctx.config.udp_port);
-        String msg = String(ClusterProtocol::CLUSTER_EVENT_MSG) + ":" + *jsonStr;
-        this->ctx.udp->write(msg.c_str());
-        this->ctx.udp->endPacket();
-    });
    // Register tasks
    registerTasks();
-    initMessageHandlers();
 }

 void ClusterManager::registerTasks() {
-    taskManager.registerTask("cluster_discovery", ctx.config.discovery_interval_ms, [this]() { sendDiscovery(); });
-    taskManager.registerTask("cluster_listen", ctx.config.cluster_listen_interval_ms, [this]() { listen(); });
+    taskManager.registerTask("discovery_send", ctx.config.discovery_interval_ms, [this]() { sendDiscovery(); });
+    taskManager.registerTask("discovery_listen", ctx.config.discovery_interval_ms / 10, [this]() { listenForDiscovery(); });
    taskManager.registerTask("status_update", ctx.config.status_update_interval_ms, [this]() {  updateAllNodeStatuses(); removeDeadNodes(); });
    taskManager.registerTask("print_members", ctx.config.print_interval_ms, [this]() { printMemberList(); });
    taskManager.registerTask("heartbeat", ctx.config.heartbeat_interval_ms, [this]() { heartbeatTaskCallback(); });
-    taskManager.registerTask("cluster_update_members_info", ctx.config.member_info_update_interval_ms, [this]() { updateAllMembersInfoTaskCallback(); });
+    taskManager.registerTask("update_members_info", ctx.config.member_info_update_interval_ms, [this]() { updateAllMembersInfoTaskCallback(); });
    LOG_INFO("ClusterManager", "Registered all cluster tasks");
 }

@@ -47,210 +29,28 @@ void ClusterManager::sendDiscovery() {
    ctx.udp->endPacket();
 }

-void ClusterManager::listen() {
+void ClusterManager::listenForDiscovery() {
    int packetSize = ctx.udp->parsePacket();
-    if (!packetSize) {
-        return;
-    }
-
-    char incoming[ClusterProtocol::UDP_BUF_SIZE];
-    int len = ctx.udp->read(incoming, ClusterProtocol::UDP_BUF_SIZE);
-    if (len <= 0) {
-        return;
-    }
-    if (len >= (int)ClusterProtocol::UDP_BUF_SIZE) {
-        incoming[ClusterProtocol::UDP_BUF_SIZE - 1] = 0;
-    } else {
-        incoming[len] = 0;
-    }
-    handleIncomingMessage(incoming);
-}
-
-void ClusterManager::initMessageHandlers() {
-    messageHandlers.clear();
-    messageHandlers.push_back({ &ClusterManager::isDiscoveryMsg, [this](const char* msg){ this->onDiscovery(msg); }, "DISCOVERY" });
-    messageHandlers.push_back({ &ClusterManager::isHeartbeatMsg, [this](const char* msg){ this->onHeartbeat(msg); }, "HEARTBEAT" });
-    messageHandlers.push_back({ &ClusterManager::isResponseMsg,  [this](const char* msg){ this->onResponse(msg);  }, "RESPONSE"  });
-    messageHandlers.push_back({ &ClusterManager::isNodeInfoMsg,  [this](const char* msg){ this->onNodeInfo(msg);  }, "NODE_INFO" });
-    messageHandlers.push_back({ &ClusterManager::isClusterEventMsg,  [this](const char* msg){ this->onClusterEvent(msg);  }, "CLUSTER_EVENT" });
-}
-
-void ClusterManager::handleIncomingMessage(const char* incoming) {
-    for (const auto& h : messageHandlers) {
-        if (h.predicate(incoming)) {
-            h.handle(incoming);
-            return;
+    if (packetSize) {
+        char incoming[ClusterProtocol::UDP_BUF_SIZE];
+        int len = ctx.udp->read(incoming, ClusterProtocol::UDP_BUF_SIZE);
+        if (len > 0) {
+            incoming[len] = 0;
+        }
+        //LOG_DEBUG(ctx, "UDP", "Packet received: " + String(incoming));
+        if (strcmp(incoming, ClusterProtocol::DISCOVERY_MSG) == 0) {
+            //LOG_DEBUG(ctx, "UDP", "Discovery request from: " + ctx.udp->remoteIP().toString());
+            ctx.udp->beginPacket(ctx.udp->remoteIP(), ctx.config.udp_port);
+            String response = String(ClusterProtocol::RESPONSE_MSG) + ":" + ctx.hostname;
+            ctx.udp->write(response.c_str());
+            ctx.udp->endPacket();
+            //LOG_DEBUG(ctx, "UDP", "Sent response with hostname: " + ctx.hostname);
+        } else if (strncmp(incoming, ClusterProtocol::RESPONSE_MSG, strlen(ClusterProtocol::RESPONSE_MSG)) == 0) {
+            char* hostPtr = incoming + strlen(ClusterProtocol::RESPONSE_MSG) + 1;
+            String nodeHost = String(hostPtr);
+            addOrUpdateNode(nodeHost, ctx.udp->remoteIP());
        }
    }
-    // Unknown message - log first token
-    const char* colon = strchr(incoming, ':');
-    String head;
-    if (colon) {
-        head = String(incoming).substring(0, colon - incoming);
-    } else {
-        head = String(incoming);
-    }
-    LOG_DEBUG("Cluster", String("Unknown cluster message: ") + head);
-}
-
-bool ClusterManager::isDiscoveryMsg(const char* msg) {
-    return strcmp(msg, ClusterProtocol::DISCOVERY_MSG) == 0;
-}
-
-bool ClusterManager::isHeartbeatMsg(const char* msg) {
-    return strncmp(msg, ClusterProtocol::HEARTBEAT_MSG, strlen(ClusterProtocol::HEARTBEAT_MSG)) == 0;
-}
-
-bool ClusterManager::isResponseMsg(const char* msg) {
-    return strncmp(msg, ClusterProtocol::RESPONSE_MSG, strlen(ClusterProtocol::RESPONSE_MSG)) == 0;
-}
-
-bool ClusterManager::isNodeInfoMsg(const char* msg) {
-    return strncmp(msg, ClusterProtocol::NODE_INFO_MSG, strlen(ClusterProtocol::NODE_INFO_MSG)) == 0;
-}
-
-bool ClusterManager::isClusterEventMsg(const char* msg) {
-    return strncmp(msg, ClusterProtocol::CLUSTER_EVENT_MSG, strlen(ClusterProtocol::CLUSTER_EVENT_MSG)) == 0;
-}
-
-void ClusterManager::onDiscovery(const char* /*msg*/) {
-    ctx.udp->beginPacket(ctx.udp->remoteIP(), ctx.config.udp_port);
-    String response = String(ClusterProtocol::RESPONSE_MSG) + ":" + ctx.hostname;
-    ctx.udp->write(response.c_str());
-    ctx.udp->endPacket();
-}
-
-void ClusterManager::onHeartbeat(const char* /*msg*/) {
-    JsonDocument doc;
-    doc["freeHeap"] = ESP.getFreeHeap();
-    doc["chipId"] = ESP.getChipId();
-    doc["sdkVersion"] = ESP.getSdkVersion();
-    doc["cpuFreqMHz"] = ESP.getCpuFreqMHz();
-    doc["flashChipSize"] = ESP.getFlashChipSize();
-
-    if (ctx.memberList) {
-        auto it = ctx.memberList->find(ctx.hostname);
-        if (it != ctx.memberList->end()) {
-            JsonObject labelsObj = doc["labels"].to<JsonObject>();
-            for (const auto& kv : it->second.labels) {
-                labelsObj[kv.first.c_str()] = kv.second;
-            }
-        } else if (!ctx.self.labels.empty()) {
-            JsonObject labelsObj = doc["labels"].to<JsonObject>();
-            for (const auto& kv : ctx.self.labels) {
-                labelsObj[kv.first.c_str()] = kv.second;
-            }
-        }
-    }
-
-    String json;
-    serializeJson(doc, json);
-
-    ctx.udp->beginPacket(ctx.udp->remoteIP(), ctx.config.udp_port);
-    String msg = String(ClusterProtocol::NODE_INFO_MSG) + ":" + ctx.hostname + ":" + json;
-    ctx.udp->write(msg.c_str());
-    ctx.udp->endPacket();
-}
-
-void ClusterManager::onResponse(const char* msg) {
-    char* hostPtr = const_cast<char*>(msg) + strlen(ClusterProtocol::RESPONSE_MSG) + 1;
-    String nodeHost = String(hostPtr);
-    addOrUpdateNode(nodeHost, ctx.udp->remoteIP());
-}
-
-void ClusterManager::onNodeInfo(const char* msg) {
-    char* p = const_cast<char*>(msg) + strlen(ClusterProtocol::NODE_INFO_MSG) + 1;
-    char* hostEnd = strchr(p, ':');
-    if (hostEnd) {
-        *hostEnd = '\0';
-        const char* hostCStr = p;
-        const char* jsonCStr = hostEnd + 1;
-
-        String nodeHost = String(hostCStr);
-        IPAddress senderIP = ctx.udp->remoteIP();
-
-        addOrUpdateNode(nodeHost, senderIP);
-
-        JsonDocument doc;
-        DeserializationError err = deserializeJson(doc, jsonCStr);
-        if (!err) {
-            auto& memberList = *ctx.memberList;
-            auto it = memberList.find(nodeHost);
-            if (it != memberList.end()) {
-                NodeInfo& node = it->second;
-                node.resources.freeHeap = doc["freeHeap"] | node.resources.freeHeap;
-                node.resources.chipId = doc["chipId"] | node.resources.chipId;
-                {
-                    const char* sdk = doc["sdkVersion"] | node.resources.sdkVersion.c_str();
-                    node.resources.sdkVersion = sdk ? String(sdk) : node.resources.sdkVersion;
-                }
-                node.resources.cpuFreqMHz = doc["cpuFreqMHz"] | node.resources.cpuFreqMHz;
-                node.resources.flashChipSize = doc["flashChipSize"] | node.resources.flashChipSize;
-                node.status = NodeInfo::ACTIVE;
-                unsigned long now = millis();
-                node.lastSeen = now;
-                if (lastHeartbeatSentAt != 0) {
-                    node.latency = now - lastHeartbeatSentAt;
-                }
-
-                node.labels.clear();
-                if (doc["labels"].is<JsonObject>()) {
-                    JsonObject labelsObj = doc["labels"].as<JsonObject>();
-                    for (JsonPair kvp : labelsObj) {
-                        const char* key = kvp.key().c_str();
-                        const char* value = labelsObj[kvp.key()];
-                        node.labels[key] = value;
-                    }
-                }
-            }
-        } else {
-            LOG_WARN("Cluster", String("Failed to parse NODE_INFO JSON from ") + senderIP.toString());
-        }
-    }
-}
-
-void ClusterManager::onClusterEvent(const char* msg) {
-    // Message format: CLUSTER_EVENT:{"event":"...","data":"<json string>"}
-    const char* jsonStart = msg + strlen(ClusterProtocol::CLUSTER_EVENT_MSG) + 1; // skip prefix and ':'
-    if (*jsonStart == '\0') {
-        LOG_DEBUG("Cluster", "CLUSTER_EVENT received with empty payload");
-        return;
-    }
-    LOG_DEBUG("Cluster", String("CLUSTER_EVENT raw from ") + ctx.udp->remoteIP().toString() + " len=" + String(strlen(jsonStart)));
-    JsonDocument doc;
-    DeserializationError err = deserializeJson(doc, jsonStart);
-    if (err) {
-        LOG_ERROR("Cluster", String("Failed to parse CLUSTER_EVENT JSON from ") + ctx.udp->remoteIP().toString());
-        return;
-    }
-    // Robust extraction of event and data
-    String eventStr;
-    if (doc["event"].is<const char*>()) {
-        eventStr = doc["event"].as<const char*>();
-    } else if (doc["event"].is<String>()) {
-        eventStr = doc["event"].as<String>();
-    }
-
-    String data;
-    if (doc["data"].is<const char*>()) {
-        data = doc["data"].as<const char*>();
-    } else if (doc["data"].is<JsonVariantConst>()) {
-        // If data is a nested JSON object/array, serialize it back to string
-        String tmp;
-        serializeJson(doc["data"], tmp);
-        data = tmp;
-    }
-
-    if (eventStr.length() == 0 || data.length() == 0) {
-        String dbg;
-        serializeJson(doc, dbg);
-        LOG_WARN("Cluster", String("CLUSTER_EVENT missing 'event' or 'data' | payload=") + dbg);
-        return;
-    }
-
-    std::string eventKey(eventStr.c_str());
-    LOG_DEBUG("Cluster", String("Firing event '") + eventStr + "' with dataLen=" + String(data.length()));
-    ctx.fire(eventKey, &data);
 }

 void ClusterManager::addOrUpdateNode(const String& nodeHost, IPAddress nodeIP) {
@@ -271,7 +71,7 @@ void ClusterManager::addOrUpdateNode(const String& nodeHost, IPAddress nodeIP) {
    newNode.hostname = nodeHost;
    newNode.ip = nodeIP;
    newNode.lastSeen = millis();
-    updateNodeStatus(newNode, newNode.lastSeen, ctx.config.node_inactive_threshold_ms, ctx.config.node_dead_threshold_ms);
+            updateNodeStatus(newNode, newNode.lastSeen, ctx.config.node_inactive_threshold_ms, ctx.config.node_dead_threshold_ms);
    memberList[nodeHost] = newNode;
    LOG_INFO("Cluster", "Added node: " + nodeHost + " @ " + newNode.ip.toString() + " | Status: " + statusToStr(newNode.status) + " | last update: 0");
    //fetchNodeInfo(nodeIP); // Do not fetch here, handled by periodic task
@@ -394,18 +194,31 @@ void ClusterManager::heartbeatTaskCallback() {
        updateLocalNodeResources();
        ctx.fire("node_discovered", &node);
    }
-
-    // Broadcast heartbeat so peers can respond with their node info
-    lastHeartbeatSentAt = millis();
-    ctx.udp->beginPacket("255.255.255.255", ctx.config.udp_port);
-    String hb = String(ClusterProtocol::HEARTBEAT_MSG) + ":" + ctx.hostname;
-    ctx.udp->write(hb.c_str());
-    ctx.udp->endPacket();
 }

 void ClusterManager::updateAllMembersInfoTaskCallback() {
-    // HTTP-based member info fetching disabled; node info is provided via UDP responses to heartbeats
-    // No-op to reduce network and memory usage
+    auto& memberList = *ctx.memberList;
+    
+    // Limit concurrent HTTP requests to prevent memory pressure
+    const size_t maxConcurrentRequests = ctx.config.max_concurrent_http_requests;
+    size_t requestCount = 0;
+    
+    for (auto& pair : memberList) {
+        const NodeInfo& node = pair.second;
+        if (node.ip != ctx.localIP) {
+            // Only process a limited number of requests per cycle
+            if (requestCount >= maxConcurrentRequests) {
+                LOG_DEBUG("Cluster", "Limiting concurrent HTTP requests to prevent memory pressure");
+                break;
+            }
+            
+            fetchNodeInfo(node.ip);
+            requestCount++;
+            
+            // Add small delay between requests to prevent overwhelming the system
+            delay(100);
+        }
+    }
 }

 void ClusterManager::updateAllNodeStatuses() {
--- a/src/spore/core/NodeContext.cpp
+++ b/src/spore/core/NodeContext.cpp
@@ -29,11 +29,4 @@ void NodeContext::fire(const std::string& event, void* data) {
    for (auto& cb : eventRegistry[event]) {
        cb(data);
    }
-    for (auto& acb : anyEventSubscribers) {
-        acb(event, data);
-    }
-}
-
-void NodeContext::onAny(AnyEventCallback cb) {
-    anyEventSubscribers.push_back(cb);
 }
--- a/src/spore/services/ClusterService.cpp
+++ b/src/spore/services/ClusterService.cpp
@@ -1,65 +1,19 @@
 #include "spore/services/ClusterService.h"
 #include "spore/core/ApiServer.h"
+#include "spore/types/ClusterResponse.h"
+
+using spore::types::ClusterMembersResponse;

 ClusterService::ClusterService(NodeContext& ctx) : ctx(ctx) {}

 void ClusterService::registerEndpoints(ApiServer& api) {
    api.addEndpoint("/api/cluster/members", HTTP_GET,
        [this](AsyncWebServerRequest* request) { handleMembersRequest(request); },
-        std::vector<ParamSpec>{});
-
-    // Generic cluster broadcast endpoint
-    api.addEndpoint("/api/cluster/event", HTTP_POST,
-        [this](AsyncWebServerRequest* request) {
-            if (!request->hasParam("event", true) || !request->hasParam("payload", true)) {
-                request->send(400, "application/json", "{\"error\":\"Missing 'event' or 'payload'\"}");
-                return;
-            }
-            String eventName = request->getParam("event", true)->value();
-            String payloadStr = request->getParam("payload", true)->value();
-            JsonDocument envelope;
-            envelope["event"] = eventName;
-            envelope["data"] = payloadStr; // pass payload as JSON string
-            String eventJson;
-            serializeJson(envelope, eventJson);
-            std::string ev = "cluster/broadcast";
-            ctx.fire(ev, &eventJson);
-            request->send(200, "application/json", "{\"ok\":true}");
-        },
-        std::vector<ParamSpec>{
-            ParamSpec{String("event"), true, String("body"), String("string"), {}},
-            ParamSpec{String("payload"), true, String("body"), String("string"), {}}
-        });
+        std::vector<ParamSpec>{}, "ClusterService");
 }

 void ClusterService::handleMembersRequest(AsyncWebServerRequest* request) {
-    JsonDocument doc;
-    JsonArray arr = doc["members"].to<JsonArray>();
-    
-    for (const auto& pair : *ctx.memberList) {
-        const NodeInfo& node = pair.second;
-        JsonObject obj = arr.add<JsonObject>();
-        obj["hostname"] = node.hostname;
-        obj["ip"] = node.ip.toString();
-        obj["lastSeen"] = node.lastSeen;
-        obj["latency"] = node.latency;
-        obj["status"] = statusToStr(node.status);
-        obj["resources"]["freeHeap"] = node.resources.freeHeap;
-        obj["resources"]["chipId"] = node.resources.chipId;
-        obj["resources"]["sdkVersion"] = node.resources.sdkVersion;
-        obj["resources"]["cpuFreqMHz"] = node.resources.cpuFreqMHz;
-        obj["resources"]["flashChipSize"] = node.resources.flashChipSize;
-
-        // Add labels if present
-        if (!node.labels.empty()) {
-            JsonObject labelsObj = obj["labels"].to<JsonObject>();
-            for (const auto& kv : node.labels) {
-                labelsObj[kv.first.c_str()] = kv.second;
-            }
-        }
-    }
-
-    String json;
-    serializeJson(doc, json);
-    request->send(200, "application/json", json);
+    ClusterMembersResponse response;
+    response.addNodes(ctx.memberList);
+    request->send(200, "application/json", response.toJsonString());
 }
--- a/src/spore/services/MonitoringService.cpp
+++ b/src/spore/services/MonitoringService.cpp
@@ -12,7 +12,7 @@ MonitoringService::MonitoringService(CpuUsage& cpuUsage)
 void MonitoringService::registerEndpoints(ApiServer& api) {
    api.addEndpoint("/api/monitoring/resources", HTTP_GET,
        [this](AsyncWebServerRequest* request) { handleResourcesRequest(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "MonitoringService");
 }

 MonitoringService::SystemResources MonitoringService::getSystemResources() const {
--- a/src/spore/services/NetworkService.cpp
+++ b/src/spore/services/NetworkService.cpp
@@ -8,16 +8,16 @@ void NetworkService::registerEndpoints(ApiServer& api) {
    // WiFi scanning endpoints
    api.addEndpoint("/api/network/wifi/scan", HTTP_POST, 
        [this](AsyncWebServerRequest* request) { handleWifiScanRequest(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "NetworkService");

    api.addEndpoint("/api/network/wifi/scan", HTTP_GET, 
        [this](AsyncWebServerRequest* request) { handleGetWifiNetworks(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "NetworkService");

    // Network status and configuration endpoints
    api.addEndpoint("/api/network/status", HTTP_GET,
        [this](AsyncWebServerRequest* request) { handleNetworkStatus(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "NetworkService");

    api.addEndpoint("/api/network/wifi/config", HTTP_POST,
        [this](AsyncWebServerRequest* request) { handleSetWifiConfig(request); },
@@ -26,7 +26,7 @@ void NetworkService::registerEndpoints(ApiServer& api) {
            ParamSpec{String("password"), true, String("body"), String("string"), {}, String("")},
            ParamSpec{String("connect_timeout_ms"), false, String("body"), String("number"), {}, String("10000")},
            ParamSpec{String("retry_delay_ms"), false, String("body"), String("number"), {}, String("500")}
-        });
+        }, "NetworkService");
 }

 void NetworkService::handleWifiScanRequest(AsyncWebServerRequest* request) {
--- a/src/spore/services/NodeService.cpp
+++ b/src/spore/services/NodeService.cpp
@@ -1,6 +1,11 @@
 #include "spore/services/NodeService.h"
 #include "spore/core/ApiServer.h"
 #include "spore/util/Logging.h"
+#include "spore/types/NodeResponse.h"
+
+using spore::types::NodeStatusResponse;
+using spore::types::NodeOperationResponse;
+using spore::types::NodeEndpointsResponse;

 NodeService::NodeService(NodeContext& ctx, ApiServer& apiServer) : ctx(ctx), apiServer(apiServer) {}

@@ -8,7 +13,7 @@ void NodeService::registerEndpoints(ApiServer& api) {
    // Status endpoint
    api.addEndpoint("/api/node/status", HTTP_GET,
        [this](AsyncWebServerRequest* request) { handleStatusRequest(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "NodeService");
    
    // Update endpoint with file upload
    api.addEndpoint("/api/node/update", HTTP_POST,
@@ -18,72 +23,45 @@ void NodeService::registerEndpoints(ApiServer& api) {
        },
        std::vector<ParamSpec>{
            ParamSpec{String("firmware"), true, String("body"), String("file"), {}, String("")}
-        });
+        }, "NodeService");
    
    // Restart endpoint
    api.addEndpoint("/api/node/restart", HTTP_POST,
        [this](AsyncWebServerRequest* request) { handleRestartRequest(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "NodeService");
        
    // Endpoints endpoint
    api.addEndpoint("/api/node/endpoints", HTTP_GET,
        [this](AsyncWebServerRequest* request) { handleEndpointsRequest(request); },
-        std::vector<ParamSpec>{});
-
-    // Generic local event endpoint
-    api.addEndpoint("/api/node/event", HTTP_POST,
-        [this](AsyncWebServerRequest* request) {
-            if (!request->hasParam("event", true) || !request->hasParam("payload", true)) {
-                request->send(400, "application/json", "{\"error\":\"Missing 'event' or 'payload'\"}");
-                return;
-            }
-            String eventName = request->getParam("event", true)->value();
-            String payloadStr = request->getParam("payload", true)->value();
-            std::string ev = eventName.c_str();
-            ctx.fire(ev, &payloadStr);
-            request->send(200, "application/json", "{\"ok\":true}");
-        },
-        std::vector<ParamSpec>{
-            ParamSpec{String("event"), true, String("body"), String("string"), {}},
-            ParamSpec{String("payload"), true, String("body"), String("string"), {}}
-        });
+        std::vector<ParamSpec>{}, "NodeService");
 }

 void NodeService::handleStatusRequest(AsyncWebServerRequest* request) {
-    JsonDocument doc;
-    doc["freeHeap"] = ESP.getFreeHeap();
-    doc["chipId"] = ESP.getChipId();
-    doc["sdkVersion"] = ESP.getSdkVersion();
-    doc["cpuFreqMHz"] = ESP.getCpuFreqMHz();
-    doc["flashChipSize"] = ESP.getFlashChipSize();
+    NodeStatusResponse response;
    
-    // Include local node labels if present
+    // Get labels from member list or self
+    std::map<String, String> labels;
    if (ctx.memberList) {
        auto it = ctx.memberList->find(ctx.hostname);
        if (it != ctx.memberList->end()) {
-            JsonObject labelsObj = doc["labels"].to<JsonObject>();
-            for (const auto& kv : it->second.labels) {
-                labelsObj[kv.first.c_str()] = kv.second;
-            }
+            labels = it->second.labels;
        } else if (!ctx.self.labels.empty()) {
-            JsonObject labelsObj = doc["labels"].to<JsonObject>();
-            for (const auto& kv : ctx.self.labels) {
-                labelsObj[kv.first.c_str()] = kv.second;
-            }
+            labels = ctx.self.labels;
        }
    }
    
-    String json;
-    serializeJson(doc, json);
-    request->send(200, "application/json", json);
+    response.buildCompleteResponse(labels);
+    request->send(200, "application/json", response.toJsonString());
 }

 void NodeService::handleUpdateRequest(AsyncWebServerRequest* request) {
    bool success = !Update.hasError();
-    AsyncWebServerResponse* response = request->beginResponse(200, "application/json", 
-        success ? "{\"status\": \"OK\"}" : "{\"status\": \"FAIL\"}");
-    response->addHeader("Connection", "close");
-    request->send(response);
+    NodeOperationResponse response;
+    response.setSuccess(success ? "OK" : "FAIL");
+    
+    AsyncWebServerResponse* httpResponse = request->beginResponse(200, "application/json", response.toJsonString());
+    httpResponse->addHeader("Connection", "close");
+    request->send(httpResponse);
    request->onDisconnect([this]() {
        LOG_INFO("API", "Restart device");
        delay(10);
@@ -126,10 +104,12 @@ void NodeService::handleUpdateUpload(AsyncWebServerRequest* request, const Strin
 }

 void NodeService::handleRestartRequest(AsyncWebServerRequest* request) {
-    AsyncWebServerResponse* response = request->beginResponse(200, "application/json", 
-        "{\"status\": \"restarting\"}");
-    response->addHeader("Connection", "close");
-    request->send(response);
+    NodeOperationResponse response;
+    response.setSuccess("restarting");
+    
+    AsyncWebServerResponse* httpResponse = request->beginResponse(200, "application/json", response.toJsonString());
+    httpResponse->addHeader("Connection", "close");
+    request->send(httpResponse);
    request->onDisconnect([this]() {
        LOG_INFO("API", "Restart device");
        delay(10);
@@ -138,36 +118,7 @@ void NodeService::handleRestartRequest(AsyncWebServerRequest* request) {
 }

 void NodeService::handleEndpointsRequest(AsyncWebServerRequest* request) {
-    JsonDocument doc;
-    JsonArray endpointsArr = doc["endpoints"].to<JsonArray>();
-
-    // Add all registered endpoints from ApiServer
-    for (const auto& endpoint : apiServer.getEndpoints()) {
-        JsonObject obj = endpointsArr.add<JsonObject>();
-        obj["uri"] = endpoint.uri;
-        obj["method"] = ApiServer::methodToStr(endpoint.method);
-        if (!endpoint.params.empty()) {
-            JsonArray paramsArr = obj["params"].to<JsonArray>();
-            for (const auto& ps : endpoint.params) {
-                JsonObject p = paramsArr.add<JsonObject>();
-                p["name"] = ps.name;
-                p["location"] = ps.location;
-                p["required"] = ps.required;
-                p["type"] = ps.type;
-                if (!ps.values.empty()) {
-                    JsonArray allowed = p["values"].to<JsonArray>();
-                    for (const auto& v : ps.values) {
-                        allowed.add(v);
-                    }
-                }
-                if (ps.defaultValue.length() > 0) {
-                    p["default"] = ps.defaultValue;
-                }
-            }
-        }
-    }
-
-    String json;
-    serializeJson(doc, json);
-    request->send(200, "application/json", json);
+    NodeEndpointsResponse response;
+    response.addEndpoints(apiServer.getEndpoints());
+    request->send(200, "application/json", response.toJsonString());
 }
--- a/src/spore/services/TaskService.cpp
+++ b/src/spore/services/TaskService.cpp
@@ -1,13 +1,17 @@
 #include "spore/services/TaskService.h"
 #include "spore/core/ApiServer.h"
+#include "spore/types/TaskResponse.h"
 #include <algorithm>

+using spore::types::TaskStatusResponse;
+using spore::types::TaskControlResponse;
+
 TaskService::TaskService(TaskManager& taskManager) : taskManager(taskManager) {}

 void TaskService::registerEndpoints(ApiServer& api) {
    api.addEndpoint("/api/tasks/status", HTTP_GET,
        [this](AsyncWebServerRequest* request) { handleStatusRequest(request); },
-        std::vector<ParamSpec>{});
+        std::vector<ParamSpec>{}, "TaskService");
        
    api.addEndpoint("/api/tasks/control", HTTP_POST,
        [this](AsyncWebServerRequest* request) { handleControlRequest(request); },
@@ -28,36 +32,19 @@ void TaskService::registerEndpoints(ApiServer& api) {
                {String("enable"), String("disable"), String("start"), String("stop"), String("status")},
                String("")
            }
-        });
+        }, "TaskService");
 }

 void TaskService::handleStatusRequest(AsyncWebServerRequest* request) {
+    TaskStatusResponse response;
+    
+    // Get task statuses using a separate document to avoid reference issues
    JsonDocument scratch;
    auto taskStatuses = taskManager.getAllTaskStatuses(scratch);
    
-    JsonDocument doc;
-    JsonObject summaryObj = doc["summary"].to<JsonObject>();
-    summaryObj["totalTasks"] = taskStatuses.size();
-    summaryObj["activeTasks"] = std::count_if(taskStatuses.begin(), taskStatuses.end(),
-        [](const auto& pair) { return pair.second["enabled"]; });
-    
-    JsonArray tasksArr = doc["tasks"].to<JsonArray>();
-    for (const auto& taskPair : taskStatuses) {
-        JsonObject taskObj = tasksArr.add<JsonObject>();
-        taskObj["name"] = taskPair.first;
-        taskObj["interval"] = taskPair.second["interval"];
-        taskObj["enabled"] = taskPair.second["enabled"];
-        taskObj["running"] = taskPair.second["running"];
-        taskObj["autoStart"] = taskPair.second["autoStart"];
-    }
-    
-    JsonObject systemObj = doc["system"].to<JsonObject>();
-    systemObj["freeHeap"] = ESP.getFreeHeap();
-    systemObj["uptime"] = millis();
-    
-    String json;
-    serializeJson(doc, json);
-    request->send(200, "application/json", json);
+    // Build the complete response with the task data
+    response.buildCompleteResponse(taskStatuses);
+    request->send(200, "application/json", response.toJsonString());
 }

 void TaskService::handleControlRequest(AsyncWebServerRequest* request) {
@@ -88,50 +75,27 @@ void TaskService::handleControlRequest(AsyncWebServerRequest* request) {
            success = true;
            message = "Task status retrieved";
            
-            JsonDocument statusDoc;
-            statusDoc["success"] = success;
-            statusDoc["message"] = message;
-            statusDoc["task"] = taskName;
-            statusDoc["action"] = action;
+            TaskControlResponse response;
+            response.setResponse(success, message, taskName, action);
+            response.addTaskDetails(taskName, 
+                taskManager.isTaskEnabled(taskName.c_str()),
+                taskManager.isTaskRunning(taskName.c_str()),
+                taskManager.getTaskInterval(taskName.c_str()));
            
-            statusDoc["taskDetails"] = JsonObject();
-            JsonObject taskDetails = statusDoc["taskDetails"];
-            taskDetails["name"] = taskName;
-            taskDetails["enabled"] = taskManager.isTaskEnabled(taskName.c_str());
-            taskDetails["running"] = taskManager.isTaskRunning(taskName.c_str());
-            taskDetails["interval"] = taskManager.getTaskInterval(taskName.c_str());
-            
-            taskDetails["system"] = JsonObject();
-            JsonObject systemInfo = taskDetails["system"];
-            systemInfo["freeHeap"] = ESP.getFreeHeap();
-            systemInfo["uptime"] = millis();
-            
-            String statusJson;
-            serializeJson(statusDoc, statusJson);
-            request->send(200, "application/json", statusJson);
+            request->send(200, "application/json", response.toJsonString());
            return;
        } else {
            success = false;
            message = "Invalid action. Use: enable, disable, start, stop, or status";
        }
        
-        JsonDocument doc;
-        doc["success"] = success;
-        doc["message"] = message;
-        doc["task"] = taskName;
-        doc["action"] = action;
-        
-        String json;
-        serializeJson(doc, json);
-        request->send(success ? 200 : 400, "application/json", json);
+        TaskControlResponse response;
+        response.setResponse(success, message, taskName, action);
+        request->send(success ? 200 : 400, "application/json", response.toJsonString());
    } else {
-        JsonDocument doc;
-        doc["success"] = false;
-        doc["message"] = "Missing parameters. Required: task, action";
-        doc["example"] = "{\"task\": \"discovery_send\", \"action\": \"status\"}";
-        
-        String json;
-        serializeJson(doc, json);
-        request->send(400, "application/json", json);
+        TaskControlResponse response;
+        response.setError("Missing parameters. Required: task, action", 
+            "{\"task\": \"discovery_send\", \"action\": \"status\"}");
+        request->send(400, "application/json", response.toJsonString());
    }
 }
--- a/src/spore/types/Config.cpp
+++ b/src/spore/types/Config.cpp
@@ -10,11 +10,10 @@ Config::Config() {
    api_server_port = 80;
    
    // Cluster Configuration
-    discovery_interval_ms = 1000; // TODO retire this in favor of heartbeat_interval_ms
-    cluster_listen_interval_ms = 10;
-    heartbeat_interval_ms = 5000;
+    discovery_interval_ms = 1000;
+    heartbeat_interval_ms = 2000;
    status_update_interval_ms = 1000;
-    member_info_update_interval_ms = 10000; // TODO retire this in favor of heartbeat_interval_ms
+    member_info_update_interval_ms = 10000;
    print_interval_ms = 5000;
    
    // Node Status Thresholds
--- a/test/README
+++ b/test/README
@@ -1,64 +1,11 @@
-# Test Scripts

-This directory contains JavaScript test scripts to interact with the Spore device, primarily for testing cluster event broadcasting.
+This directory is intended for PlatformIO Test Runner and project tests.

-## Prerequisites
-
-These scripts require [Node.js](https://nodejs.org/) to be installed on your system.
-
-## How to Run
-
-### 1. HTTP Cluster Broadcast Color (`test/http-cluster-broadcast-color.js`)
-
-This script sends HTTP POST requests to the `/api/cluster/event` endpoint on your Spore device. It broadcasts NeoPattern color changes across the cluster every 5 seconds.
-
-**Usage:**
-```
-node test/http-cluster-broadcast-color.js <device-ip>
-```
-Example:
-```
-node test/http-cluster-broadcast-color.js 10.0.1.53
-```
-This will broadcast `{ event: "api/neopattern/color", data: { color: "#RRGGBB", brightness: 128 } }` every 5 seconds to the cluster via `/api/cluster/event`.
-
-### 2. WS Local Color Setter (`test/ws-color-client.js`)
-
-Connects to the device WebSocket (`/ws`) and sets a solid color locally (non-broadcast) every 5 seconds by firing `api/neopattern/color`.
-
-**Usage:**
-```
-node test/ws-color-client.js ws://<device-ip>/ws
-```
-Example:
-```
-node test/ws-color-client.js ws://10.0.1.53/ws
-```
-
-### 3. WS Cluster Broadcast Color (`test/ws-cluster-broadcast-color.js`)
-
-Connects to the device WebSocket (`/ws`) and broadcasts a color change to all peers every 5 seconds by firing `cluster/broadcast` with the proper envelope.
-
-**Usage:**
-```
-node test/ws-cluster-broadcast-color.js ws://<device-ip>/ws
-```
-Example:
-```
-node test/ws-cluster-broadcast-color.js ws://10.0.1.53/ws
-```
-
-### 4. WS Cluster Broadcast Rainbow (`test/ws-cluster-broadcast-rainbow.js`)
-
-Broadcasts a smooth rainbow color transition over WebSocket using `cluster/broadcast` and the `api/neopattern/color` event. Update rate defaults to `UPDATE_RATE` in the script (e.g., 100 ms).
-
-**Usage:**
-```
-node test/ws-cluster-broadcast-rainbow.js ws://<device-ip>/ws
-```
-Example:
-```
-node test/ws-cluster-broadcast-rainbow.js ws://10.0.1.53/ws
-```
-Note: Very fast update intervals (e.g., 10 ms) may saturate links or the device.
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.

+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html
--- a/test/http-cluster-broadcast-color.js
+++ b/test/http-cluster-broadcast-color.js
@@ -1,52 +0,0 @@
-// Simple HTTP client to broadcast a neopattern color change to the cluster
-// Usage: node cluster-broadcast-color.js 10.0.1.53
-
-const http = require('http');
-
-const host = process.argv[2] || '127.0.0.1';
-const port = 80;
-
-const colors = ['#FF0000', '#00FF00', '#0000FF', '#FFFF00', '#FF00FF', '#00FFFF'];
-let idx = 0;
-
-function postClusterEvent(event, payloadObj) {
-  const payload = encodeURIComponent(JSON.stringify(payloadObj));
-  const body = `event=${encodeURIComponent(event)}&payload=${payload}`;
-
-  const options = {
-    host,
-    port,
-    path: '/api/cluster/event',
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'Content-Length': Buffer.byteLength(body)
-    }
-  };
-
-  const req = http.request(options, (res) => {
-    let data = '';
-    res.on('data', (chunk) => (data += chunk));
-    res.on('end', () => {
-      console.log('Response:', res.statusCode, data);
-    });
-  });
-
-  req.on('error', (err) => {
-    console.error('Request error:', err.message);
-  });
-
-  req.write(body);
-  req.end();
-}
-
-console.log(`Broadcasting color changes to http://${host}/api/cluster/event ...`);
-setInterval(() => {
-  const color = colors[idx % colors.length];
-  idx++;
-  const payload = { color, brightness: 128 };
-  console.log('Broadcasting color:', payload);
-  postClusterEvent('api/neopattern/color', payload);
-}, 5000);
-
-
--- a/test/node_modules/.package-lock.json
+++ b/test/node_modules/.package-lock.json
@@ -1,28 +0,0 @@
-{
-  "name": "test",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "node_modules/ws": {
-      "version": "8.18.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
-      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    }
-  }
-}
--- a/test/node_modules/ws/LICENSE
+++ b/test/node_modules/ws/LICENSE
@@ -1,20 +0,0 @@
-Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
-Copyright (c) 2013 Arnout Kazemier and contributors
-Copyright (c) 2016 Luigi Pinca and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/test/node_modules/ws/README.md
+++ b/test/node_modules/ws/README.md
@@ -1,548 +0,0 @@
-# ws: a Node.js WebSocket library
-
-[![Version npm](https://img.shields.io/npm/v/ws.svg?logo=npm)](https://www.npmjs.com/package/ws)
-[![CI](https://img.shields.io/github/actions/workflow/status/websockets/ws/ci.yml?branch=master&label=CI&logo=github)](https://github.com/websockets/ws/actions?query=workflow%3ACI+branch%3Amaster)
-[![Coverage Status](https://img.shields.io/coveralls/websockets/ws/master.svg?logo=coveralls)](https://coveralls.io/github/websockets/ws)
-
-ws is a simple to use, blazing fast, and thoroughly tested WebSocket client and
-server implementation.
-
-Passes the quite extensive Autobahn test suite: [server][server-report],
-[client][client-report].
-
-**Note**: This module does not work in the browser. The client in the docs is a
-reference to a backend with the role of a client in the WebSocket communication.
-Browser clients must use the native
-[`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
-object. To make the same code work seamlessly on Node.js and the browser, you
-can use one of the many wrappers available on npm, like
-[isomorphic-ws](https://github.com/heineiuo/isomorphic-ws).
-
-## Table of Contents
-
- [Protocol support](#protocol-support)
- [Installing](#installing)
-  - [Opt-in for performance](#opt-in-for-performance)
-    - [Legacy opt-in for performance](#legacy-opt-in-for-performance)
- [API docs](#api-docs)
- [WebSocket compression](#websocket-compression)
- [Usage examples](#usage-examples)
-  - [Sending and receiving text data](#sending-and-receiving-text-data)
-  - [Sending binary data](#sending-binary-data)
-  - [Simple server](#simple-server)
-  - [External HTTP/S server](#external-https-server)
-  - [Multiple servers sharing a single HTTP/S server](#multiple-servers-sharing-a-single-https-server)
-  - [Client authentication](#client-authentication)
-  - [Server broadcast](#server-broadcast)
-  - [Round-trip time](#round-trip-time)
-  - [Use the Node.js streams API](#use-the-nodejs-streams-api)
-  - [Other examples](#other-examples)
- [FAQ](#faq)
-  - [How to get the IP address of the client?](#how-to-get-the-ip-address-of-the-client)
-  - [How to detect and close broken connections?](#how-to-detect-and-close-broken-connections)
-  - [How to connect via a proxy?](#how-to-connect-via-a-proxy)
- [Changelog](#changelog)
- [License](#license)
-
-## Protocol support
-
- **HyBi drafts 07-12** (Use the option `protocolVersion: 8`)
- **HyBi drafts 13-17** (Current default, alternatively option
-  `protocolVersion: 13`)
-
-## Installing
-
-```
-npm install ws
-```
-
-### Opt-in for performance
-
-[bufferutil][] is an optional module that can be installed alongside the ws
-module:
-
-```
-npm install --save-optional bufferutil
-```
-
-This is a binary addon that improves the performance of certain operations such
-as masking and unmasking the data payload of the WebSocket frames. Prebuilt
-binaries are available for the most popular platforms, so you don't necessarily
-need to have a C++ compiler installed on your machine.
-
-To force ws to not use bufferutil, use the
-[`WS_NO_BUFFER_UTIL`](./doc/ws.md#ws_no_buffer_util) environment variable. This
-can be useful to enhance security in systems where a user can put a package in
-the package search path of an application of another user, due to how the
-Node.js resolver algorithm works.
-
-#### Legacy opt-in for performance
-
-If you are running on an old version of Node.js (prior to v18.14.0), ws also
-supports the [utf-8-validate][] module:
-
-```
-npm install --save-optional utf-8-validate
-```
-
-This contains a binary polyfill for [`buffer.isUtf8()`][].
-
-To force ws not to use utf-8-validate, use the
-[`WS_NO_UTF_8_VALIDATE`](./doc/ws.md#ws_no_utf_8_validate) environment variable.
-
-## API docs
-
-See [`/doc/ws.md`](./doc/ws.md) for Node.js-like documentation of ws classes and
-utility functions.
-
-## WebSocket compression
-
-ws supports the [permessage-deflate extension][permessage-deflate] which enables
-the client and server to negotiate a compression algorithm and its parameters,
-and then selectively apply it to the data payloads of each WebSocket message.
-
-The extension is disabled by default on the server and enabled by default on the
-client. It adds a significant overhead in terms of performance and memory
-consumption so we suggest to enable it only if it is really needed.
-
-Note that Node.js has a variety of issues with high-performance compression,
-where increased concurrency, especially on Linux, can lead to [catastrophic
-memory fragmentation][node-zlib-bug] and slow performance. If you intend to use
-permessage-deflate in production, it is worthwhile to set up a test
-representative of your workload and ensure Node.js/zlib will handle it with
-acceptable performance and memory usage.
-
-Tuning of permessage-deflate can be done via the options defined below. You can
-also use `zlibDeflateOptions` and `zlibInflateOptions`, which is passed directly
-into the creation of [raw deflate/inflate streams][node-zlib-deflaterawdocs].
-
-See [the docs][ws-server-options] for more options.
-
-```js
-import WebSocket, { WebSocketServer } from 'ws';
-
-const wss = new WebSocketServer({
-  port: 8080,
-  perMessageDeflate: {
-    zlibDeflateOptions: {
-      // See zlib defaults.
-      chunkSize: 1024,
-      memLevel: 7,
-      level: 3
-    },
-    zlibInflateOptions: {
-      chunkSize: 10 * 1024
-    },
-    // Other options settable:
-    clientNoContextTakeover: true, // Defaults to negotiated value.
-    serverNoContextTakeover: true, // Defaults to negotiated value.
-    serverMaxWindowBits: 10, // Defaults to negotiated value.
-    // Below options specified as default values.
-    concurrencyLimit: 10, // Limits zlib concurrency for perf.
-    threshold: 1024 // Size (in bytes) below which messages
-    // should not be compressed if context takeover is disabled.
-  }
-});
-```
-
-The client will only use the extension if it is supported and enabled on the
-server. To always disable the extension on the client, set the
-`perMessageDeflate` option to `false`.
-
-```js
-import WebSocket from 'ws';
-
-const ws = new WebSocket('ws://www.host.com/path', {
-  perMessageDeflate: false
-});
-```
-
-## Usage examples
-
-### Sending and receiving text data
-
-```js
-import WebSocket from 'ws';
-
-const ws = new WebSocket('ws://www.host.com/path');
-
-ws.on('error', console.error);
-
-ws.on('open', function open() {
-  ws.send('something');
-});
-
-ws.on('message', function message(data) {
-  console.log('received: %s', data);
-});
-```
-
-### Sending binary data
-
-```js
-import WebSocket from 'ws';
-
-const ws = new WebSocket('ws://www.host.com/path');
-
-ws.on('error', console.error);
-
-ws.on('open', function open() {
-  const array = new Float32Array(5);
-
-  for (var i = 0; i < array.length; ++i) {
-    array[i] = i / 2;
-  }
-
-  ws.send(array);
-});
-```
-
-### Simple server
-
-```js
-import { WebSocketServer } from 'ws';
-
-const wss = new WebSocketServer({ port: 8080 });
-
-wss.on('connection', function connection(ws) {
-  ws.on('error', console.error);
-
-  ws.on('message', function message(data) {
-    console.log('received: %s', data);
-  });
-
-  ws.send('something');
-});
-```
-
-### External HTTP/S server
-
-```js
-import { createServer } from 'https';
-import { readFileSync } from 'fs';
-import { WebSocketServer } from 'ws';
-
-const server = createServer({
-  cert: readFileSync('/path/to/cert.pem'),
-  key: readFileSync('/path/to/key.pem')
-});
-const wss = new WebSocketServer({ server });
-
-wss.on('connection', function connection(ws) {
-  ws.on('error', console.error);
-
-  ws.on('message', function message(data) {
-    console.log('received: %s', data);
-  });
-
-  ws.send('something');
-});
-
-server.listen(8080);
-```
-
-### Multiple servers sharing a single HTTP/S server
-
-```js
-import { createServer } from 'http';
-import { WebSocketServer } from 'ws';
-
-const server = createServer();
-const wss1 = new WebSocketServer({ noServer: true });
-const wss2 = new WebSocketServer({ noServer: true });
-
-wss1.on('connection', function connection(ws) {
-  ws.on('error', console.error);
-
-  // ...
-});
-
-wss2.on('connection', function connection(ws) {
-  ws.on('error', console.error);
-
-  // ...
-});
-
-server.on('upgrade', function upgrade(request, socket, head) {
-  const { pathname } = new URL(request.url, 'wss://base.url');
-
-  if (pathname === '/foo') {
-    wss1.handleUpgrade(request, socket, head, function done(ws) {
-      wss1.emit('connection', ws, request);
-    });
-  } else if (pathname === '/bar') {
-    wss2.handleUpgrade(request, socket, head, function done(ws) {
-      wss2.emit('connection', ws, request);
-    });
-  } else {
-    socket.destroy();
-  }
-});
-
-server.listen(8080);
-```
-
-### Client authentication
-
-```js
-import { createServer } from 'http';
-import { WebSocketServer } from 'ws';
-
-function onSocketError(err) {
-  console.error(err);
-}
-
-const server = createServer();
-const wss = new WebSocketServer({ noServer: true });
-
-wss.on('connection', function connection(ws, request, client) {
-  ws.on('error', console.error);
-
-  ws.on('message', function message(data) {
-    console.log(`Received message ${data} from user ${client}`);
-  });
-});
-
-server.on('upgrade', function upgrade(request, socket, head) {
-  socket.on('error', onSocketError);
-
-  // This function is not defined on purpose. Implement it with your own logic.
-  authenticate(request, function next(err, client) {
-    if (err || !client) {
-      socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
-      socket.destroy();
-      return;
-    }
-
-    socket.removeListener('error', onSocketError);
-
-    wss.handleUpgrade(request, socket, head, function done(ws) {
-      wss.emit('connection', ws, request, client);
-    });
-  });
-});
-
-server.listen(8080);
-```
-
-Also see the provided [example][session-parse-example] using `express-session`.
-
-### Server broadcast
-
-A client WebSocket broadcasting to all connected WebSocket clients, including
-itself.
-
-```js
-import WebSocket, { WebSocketServer } from 'ws';
-
-const wss = new WebSocketServer({ port: 8080 });
-
-wss.on('connection', function connection(ws) {
-  ws.on('error', console.error);
-
-  ws.on('message', function message(data, isBinary) {
-    wss.clients.forEach(function each(client) {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(data, { binary: isBinary });
-      }
-    });
-  });
-});
-```
-
-A client WebSocket broadcasting to every other connected WebSocket clients,
-excluding itself.
-
-```js
-import WebSocket, { WebSocketServer } from 'ws';
-
-const wss = new WebSocketServer({ port: 8080 });
-
-wss.on('connection', function connection(ws) {
-  ws.on('error', console.error);
-
-  ws.on('message', function message(data, isBinary) {
-    wss.clients.forEach(function each(client) {
-      if (client !== ws && client.readyState === WebSocket.OPEN) {
-        client.send(data, { binary: isBinary });
-      }
-    });
-  });
-});
-```
-
-### Round-trip time
-
-```js
-import WebSocket from 'ws';
-
-const ws = new WebSocket('wss://websocket-echo.com/');
-
-ws.on('error', console.error);
-
-ws.on('open', function open() {
-  console.log('connected');
-  ws.send(Date.now());
-});
-
-ws.on('close', function close() {
-  console.log('disconnected');
-});
-
-ws.on('message', function message(data) {
-  console.log(`Round-trip time: ${Date.now() - data} ms`);
-
-  setTimeout(function timeout() {
-    ws.send(Date.now());
-  }, 500);
-});
-```
-
-### Use the Node.js streams API
-
-```js
-import WebSocket, { createWebSocketStream } from 'ws';
-
-const ws = new WebSocket('wss://websocket-echo.com/');
-
-const duplex = createWebSocketStream(ws, { encoding: 'utf8' });
-
-duplex.on('error', console.error);
-
-duplex.pipe(process.stdout);
-process.stdin.pipe(duplex);
-```
-
-### Other examples
-
-For a full example with a browser client communicating with a ws server, see the
-examples folder.
-
-Otherwise, see the test cases.
-
-## FAQ
-
-### How to get the IP address of the client?
-
-The remote IP address can be obtained from the raw socket.
-
-```js
-import { WebSocketServer } from 'ws';
-
-const wss = new WebSocketServer({ port: 8080 });
-
-wss.on('connection', function connection(ws, req) {
-  const ip = req.socket.remoteAddress;
-
-  ws.on('error', console.error);
-});
-```
-
-When the server runs behind a proxy like NGINX, the de-facto standard is to use
-the `X-Forwarded-For` header.
-
-```js
-wss.on('connection', function connection(ws, req) {
-  const ip = req.headers['x-forwarded-for'].split(',')[0].trim();
-
-  ws.on('error', console.error);
-});
-```
-
-### How to detect and close broken connections?
-
-Sometimes, the link between the server and the client can be interrupted in a
-way that keeps both the server and the client unaware of the broken state of the
-connection (e.g. when pulling the cord).
-
-In these cases, ping messages can be used as a means to verify that the remote
-endpoint is still responsive.
-
-```js
-import { WebSocketServer } from 'ws';
-
-function heartbeat() {
-  this.isAlive = true;
-}
-
-const wss = new WebSocketServer({ port: 8080 });
-
-wss.on('connection', function connection(ws) {
-  ws.isAlive = true;
-  ws.on('error', console.error);
-  ws.on('pong', heartbeat);
-});
-
-const interval = setInterval(function ping() {
-  wss.clients.forEach(function each(ws) {
-    if (ws.isAlive === false) return ws.terminate();
-
-    ws.isAlive = false;
-    ws.ping();
-  });
-}, 30000);
-
-wss.on('close', function close() {
-  clearInterval(interval);
-});
-```
-
-Pong messages are automatically sent in response to ping messages as required by
-the spec.
-
-Just like the server example above, your clients might as well lose connection
-without knowing it. You might want to add a ping listener on your clients to
-prevent that. A simple implementation would be:
-
-```js
-import WebSocket from 'ws';
-
-function heartbeat() {
-  clearTimeout(this.pingTimeout);
-
-  // Use `WebSocket#terminate()`, which immediately destroys the connection,
-  // instead of `WebSocket#close()`, which waits for the close timer.
-  // Delay should be equal to the interval at which your server
-  // sends out pings plus a conservative assumption of the latency.
-  this.pingTimeout = setTimeout(() => {
-    this.terminate();
-  }, 30000 + 1000);
-}
-
-const client = new WebSocket('wss://websocket-echo.com/');
-
-client.on('error', console.error);
-client.on('open', heartbeat);
-client.on('ping', heartbeat);
-client.on('close', function clear() {
-  clearTimeout(this.pingTimeout);
-});
-```
-
-### How to connect via a proxy?
-
-Use a custom `http.Agent` implementation like [https-proxy-agent][] or
-[socks-proxy-agent][].
-
-## Changelog
-
-We're using the GitHub [releases][changelog] for changelog entries.
-
-## License
-
-[MIT](LICENSE)
-
-[`buffer.isutf8()`]: https://nodejs.org/api/buffer.html#bufferisutf8input
-[bufferutil]: https://github.com/websockets/bufferutil
-[changelog]: https://github.com/websockets/ws/releases
-[client-report]: http://websockets.github.io/ws/autobahn/clients/
-[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
-[node-zlib-bug]: https://github.com/nodejs/node/issues/8871
-[node-zlib-deflaterawdocs]:
-  https://nodejs.org/api/zlib.html#zlib_zlib_createdeflateraw_options
-[permessage-deflate]: https://tools.ietf.org/html/rfc7692
-[server-report]: http://websockets.github.io/ws/autobahn/servers/
-[session-parse-example]: ./examples/express-session-parse
-[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
-[utf-8-validate]: https://github.com/websockets/utf-8-validate
-[ws-server-options]: ./doc/ws.md#new-websocketserveroptions-callback
--- a/test/node_modules/ws/browser.js
+++ b/test/node_modules/ws/browser.js
@@ -1,8 +0,0 @@
-'use strict';
-
-module.exports = function () {
-  throw new Error(
-    'ws does not work in the browser. Browser clients must use the native ' +
-      'WebSocket object'
-  );
-};
--- a/test/node_modules/ws/index.js
+++ b/test/node_modules/ws/index.js
@@ -1,13 +0,0 @@
-'use strict';
-
-const WebSocket = require('./lib/websocket');
-
-WebSocket.createWebSocketStream = require('./lib/stream');
-WebSocket.Server = require('./lib/websocket-server');
-WebSocket.Receiver = require('./lib/receiver');
-WebSocket.Sender = require('./lib/sender');
-
-WebSocket.WebSocket = WebSocket;
-WebSocket.WebSocketServer = WebSocket.Server;
-
-module.exports = WebSocket;
--- a/test/node_modules/ws/lib/buffer-util.js
+++ b/test/node_modules/ws/lib/buffer-util.js
@@ -1,131 +0,0 @@
-'use strict';
-
-const { EMPTY_BUFFER } = require('./constants');
-
-const FastBuffer = Buffer[Symbol.species];
-
-/**
- * Merges an array of buffers into a new buffer.
- *
- * @param {Buffer[]} list The array of buffers to concat
- * @param {Number} totalLength The total length of buffers in the list
- * @return {Buffer} The resulting buffer
- * @public
- */
-function concat(list, totalLength) {
-  if (list.length === 0) return EMPTY_BUFFER;
-  if (list.length === 1) return list[0];
-
-  const target = Buffer.allocUnsafe(totalLength);
-  let offset = 0;
-
-  for (let i = 0; i < list.length; i++) {
-    const buf = list[i];
-    target.set(buf, offset);
-    offset += buf.length;
-  }
-
-  if (offset < totalLength) {
-    return new FastBuffer(target.buffer, target.byteOffset, offset);
-  }
-
-  return target;
-}
-
-/**
- * Masks a buffer using the given mask.
- *
- * @param {Buffer} source The buffer to mask
- * @param {Buffer} mask The mask to use
- * @param {Buffer} output The buffer where to store the result
- * @param {Number} offset The offset at which to start writing
- * @param {Number} length The number of bytes to mask.
- * @public
- */
-function _mask(source, mask, output, offset, length) {
-  for (let i = 0; i < length; i++) {
-    output[offset + i] = source[i] ^ mask[i & 3];
-  }
-}
-
-/**
- * Unmasks a buffer using the given mask.
- *
- * @param {Buffer} buffer The buffer to unmask
- * @param {Buffer} mask The mask to use
- * @public
- */
-function _unmask(buffer, mask) {
-  for (let i = 0; i < buffer.length; i++) {
-    buffer[i] ^= mask[i & 3];
-  }
-}
-
-/**
- * Converts a buffer to an `ArrayBuffer`.
- *
- * @param {Buffer} buf The buffer to convert
- * @return {ArrayBuffer} Converted buffer
- * @public
- */
-function toArrayBuffer(buf) {
-  if (buf.length === buf.buffer.byteLength) {
-    return buf.buffer;
-  }
-
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
-}
-
-/**
- * Converts `data` to a `Buffer`.
- *
- * @param {*} data The data to convert
- * @return {Buffer} The buffer
- * @throws {TypeError}
- * @public
- */
-function toBuffer(data) {
-  toBuffer.readOnly = true;
-
-  if (Buffer.isBuffer(data)) return data;
-
-  let buf;
-
-  if (data instanceof ArrayBuffer) {
-    buf = new FastBuffer(data);
-  } else if (ArrayBuffer.isView(data)) {
-    buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
-  } else {
-    buf = Buffer.from(data);
-    toBuffer.readOnly = false;
-  }
-
-  return buf;
-}
-
-module.exports = {
-  concat,
-  mask: _mask,
-  toArrayBuffer,
-  toBuffer,
-  unmask: _unmask
-};
-
-/* istanbul ignore else  */
-if (!process.env.WS_NO_BUFFER_UTIL) {
-  try {
-    const bufferUtil = require('bufferutil');
-
-    module.exports.mask = function (source, mask, output, offset, length) {
-      if (length < 48) _mask(source, mask, output, offset, length);
-      else bufferUtil.mask(source, mask, output, offset, length);
-    };
-
-    module.exports.unmask = function (buffer, mask) {
-      if (buffer.length < 32) _unmask(buffer, mask);
-      else bufferUtil.unmask(buffer, mask);
-    };
-  } catch (e) {
-    // Continue regardless of the error.
-  }
-}
--- a/test/node_modules/ws/lib/constants.js
+++ b/test/node_modules/ws/lib/constants.js
@@ -1,18 +0,0 @@
-'use strict';
-
-const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
-const hasBlob = typeof Blob !== 'undefined';
-
-if (hasBlob) BINARY_TYPES.push('blob');
-
-module.exports = {
-  BINARY_TYPES,
-  EMPTY_BUFFER: Buffer.alloc(0),
-  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
-  hasBlob,
-  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
-  kListener: Symbol('kListener'),
-  kStatusCode: Symbol('status-code'),
-  kWebSocket: Symbol('websocket'),
-  NOOP: () => {}
-};
--- a/test/node_modules/ws/lib/event-target.js
+++ b/test/node_modules/ws/lib/event-target.js
@@ -1,292 +0,0 @@
-'use strict';
-
-const { kForOnEventAttribute, kListener } = require('./constants');
-
-const kCode = Symbol('kCode');
-const kData = Symbol('kData');
-const kError = Symbol('kError');
-const kMessage = Symbol('kMessage');
-const kReason = Symbol('kReason');
-const kTarget = Symbol('kTarget');
-const kType = Symbol('kType');
-const kWasClean = Symbol('kWasClean');
-
-/**
- * Class representing an event.
- */
-class Event {
-  /**
-   * Create a new `Event`.
-   *
-   * @param {String} type The name of the event
-   * @throws {TypeError} If the `type` argument is not specified
-   */
-  constructor(type) {
-    this[kTarget] = null;
-    this[kType] = type;
-  }
-
-  /**
-   * @type {*}
-   */
-  get target() {
-    return this[kTarget];
-  }
-
-  /**
-   * @type {String}
-   */
-  get type() {
-    return this[kType];
-  }
-}
-
-Object.defineProperty(Event.prototype, 'target', { enumerable: true });
-Object.defineProperty(Event.prototype, 'type', { enumerable: true });
-
-/**
- * Class representing a close event.
- *
- * @extends Event
- */
-class CloseEvent extends Event {
-  /**
-   * Create a new `CloseEvent`.
-   *
-   * @param {String} type The name of the event
-   * @param {Object} [options] A dictionary object that allows for setting
-   *     attributes via object members of the same name
-   * @param {Number} [options.code=0] The status code explaining why the
-   *     connection was closed
-   * @param {String} [options.reason=''] A human-readable string explaining why
-   *     the connection was closed
-   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
-   *     connection was cleanly closed
-   */
-  constructor(type, options = {}) {
-    super(type);
-
-    this[kCode] = options.code === undefined ? 0 : options.code;
-    this[kReason] = options.reason === undefined ? '' : options.reason;
-    this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
-  }
-
-  /**
-   * @type {Number}
-   */
-  get code() {
-    return this[kCode];
-  }
-
-  /**
-   * @type {String}
-   */
-  get reason() {
-    return this[kReason];
-  }
-
-  /**
-   * @type {Boolean}
-   */
-  get wasClean() {
-    return this[kWasClean];
-  }
-}
-
-Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
-Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
-Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
-
-/**
- * Class representing an error event.
- *
- * @extends Event
- */
-class ErrorEvent extends Event {
-  /**
-   * Create a new `ErrorEvent`.
-   *
-   * @param {String} type The name of the event
-   * @param {Object} [options] A dictionary object that allows for setting
-   *     attributes via object members of the same name
-   * @param {*} [options.error=null] The error that generated this event
-   * @param {String} [options.message=''] The error message
-   */
-  constructor(type, options = {}) {
-    super(type);
-
-    this[kError] = options.error === undefined ? null : options.error;
-    this[kMessage] = options.message === undefined ? '' : options.message;
-  }
-
-  /**
-   * @type {*}
-   */
-  get error() {
-    return this[kError];
-  }
-
-  /**
-   * @type {String}
-   */
-  get message() {
-    return this[kMessage];
-  }
-}
-
-Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
-Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
-
-/**
- * Class representing a message event.
- *
- * @extends Event
- */
-class MessageEvent extends Event {
-  /**
-   * Create a new `MessageEvent`.
-   *
-   * @param {String} type The name of the event
-   * @param {Object} [options] A dictionary object that allows for setting
-   *     attributes via object members of the same name
-   * @param {*} [options.data=null] The message content
-   */
-  constructor(type, options = {}) {
-    super(type);
-
-    this[kData] = options.data === undefined ? null : options.data;
-  }
-
-  /**
-   * @type {*}
-   */
-  get data() {
-    return this[kData];
-  }
-}
-
-Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
-
-/**
- * This provides methods for emulating the `EventTarget` interface. It's not
- * meant to be used directly.
- *
- * @mixin
- */
-const EventTarget = {
-  /**
-   * Register an event listener.
-   *
-   * @param {String} type A string representing the event type to listen for
-   * @param {(Function|Object)} handler The listener to add
-   * @param {Object} [options] An options object specifies characteristics about
-   *     the event listener
-   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
-   *     listener should be invoked at most once after being added. If `true`,
-   *     the listener would be automatically removed when invoked.
-   * @public
-   */
-  addEventListener(type, handler, options = {}) {
-    for (const listener of this.listeners(type)) {
-      if (
-        !options[kForOnEventAttribute] &&
-        listener[kListener] === handler &&
-        !listener[kForOnEventAttribute]
-      ) {
-        return;
-      }
-    }
-
-    let wrapper;
-
-    if (type === 'message') {
-      wrapper = function onMessage(data, isBinary) {
-        const event = new MessageEvent('message', {
-          data: isBinary ? data : data.toString()
-        });
-
-        event[kTarget] = this;
-        callListener(handler, this, event);
-      };
-    } else if (type === 'close') {
-      wrapper = function onClose(code, message) {
-        const event = new CloseEvent('close', {
-          code,
-          reason: message.toString(),
-          wasClean: this._closeFrameReceived && this._closeFrameSent
-        });
-
-        event[kTarget] = this;
-        callListener(handler, this, event);
-      };
-    } else if (type === 'error') {
-      wrapper = function onError(error) {
-        const event = new ErrorEvent('error', {
-          error,
-          message: error.message
-        });
-
-        event[kTarget] = this;
-        callListener(handler, this, event);
-      };
-    } else if (type === 'open') {
-      wrapper = function onOpen() {
-        const event = new Event('open');
-
-        event[kTarget] = this;
-        callListener(handler, this, event);
-      };
-    } else {
-      return;
-    }
-
-    wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
-    wrapper[kListener] = handler;
-
-    if (options.once) {
-      this.once(type, wrapper);
-    } else {
-      this.on(type, wrapper);
-    }
-  },
-
-  /**
-   * Remove an event listener.
-   *
-   * @param {String} type A string representing the event type to remove
-   * @param {(Function|Object)} handler The listener to remove
-   * @public
-   */
-  removeEventListener(type, handler) {
-    for (const listener of this.listeners(type)) {
-      if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
-        this.removeListener(type, listener);
-        break;
-      }
-    }
-  }
-};
-
-module.exports = {
-  CloseEvent,
-  ErrorEvent,
-  Event,
-  EventTarget,
-  MessageEvent
-};
-
-/**
- * Call an event listener
- *
- * @param {(Function|Object)} listener The listener to call
- * @param {*} thisArg The value to use as `this`` when calling the listener
- * @param {Event} event The event to pass to the listener
- * @private
- */
-function callListener(listener, thisArg, event) {
-  if (typeof listener === 'object' && listener.handleEvent) {
-    listener.handleEvent.call(listener, event);
-  } else {
-    listener.call(thisArg, event);
-  }
-}
--- a/test/node_modules/ws/lib/extension.js
+++ b/test/node_modules/ws/lib/extension.js
@@ -1,203 +0,0 @@
-'use strict';
-
-const { tokenChars } = require('./validation');
-
-/**
- * Adds an offer to the map of extension offers or a parameter to the map of
- * parameters.
- *
- * @param {Object} dest The map of extension offers or parameters
- * @param {String} name The extension or parameter name
- * @param {(Object|Boolean|String)} elem The extension parameters or the
- *     parameter value
- * @private
- */
-function push(dest, name, elem) {
-  if (dest[name] === undefined) dest[name] = [elem];
-  else dest[name].push(elem);
-}
-
-/**
- * Parses the `Sec-WebSocket-Extensions` header into an object.
- *
- * @param {String} header The field value of the header
- * @return {Object} The parsed object
- * @public
- */
-function parse(header) {
-  const offers = Object.create(null);
-  let params = Object.create(null);
-  let mustUnescape = false;
-  let isEscaping = false;
-  let inQuotes = false;
-  let extensionName;
-  let paramName;
-  let start = -1;
-  let code = -1;
-  let end = -1;
-  let i = 0;
-
-  for (; i < header.length; i++) {
-    code = header.charCodeAt(i);
-
-    if (extensionName === undefined) {
-      if (end === -1 && tokenChars[code] === 1) {
-        if (start === -1) start = i;
-      } else if (
-        i !== 0 &&
-        (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
-      ) {
-        if (end === -1 && start !== -1) end = i;
-      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
-        if (start === -1) {
-          throw new SyntaxError(`Unexpected character at index ${i}`);
-        }
-
-        if (end === -1) end = i;
-        const name = header.slice(start, end);
-        if (code === 0x2c) {
-          push(offers, name, params);
-          params = Object.create(null);
-        } else {
-          extensionName = name;
-        }
-
-        start = end = -1;
-      } else {
-        throw new SyntaxError(`Unexpected character at index ${i}`);
-      }
-    } else if (paramName === undefined) {
-      if (end === -1 && tokenChars[code] === 1) {
-        if (start === -1) start = i;
-      } else if (code === 0x20 || code === 0x09) {
-        if (end === -1 && start !== -1) end = i;
-      } else if (code === 0x3b || code === 0x2c) {
-        if (start === -1) {
-          throw new SyntaxError(`Unexpected character at index ${i}`);
-        }
-
-        if (end === -1) end = i;
-        push(params, header.slice(start, end), true);
-        if (code === 0x2c) {
-          push(offers, extensionName, params);
-          params = Object.create(null);
-          extensionName = undefined;
-        }
-
-        start = end = -1;
-      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
-        paramName = header.slice(start, i);
-        start = end = -1;
-      } else {
-        throw new SyntaxError(`Unexpected character at index ${i}`);
-      }
-    } else {
-      //
-      // The value of a quoted-string after unescaping must conform to the
-      // token ABNF, so only token characters are valid.
-      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
-      //
-      if (isEscaping) {
-        if (tokenChars[code] !== 1) {
-          throw new SyntaxError(`Unexpected character at index ${i}`);
-        }
-        if (start === -1) start = i;
-        else if (!mustUnescape) mustUnescape = true;
-        isEscaping = false;
-      } else if (inQuotes) {
-        if (tokenChars[code] === 1) {
-          if (start === -1) start = i;
-        } else if (code === 0x22 /* '"' */ && start !== -1) {
-          inQuotes = false;
-          end = i;
-        } else if (code === 0x5c /* '\' */) {
-          isEscaping = true;
-        } else {
-          throw new SyntaxError(`Unexpected character at index ${i}`);
-        }
-      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
-        inQuotes = true;
-      } else if (end === -1 && tokenChars[code] === 1) {
-        if (start === -1) start = i;
-      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
-        if (end === -1) end = i;
-      } else if (code === 0x3b || code === 0x2c) {
-        if (start === -1) {
-          throw new SyntaxError(`Unexpected character at index ${i}`);
-        }
-
-        if (end === -1) end = i;
-        let value = header.slice(start, end);
-        if (mustUnescape) {
-          value = value.replace(/\\/g, '');
-          mustUnescape = false;
-        }
-        push(params, paramName, value);
-        if (code === 0x2c) {
-          push(offers, extensionName, params);
-          params = Object.create(null);
-          extensionName = undefined;
-        }
-
-        paramName = undefined;
-        start = end = -1;
-      } else {
-        throw new SyntaxError(`Unexpected character at index ${i}`);
-      }
-    }
-  }
-
-  if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
-    throw new SyntaxError('Unexpected end of input');
-  }
-
-  if (end === -1) end = i;
-  const token = header.slice(start, end);
-  if (extensionName === undefined) {
-    push(offers, token, params);
-  } else {
-    if (paramName === undefined) {
-      push(params, token, true);
-    } else if (mustUnescape) {
-      push(params, paramName, token.replace(/\\/g, ''));
-    } else {
-      push(params, paramName, token);
-    }
-    push(offers, extensionName, params);
-  }
-
-  return offers;
-}
-
-/**
- * Builds the `Sec-WebSocket-Extensions` header field value.
- *
- * @param {Object} extensions The map of extensions and parameters to format
- * @return {String} A string representing the given object
- * @public
- */
-function format(extensions) {
-  return Object.keys(extensions)
-    .map((extension) => {
-      let configurations = extensions[extension];
-      if (!Array.isArray(configurations)) configurations = [configurations];
-      return configurations
-        .map((params) => {
-          return [extension]
-            .concat(
-              Object.keys(params).map((k) => {
-                let values = params[k];
-                if (!Array.isArray(values)) values = [values];
-                return values
-                  .map((v) => (v === true ? k : `${k}=${v}`))
-                  .join('; ');
-              })
-            )
-            .join('; ');
-        })
-        .join(', ');
-    })
-    .join(', ');
-}
-
-module.exports = { format, parse };
--- a/test/node_modules/ws/lib/limiter.js
+++ b/test/node_modules/ws/lib/limiter.js
@@ -1,55 +0,0 @@
-'use strict';
-
-const kDone = Symbol('kDone');
-const kRun = Symbol('kRun');
-
-/**
- * A very simple job queue with adjustable concurrency. Adapted from
- * https://github.com/STRML/async-limiter
- */
-class Limiter {
-  /**
-   * Creates a new `Limiter`.
-   *
-   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
-   *     to run concurrently
-   */
-  constructor(concurrency) {
-    this[kDone] = () => {
-      this.pending--;
-      this[kRun]();
-    };
-    this.concurrency = concurrency || Infinity;
-    this.jobs = [];
-    this.pending = 0;
-  }
-
-  /**
-   * Adds a job to the queue.
-   *
-   * @param {Function} job The job to run
-   * @public
-   */
-  add(job) {
-    this.jobs.push(job);
-    this[kRun]();
-  }
-
-  /**
-   * Removes a job from the queue and runs it if possible.
-   *
-   * @private
-   */
-  [kRun]() {
-    if (this.pending === this.concurrency) return;
-
-    if (this.jobs.length) {
-      const job = this.jobs.shift();
-
-      this.pending++;
-      job(this[kDone]);
-    }
-  }
-}
-
-module.exports = Limiter;
--- a/test/node_modules/ws/lib/permessage-deflate.js
+++ b/test/node_modules/ws/lib/permessage-deflate.js
@@ -1,528 +0,0 @@
-'use strict';
-
-const zlib = require('zlib');
-
-const bufferUtil = require('./buffer-util');
-const Limiter = require('./limiter');
-const { kStatusCode } = require('./constants');
-
-const FastBuffer = Buffer[Symbol.species];
-const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
-const kPerMessageDeflate = Symbol('permessage-deflate');
-const kTotalLength = Symbol('total-length');
-const kCallback = Symbol('callback');
-const kBuffers = Symbol('buffers');
-const kError = Symbol('error');
-
-//
-// We limit zlib concurrency, which prevents severe memory fragmentation
-// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
-// and https://github.com/websockets/ws/issues/1202
-//
-// Intentionally global; it's the global thread pool that's an issue.
-//
-let zlibLimiter;
-
-/**
- * permessage-deflate implementation.
- */
-class PerMessageDeflate {
-  /**
-   * Creates a PerMessageDeflate instance.
-   *
-   * @param {Object} [options] Configuration options
-   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
-   *     for, or request, a custom client window size
-   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
-   *     acknowledge disabling of client context takeover
-   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
-   *     calls to zlib
-   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
-   *     use of a custom server window size
-   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
-   *     disabling of server context takeover
-   * @param {Number} [options.threshold=1024] Size (in bytes) below which
-   *     messages should not be compressed if context takeover is disabled
-   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
-   *     deflate
-   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
-   *     inflate
-   * @param {Boolean} [isServer=false] Create the instance in either server or
-   *     client mode
-   * @param {Number} [maxPayload=0] The maximum allowed message length
-   */
-  constructor(options, isServer, maxPayload) {
-    this._maxPayload = maxPayload | 0;
-    this._options = options || {};
-    this._threshold =
-      this._options.threshold !== undefined ? this._options.threshold : 1024;
-    this._isServer = !!isServer;
-    this._deflate = null;
-    this._inflate = null;
-
-    this.params = null;
-
-    if (!zlibLimiter) {
-      const concurrency =
-        this._options.concurrencyLimit !== undefined
-          ? this._options.concurrencyLimit
-          : 10;
-      zlibLimiter = new Limiter(concurrency);
-    }
-  }
-
-  /**
-   * @type {String}
-   */
-  static get extensionName() {
-    return 'permessage-deflate';
-  }
-
-  /**
-   * Create an extension negotiation offer.
-   *
-   * @return {Object} Extension parameters
-   * @public
-   */
-  offer() {
-    const params = {};
-
-    if (this._options.serverNoContextTakeover) {
-      params.server_no_context_takeover = true;
-    }
-    if (this._options.clientNoContextTakeover) {
-      params.client_no_context_takeover = true;
-    }
-    if (this._options.serverMaxWindowBits) {
-      params.server_max_window_bits = this._options.serverMaxWindowBits;
-    }
-    if (this._options.clientMaxWindowBits) {
-      params.client_max_window_bits = this._options.clientMaxWindowBits;
-    } else if (this._options.clientMaxWindowBits == null) {
-      params.client_max_window_bits = true;
-    }
-
-    return params;
-  }
-
-  /**
-   * Accept an extension negotiation offer/response.
-   *
-   * @param {Array} configurations The extension negotiation offers/reponse
-   * @return {Object} Accepted configuration
-   * @public
-   */
-  accept(configurations) {
-    configurations = this.normalizeParams(configurations);
-
-    this.params = this._isServer
-      ? this.acceptAsServer(configurations)
-      : this.acceptAsClient(configurations);
-
-    return this.params;
-  }
-
-  /**
-   * Releases all resources used by the extension.
-   *
-   * @public
-   */
-  cleanup() {
-    if (this._inflate) {
-      this._inflate.close();
-      this._inflate = null;
-    }
-
-    if (this._deflate) {
-      const callback = this._deflate[kCallback];
-
-      this._deflate.close();
-      this._deflate = null;
-
-      if (callback) {
-        callback(
-          new Error(
-            'The deflate stream was closed while data was being processed'
-          )
-        );
-      }
-    }
-  }
-
-  /**
-   *  Accept an extension negotiation offer.
-   *
-   * @param {Array} offers The extension negotiation offers
-   * @return {Object} Accepted configuration
-   * @private
-   */
-  acceptAsServer(offers) {
-    const opts = this._options;
-    const accepted = offers.find((params) => {
-      if (
-        (opts.serverNoContextTakeover === false &&
-          params.server_no_context_takeover) ||
-        (params.server_max_window_bits &&
-          (opts.serverMaxWindowBits === false ||
-            (typeof opts.serverMaxWindowBits === 'number' &&
-              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
-        (typeof opts.clientMaxWindowBits === 'number' &&
-          !params.client_max_window_bits)
-      ) {
-        return false;
-      }
-
-      return true;
-    });
-
-    if (!accepted) {
-      throw new Error('None of the extension offers can be accepted');
-    }
-
-    if (opts.serverNoContextTakeover) {
-      accepted.server_no_context_takeover = true;
-    }
-    if (opts.clientNoContextTakeover) {
-      accepted.client_no_context_takeover = true;
-    }
-    if (typeof opts.serverMaxWindowBits === 'number') {
-      accepted.server_max_window_bits = opts.serverMaxWindowBits;
-    }
-    if (typeof opts.clientMaxWindowBits === 'number') {
-      accepted.client_max_window_bits = opts.clientMaxWindowBits;
-    } else if (
-      accepted.client_max_window_bits === true ||
-      opts.clientMaxWindowBits === false
-    ) {
-      delete accepted.client_max_window_bits;
-    }
-
-    return accepted;
-  }
-
-  /**
-   * Accept the extension negotiation response.
-   *
-   * @param {Array} response The extension negotiation response
-   * @return {Object} Accepted configuration
-   * @private
-   */
-  acceptAsClient(response) {
-    const params = response[0];
-
-    if (
-      this._options.clientNoContextTakeover === false &&
-      params.client_no_context_takeover
-    ) {
-      throw new Error('Unexpected parameter "client_no_context_takeover"');
-    }
-
-    if (!params.client_max_window_bits) {
-      if (typeof this._options.clientMaxWindowBits === 'number') {
-        params.client_max_window_bits = this._options.clientMaxWindowBits;
-      }
-    } else if (
-      this._options.clientMaxWindowBits === false ||
-      (typeof this._options.clientMaxWindowBits === 'number' &&
-        params.client_max_window_bits > this._options.clientMaxWindowBits)
-    ) {
-      throw new Error(
-        'Unexpected or invalid parameter "client_max_window_bits"'
-      );
-    }
-
-    return params;
-  }
-
-  /**
-   * Normalize parameters.
-   *
-   * @param {Array} configurations The extension negotiation offers/reponse
-   * @return {Array} The offers/response with normalized parameters
-   * @private
-   */
-  normalizeParams(configurations) {
-    configurations.forEach((params) => {
-      Object.keys(params).forEach((key) => {
-        let value = params[key];
-
-        if (value.length > 1) {
-          throw new Error(`Parameter "${key}" must have only a single value`);
-        }
-
-        value = value[0];
-
-        if (key === 'client_max_window_bits') {
-          if (value !== true) {
-            const num = +value;
-            if (!Number.isInteger(num) || num < 8 || num > 15) {
-              throw new TypeError(
-                `Invalid value for parameter "${key}": ${value}`
-              );
-            }
-            value = num;
-          } else if (!this._isServer) {
-            throw new TypeError(
-              `Invalid value for parameter "${key}": ${value}`
-            );
-          }
-        } else if (key === 'server_max_window_bits') {
-          const num = +value;
-          if (!Number.isInteger(num) || num < 8 || num > 15) {
-            throw new TypeError(
-              `Invalid value for parameter "${key}": ${value}`
-            );
-          }
-          value = num;
-        } else if (
-          key === 'client_no_context_takeover' ||
-          key === 'server_no_context_takeover'
-        ) {
-          if (value !== true) {
-            throw new TypeError(
-              `Invalid value for parameter "${key}": ${value}`
-            );
-          }
-        } else {
-          throw new Error(`Unknown parameter "${key}"`);
-        }
-
-        params[key] = value;
-      });
-    });
-
-    return configurations;
-  }
-
-  /**
-   * Decompress data. Concurrency limited.
-   *
-   * @param {Buffer} data Compressed data
-   * @param {Boolean} fin Specifies whether or not this is the last fragment
-   * @param {Function} callback Callback
-   * @public
-   */
-  decompress(data, fin, callback) {
-    zlibLimiter.add((done) => {
-      this._decompress(data, fin, (err, result) => {
-        done();
-        callback(err, result);
-      });
-    });
-  }
-
-  /**
-   * Compress data. Concurrency limited.
-   *
-   * @param {(Buffer|String)} data Data to compress
-   * @param {Boolean} fin Specifies whether or not this is the last fragment
-   * @param {Function} callback Callback
-   * @public
-   */
-  compress(data, fin, callback) {
-    zlibLimiter.add((done) => {
-      this._compress(data, fin, (err, result) => {
-        done();
-        callback(err, result);
-      });
-    });
-  }
-
-  /**
-   * Decompress data.
-   *
-   * @param {Buffer} data Compressed data
-   * @param {Boolean} fin Specifies whether or not this is the last fragment
-   * @param {Function} callback Callback
-   * @private
-   */
-  _decompress(data, fin, callback) {
-    const endpoint = this._isServer ? 'client' : 'server';
-
-    if (!this._inflate) {
-      const key = `${endpoint}_max_window_bits`;
-      const windowBits =
-        typeof this.params[key] !== 'number'
-          ? zlib.Z_DEFAULT_WINDOWBITS
-          : this.params[key];
-
-      this._inflate = zlib.createInflateRaw({
-        ...this._options.zlibInflateOptions,
-        windowBits
-      });
-      this._inflate[kPerMessageDeflate] = this;
-      this._inflate[kTotalLength] = 0;
-      this._inflate[kBuffers] = [];
-      this._inflate.on('error', inflateOnError);
-      this._inflate.on('data', inflateOnData);
-    }
-
-    this._inflate[kCallback] = callback;
-
-    this._inflate.write(data);
-    if (fin) this._inflate.write(TRAILER);
-
-    this._inflate.flush(() => {
-      const err = this._inflate[kError];
-
-      if (err) {
-        this._inflate.close();
-        this._inflate = null;
-        callback(err);
-        return;
-      }
-
-      const data = bufferUtil.concat(
-        this._inflate[kBuffers],
-        this._inflate[kTotalLength]
-      );
-
-      if (this._inflate._readableState.endEmitted) {
-        this._inflate.close();
-        this._inflate = null;
-      } else {
-        this._inflate[kTotalLength] = 0;
-        this._inflate[kBuffers] = [];
-
-        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
-          this._inflate.reset();
-        }
-      }
-
-      callback(null, data);
-    });
-  }
-
-  /**
-   * Compress data.
-   *
-   * @param {(Buffer|String)} data Data to compress
-   * @param {Boolean} fin Specifies whether or not this is the last fragment
-   * @param {Function} callback Callback
-   * @private
-   */
-  _compress(data, fin, callback) {
-    const endpoint = this._isServer ? 'server' : 'client';
-
-    if (!this._deflate) {
-      const key = `${endpoint}_max_window_bits`;
-      const windowBits =
-        typeof this.params[key] !== 'number'
-          ? zlib.Z_DEFAULT_WINDOWBITS
-          : this.params[key];
-
-      this._deflate = zlib.createDeflateRaw({
-        ...this._options.zlibDeflateOptions,
-        windowBits
-      });
-
-      this._deflate[kTotalLength] = 0;
-      this._deflate[kBuffers] = [];
-
-      this._deflate.on('data', deflateOnData);
-    }
-
-    this._deflate[kCallback] = callback;
-
-    this._deflate.write(data);
-    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
-      if (!this._deflate) {
-        //
-        // The deflate stream was closed while data was being processed.
-        //
-        return;
-      }
-
-      let data = bufferUtil.concat(
-        this._deflate[kBuffers],
-        this._deflate[kTotalLength]
-      );
-
-      if (fin) {
-        data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);
-      }
-
-      //
-      // Ensure that the callback will not be called again in
-      // `PerMessageDeflate#cleanup()`.
-      //
-      this._deflate[kCallback] = null;
-
-      this._deflate[kTotalLength] = 0;
-      this._deflate[kBuffers] = [];
-
-      if (fin && this.params[`${endpoint}_no_context_takeover`]) {
-        this._deflate.reset();
-      }
-
-      callback(null, data);
-    });
-  }
-}
-
-module.exports = PerMessageDeflate;
-
-/**
- * The listener of the `zlib.DeflateRaw` stream `'data'` event.
- *
- * @param {Buffer} chunk A chunk of data
- * @private
- */
-function deflateOnData(chunk) {
-  this[kBuffers].push(chunk);
-  this[kTotalLength] += chunk.length;
-}
-
-/**
- * The listener of the `zlib.InflateRaw` stream `'data'` event.
- *
- * @param {Buffer} chunk A chunk of data
- * @private
- */
-function inflateOnData(chunk) {
-  this[kTotalLength] += chunk.length;
-
-  if (
-    this[kPerMessageDeflate]._maxPayload < 1 ||
-    this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
-  ) {
-    this[kBuffers].push(chunk);
-    return;
-  }
-
-  this[kError] = new RangeError('Max payload size exceeded');
-  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
-  this[kError][kStatusCode] = 1009;
-  this.removeListener('data', inflateOnData);
-
-  //
-  // The choice to employ `zlib.reset()` over `zlib.close()` is dictated by the
-  // fact that in Node.js versions prior to 13.10.0, the callback for
-  // `zlib.flush()` is not called if `zlib.close()` is used. Utilizing
-  // `zlib.reset()` ensures that either the callback is invoked or an error is
-  // emitted.
-  //
-  this.reset();
-}
-
-/**
- * The listener of the `zlib.InflateRaw` stream `'error'` event.
- *
- * @param {Error} err The emitted error
- * @private
- */
-function inflateOnError(err) {
-  //
-  // There is no need to call `Zlib#close()` as the handle is automatically
-  // closed when an error is emitted.
-  //
-  this[kPerMessageDeflate]._inflate = null;
-
-  if (this[kError]) {
-    this[kCallback](this[kError]);
-    return;
-  }
-
-  err[kStatusCode] = 1007;
-  this[kCallback](err);
-}
--- a/test/node_modules/ws/lib/receiver.js
+++ b/test/node_modules/ws/lib/receiver.js
@@ -1,706 +0,0 @@
-'use strict';
-
-const { Writable } = require('stream');
-
-const PerMessageDeflate = require('./permessage-deflate');
-const {
-  BINARY_TYPES,
-  EMPTY_BUFFER,
-  kStatusCode,
-  kWebSocket
-} = require('./constants');
-const { concat, toArrayBuffer, unmask } = require('./buffer-util');
-const { isValidStatusCode, isValidUTF8 } = require('./validation');
-
-const FastBuffer = Buffer[Symbol.species];
-
-const GET_INFO = 0;
-const GET_PAYLOAD_LENGTH_16 = 1;
-const GET_PAYLOAD_LENGTH_64 = 2;
-const GET_MASK = 3;
-const GET_DATA = 4;
-const INFLATING = 5;
-const DEFER_EVENT = 6;
-
-/**
- * HyBi Receiver implementation.
- *
- * @extends Writable
- */
-class Receiver extends Writable {
-  /**
-   * Creates a Receiver instance.
-   *
-   * @param {Object} [options] Options object
-   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
-   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
-   *     multiple times in the same tick
-   * @param {String} [options.binaryType=nodebuffer] The type for binary data
-   * @param {Object} [options.extensions] An object containing the negotiated
-   *     extensions
-   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
-   *     client or server mode
-   * @param {Number} [options.maxPayload=0] The maximum allowed message length
-   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
-   *     not to skip UTF-8 validation for text and close messages
-   */
-  constructor(options = {}) {
-    super();
-
-    this._allowSynchronousEvents =
-      options.allowSynchronousEvents !== undefined
-        ? options.allowSynchronousEvents
-        : true;
-    this._binaryType = options.binaryType || BINARY_TYPES[0];
-    this._extensions = options.extensions || {};
-    this._isServer = !!options.isServer;
-    this._maxPayload = options.maxPayload | 0;
-    this._skipUTF8Validation = !!options.skipUTF8Validation;
-    this[kWebSocket] = undefined;
-
-    this._bufferedBytes = 0;
-    this._buffers = [];
-
-    this._compressed = false;
-    this._payloadLength = 0;
-    this._mask = undefined;
-    this._fragmented = 0;
-    this._masked = false;
-    this._fin = false;
-    this._opcode = 0;
-
-    this._totalPayloadLength = 0;
-    this._messageLength = 0;
-    this._fragments = [];
-
-    this._errored = false;
-    this._loop = false;
-    this._state = GET_INFO;
-  }
-
-  /**
-   * Implements `Writable.prototype._write()`.
-   *
-   * @param {Buffer} chunk The chunk of data to write
-   * @param {String} encoding The character encoding of `chunk`
-   * @param {Function} cb Callback
-   * @private
-   */
-  _write(chunk, encoding, cb) {
-    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
-
-    this._bufferedBytes += chunk.length;
-    this._buffers.push(chunk);
-    this.startLoop(cb);
-  }
-
-  /**
-   * Consumes `n` bytes from the buffered data.
-   *
-   * @param {Number} n The number of bytes to consume
-   * @return {Buffer} The consumed bytes
-   * @private
-   */
-  consume(n) {
-    this._bufferedBytes -= n;
-
-    if (n === this._buffers[0].length) return this._buffers.shift();
-
-    if (n < this._buffers[0].length) {
-      const buf = this._buffers[0];
-      this._buffers[0] = new FastBuffer(
-        buf.buffer,
-        buf.byteOffset + n,
-        buf.length - n
-      );
-
-      return new FastBuffer(buf.buffer, buf.byteOffset, n);
-    }
-
-    const dst = Buffer.allocUnsafe(n);
-
-    do {
-      const buf = this._buffers[0];
-      const offset = dst.length - n;
-
-      if (n >= buf.length) {
-        dst.set(this._buffers.shift(), offset);
-      } else {
-        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
-        this._buffers[0] = new FastBuffer(
-          buf.buffer,
-          buf.byteOffset + n,
-          buf.length - n
-        );
-      }
-
-      n -= buf.length;
-    } while (n > 0);
-
-    return dst;
-  }
-
-  /**
-   * Starts the parsing loop.
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  startLoop(cb) {
-    this._loop = true;
-
-    do {
-      switch (this._state) {
-        case GET_INFO:
-          this.getInfo(cb);
-          break;
-        case GET_PAYLOAD_LENGTH_16:
-          this.getPayloadLength16(cb);
-          break;
-        case GET_PAYLOAD_LENGTH_64:
-          this.getPayloadLength64(cb);
-          break;
-        case GET_MASK:
-          this.getMask();
-          break;
-        case GET_DATA:
-          this.getData(cb);
-          break;
-        case INFLATING:
-        case DEFER_EVENT:
-          this._loop = false;
-          return;
-      }
-    } while (this._loop);
-
-    if (!this._errored) cb();
-  }
-
-  /**
-   * Reads the first two bytes of a frame.
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  getInfo(cb) {
-    if (this._bufferedBytes < 2) {
-      this._loop = false;
-      return;
-    }
-
-    const buf = this.consume(2);
-
-    if ((buf[0] & 0x30) !== 0x00) {
-      const error = this.createError(
-        RangeError,
-        'RSV2 and RSV3 must be clear',
-        true,
-        1002,
-        'WS_ERR_UNEXPECTED_RSV_2_3'
-      );
-
-      cb(error);
-      return;
-    }
-
-    const compressed = (buf[0] & 0x40) === 0x40;
-
-    if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
-      const error = this.createError(
-        RangeError,
-        'RSV1 must be clear',
-        true,
-        1002,
-        'WS_ERR_UNEXPECTED_RSV_1'
-      );
-
-      cb(error);
-      return;
-    }
-
-    this._fin = (buf[0] & 0x80) === 0x80;
-    this._opcode = buf[0] & 0x0f;
-    this._payloadLength = buf[1] & 0x7f;
-
-    if (this._opcode === 0x00) {
-      if (compressed) {
-        const error = this.createError(
-          RangeError,
-          'RSV1 must be clear',
-          true,
-          1002,
-          'WS_ERR_UNEXPECTED_RSV_1'
-        );
-
-        cb(error);
-        return;
-      }
-
-      if (!this._fragmented) {
-        const error = this.createError(
-          RangeError,
-          'invalid opcode 0',
-          true,
-          1002,
-          'WS_ERR_INVALID_OPCODE'
-        );
-
-        cb(error);
-        return;
-      }
-
-      this._opcode = this._fragmented;
-    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
-      if (this._fragmented) {
-        const error = this.createError(
-          RangeError,
-          `invalid opcode ${this._opcode}`,
-          true,
-          1002,
-          'WS_ERR_INVALID_OPCODE'
-        );
-
-        cb(error);
-        return;
-      }
-
-      this._compressed = compressed;
-    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
-      if (!this._fin) {
-        const error = this.createError(
-          RangeError,
-          'FIN must be set',
-          true,
-          1002,
-          'WS_ERR_EXPECTED_FIN'
-        );
-
-        cb(error);
-        return;
-      }
-
-      if (compressed) {
-        const error = this.createError(
-          RangeError,
-          'RSV1 must be clear',
-          true,
-          1002,
-          'WS_ERR_UNEXPECTED_RSV_1'
-        );
-
-        cb(error);
-        return;
-      }
-
-      if (
-        this._payloadLength > 0x7d ||
-        (this._opcode === 0x08 && this._payloadLength === 1)
-      ) {
-        const error = this.createError(
-          RangeError,
-          `invalid payload length ${this._payloadLength}`,
-          true,
-          1002,
-          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
-        );
-
-        cb(error);
-        return;
-      }
-    } else {
-      const error = this.createError(
-        RangeError,
-        `invalid opcode ${this._opcode}`,
-        true,
-        1002,
-        'WS_ERR_INVALID_OPCODE'
-      );
-
-      cb(error);
-      return;
-    }
-
-    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
-    this._masked = (buf[1] & 0x80) === 0x80;
-
-    if (this._isServer) {
-      if (!this._masked) {
-        const error = this.createError(
-          RangeError,
-          'MASK must be set',
-          true,
-          1002,
-          'WS_ERR_EXPECTED_MASK'
-        );
-
-        cb(error);
-        return;
-      }
-    } else if (this._masked) {
-      const error = this.createError(
-        RangeError,
-        'MASK must be clear',
-        true,
-        1002,
-        'WS_ERR_UNEXPECTED_MASK'
-      );
-
-      cb(error);
-      return;
-    }
-
-    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
-    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
-    else this.haveLength(cb);
-  }
-
-  /**
-   * Gets extended payload length (7+16).
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  getPayloadLength16(cb) {
-    if (this._bufferedBytes < 2) {
-      this._loop = false;
-      return;
-    }
-
-    this._payloadLength = this.consume(2).readUInt16BE(0);
-    this.haveLength(cb);
-  }
-
-  /**
-   * Gets extended payload length (7+64).
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  getPayloadLength64(cb) {
-    if (this._bufferedBytes < 8) {
-      this._loop = false;
-      return;
-    }
-
-    const buf = this.consume(8);
-    const num = buf.readUInt32BE(0);
-
-    //
-    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
-    // if payload length is greater than this number.
-    //
-    if (num > Math.pow(2, 53 - 32) - 1) {
-      const error = this.createError(
-        RangeError,
-        'Unsupported WebSocket frame: payload length > 2^53 - 1',
-        false,
-        1009,
-        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
-      );
-
-      cb(error);
-      return;
-    }
-
-    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
-    this.haveLength(cb);
-  }
-
-  /**
-   * Payload length has been read.
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  haveLength(cb) {
-    if (this._payloadLength && this._opcode < 0x08) {
-      this._totalPayloadLength += this._payloadLength;
-      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
-        const error = this.createError(
-          RangeError,
-          'Max payload size exceeded',
-          false,
-          1009,
-          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
-        );
-
-        cb(error);
-        return;
-      }
-    }
-
-    if (this._masked) this._state = GET_MASK;
-    else this._state = GET_DATA;
-  }
-
-  /**
-   * Reads mask bytes.
-   *
-   * @private
-   */
-  getMask() {
-    if (this._bufferedBytes < 4) {
-      this._loop = false;
-      return;
-    }
-
-    this._mask = this.consume(4);
-    this._state = GET_DATA;
-  }
-
-  /**
-   * Reads data bytes.
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  getData(cb) {
-    let data = EMPTY_BUFFER;
-
-    if (this._payloadLength) {
-      if (this._bufferedBytes < this._payloadLength) {
-        this._loop = false;
-        return;
-      }
-
-      data = this.consume(this._payloadLength);
-
-      if (
-        this._masked &&
-        (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0
-      ) {
-        unmask(data, this._mask);
-      }
-    }
-
-    if (this._opcode > 0x07) {
-      this.controlMessage(data, cb);
-      return;
-    }
-
-    if (this._compressed) {
-      this._state = INFLATING;
-      this.decompress(data, cb);
-      return;
-    }
-
-    if (data.length) {
-      //
-      // This message is not compressed so its length is the sum of the payload
-      // length of all fragments.
-      //
-      this._messageLength = this._totalPayloadLength;
-      this._fragments.push(data);
-    }
-
-    this.dataMessage(cb);
-  }
-
-  /**
-   * Decompresses data.
-   *
-   * @param {Buffer} data Compressed data
-   * @param {Function} cb Callback
-   * @private
-   */
-  decompress(data, cb) {
-    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-
-    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
-      if (err) return cb(err);
-
-      if (buf.length) {
-        this._messageLength += buf.length;
-        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
-          const error = this.createError(
-            RangeError,
-            'Max payload size exceeded',
-            false,
-            1009,
-            'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
-          );
-
-          cb(error);
-          return;
-        }
-
-        this._fragments.push(buf);
-      }
-
-      this.dataMessage(cb);
-      if (this._state === GET_INFO) this.startLoop(cb);
-    });
-  }
-
-  /**
-   * Handles a data message.
-   *
-   * @param {Function} cb Callback
-   * @private
-   */
-  dataMessage(cb) {
-    if (!this._fin) {
-      this._state = GET_INFO;
-      return;
-    }
-
-    const messageLength = this._messageLength;
-    const fragments = this._fragments;
-
-    this._totalPayloadLength = 0;
-    this._messageLength = 0;
-    this._fragmented = 0;
-    this._fragments = [];
-
-    if (this._opcode === 2) {
-      let data;
-
-      if (this._binaryType === 'nodebuffer') {
-        data = concat(fragments, messageLength);
-      } else if (this._binaryType === 'arraybuffer') {
-        data = toArrayBuffer(concat(fragments, messageLength));
-      } else if (this._binaryType === 'blob') {
-        data = new Blob(fragments);
-      } else {
-        data = fragments;
-      }
-
-      if (this._allowSynchronousEvents) {
-        this.emit('message', data, true);
-        this._state = GET_INFO;
-      } else {
-        this._state = DEFER_EVENT;
-        setImmediate(() => {
-          this.emit('message', data, true);
-          this._state = GET_INFO;
-          this.startLoop(cb);
-        });
-      }
-    } else {
-      const buf = concat(fragments, messageLength);
-
-      if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
-        const error = this.createError(
-          Error,
-          'invalid UTF-8 sequence',
-          true,
-          1007,
-          'WS_ERR_INVALID_UTF8'
-        );
-
-        cb(error);
-        return;
-      }
-
-      if (this._state === INFLATING || this._allowSynchronousEvents) {
-        this.emit('message', buf, false);
-        this._state = GET_INFO;
-      } else {
-        this._state = DEFER_EVENT;
-        setImmediate(() => {
-          this.emit('message', buf, false);
-          this._state = GET_INFO;
-          this.startLoop(cb);
-        });
-      }
-    }
-  }
-
-  /**
-   * Handles a control message.
-   *
-   * @param {Buffer} data Data to handle
-   * @return {(Error|RangeError|undefined)} A possible error
-   * @private
-   */
-  controlMessage(data, cb) {
-    if (this._opcode === 0x08) {
-      if (data.length === 0) {
-        this._loop = false;
-        this.emit('conclude', 1005, EMPTY_BUFFER);
-        this.end();
-      } else {
-        const code = data.readUInt16BE(0);
-
-        if (!isValidStatusCode(code)) {
-          const error = this.createError(
-            RangeError,
-            `invalid status code ${code}`,
-            true,
-            1002,
-            'WS_ERR_INVALID_CLOSE_CODE'
-          );
-
-          cb(error);
-          return;
-        }
-
-        const buf = new FastBuffer(
-          data.buffer,
-          data.byteOffset + 2,
-          data.length - 2
-        );
-
-        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
-          const error = this.createError(
-            Error,
-            'invalid UTF-8 sequence',
-            true,
-            1007,
-            'WS_ERR_INVALID_UTF8'
-          );
-
-          cb(error);
-          return;
-        }
-
-        this._loop = false;
-        this.emit('conclude', code, buf);
-        this.end();
-      }
-
-      this._state = GET_INFO;
-      return;
-    }
-
-    if (this._allowSynchronousEvents) {
-      this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
-      this._state = GET_INFO;
-    } else {
-      this._state = DEFER_EVENT;
-      setImmediate(() => {
-        this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
-        this._state = GET_INFO;
-        this.startLoop(cb);
-      });
-    }
-  }
-
-  /**
-   * Builds an error object.
-   *
-   * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
-   * @param {String} message The error message
-   * @param {Boolean} prefix Specifies whether or not to add a default prefix to
-   *     `message`
-   * @param {Number} statusCode The status code
-   * @param {String} errorCode The exposed error code
-   * @return {(Error|RangeError)} The error
-   * @private
-   */
-  createError(ErrorCtor, message, prefix, statusCode, errorCode) {
-    this._loop = false;
-    this._errored = true;
-
-    const err = new ErrorCtor(
-      prefix ? `Invalid WebSocket frame: ${message}` : message
-    );
-
-    Error.captureStackTrace(err, this.createError);
-    err.code = errorCode;
-    err[kStatusCode] = statusCode;
-    return err;
-  }
-}
-
-module.exports = Receiver;
--- a/test/node_modules/ws/lib/sender.js
+++ b/test/node_modules/ws/lib/sender.js
@@ -1,602 +0,0 @@
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
-
-'use strict';
-
-const { Duplex } = require('stream');
-const { randomFillSync } = require('crypto');
-
-const PerMessageDeflate = require('./permessage-deflate');
-const { EMPTY_BUFFER, kWebSocket, NOOP } = require('./constants');
-const { isBlob, isValidStatusCode } = require('./validation');
-const { mask: applyMask, toBuffer } = require('./buffer-util');
-
-const kByteLength = Symbol('kByteLength');
-const maskBuffer = Buffer.alloc(4);
-const RANDOM_POOL_SIZE = 8 * 1024;
-let randomPool;
-let randomPoolPointer = RANDOM_POOL_SIZE;
-
-const DEFAULT = 0;
-const DEFLATING = 1;
-const GET_BLOB_DATA = 2;
-
-/**
- * HyBi Sender implementation.
- */
-class Sender {
-  /**
-   * Creates a Sender instance.
-   *
-   * @param {Duplex} socket The connection socket
-   * @param {Object} [extensions] An object containing the negotiated extensions
-   * @param {Function} [generateMask] The function used to generate the masking
-   *     key
-   */
-  constructor(socket, extensions, generateMask) {
-    this._extensions = extensions || {};
-
-    if (generateMask) {
-      this._generateMask = generateMask;
-      this._maskBuffer = Buffer.alloc(4);
-    }
-
-    this._socket = socket;
-
-    this._firstFragment = true;
-    this._compress = false;
-
-    this._bufferedBytes = 0;
-    this._queue = [];
-    this._state = DEFAULT;
-    this.onerror = NOOP;
-    this[kWebSocket] = undefined;
-  }
-
-  /**
-   * Frames a piece of data according to the HyBi WebSocket protocol.
-   *
-   * @param {(Buffer|String)} data The data to frame
-   * @param {Object} options Options object
-   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
-   *     FIN bit
-   * @param {Function} [options.generateMask] The function used to generate the
-   *     masking key
-   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-   *     `data`
-   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
-   *     key
-   * @param {Number} options.opcode The opcode
-   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-   *     modified
-   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
-   *     RSV1 bit
-   * @return {(Buffer|String)[]} The framed data
-   * @public
-   */
-  static frame(data, options) {
-    let mask;
-    let merge = false;
-    let offset = 2;
-    let skipMasking = false;
-
-    if (options.mask) {
-      mask = options.maskBuffer || maskBuffer;
-
-      if (options.generateMask) {
-        options.generateMask(mask);
-      } else {
-        if (randomPoolPointer === RANDOM_POOL_SIZE) {
-          /* istanbul ignore else  */
-          if (randomPool === undefined) {
-            //
-            // This is lazily initialized because server-sent frames must not
-            // be masked so it may never be used.
-            //
-            randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
-          }
-
-          randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
-          randomPoolPointer = 0;
-        }
-
-        mask[0] = randomPool[randomPoolPointer++];
-        mask[1] = randomPool[randomPoolPointer++];
-        mask[2] = randomPool[randomPoolPointer++];
-        mask[3] = randomPool[randomPoolPointer++];
-      }
-
-      skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
-      offset = 6;
-    }
-
-    let dataLength;
-
-    if (typeof data === 'string') {
-      if (
-        (!options.mask || skipMasking) &&
-        options[kByteLength] !== undefined
-      ) {
-        dataLength = options[kByteLength];
-      } else {
-        data = Buffer.from(data);
-        dataLength = data.length;
-      }
-    } else {
-      dataLength = data.length;
-      merge = options.mask && options.readOnly && !skipMasking;
-    }
-
-    let payloadLength = dataLength;
-
-    if (dataLength >= 65536) {
-      offset += 8;
-      payloadLength = 127;
-    } else if (dataLength > 125) {
-      offset += 2;
-      payloadLength = 126;
-    }
-
-    const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
-
-    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
-    if (options.rsv1) target[0] |= 0x40;
-
-    target[1] = payloadLength;
-
-    if (payloadLength === 126) {
-      target.writeUInt16BE(dataLength, 2);
-    } else if (payloadLength === 127) {
-      target[2] = target[3] = 0;
-      target.writeUIntBE(dataLength, 4, 6);
-    }
-
-    if (!options.mask) return [target, data];
-
-    target[1] |= 0x80;
-    target[offset - 4] = mask[0];
-    target[offset - 3] = mask[1];
-    target[offset - 2] = mask[2];
-    target[offset - 1] = mask[3];
-
-    if (skipMasking) return [target, data];
-
-    if (merge) {
-      applyMask(data, mask, target, offset, dataLength);
-      return [target];
-    }
-
-    applyMask(data, mask, data, 0, dataLength);
-    return [target, data];
-  }
-
-  /**
-   * Sends a close message to the other peer.
-   *
-   * @param {Number} [code] The status code component of the body
-   * @param {(String|Buffer)} [data] The message component of the body
-   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
-   * @param {Function} [cb] Callback
-   * @public
-   */
-  close(code, data, mask, cb) {
-    let buf;
-
-    if (code === undefined) {
-      buf = EMPTY_BUFFER;
-    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
-      throw new TypeError('First argument must be a valid error code number');
-    } else if (data === undefined || !data.length) {
-      buf = Buffer.allocUnsafe(2);
-      buf.writeUInt16BE(code, 0);
-    } else {
-      const length = Buffer.byteLength(data);
-
-      if (length > 123) {
-        throw new RangeError('The message must not be greater than 123 bytes');
-      }
-
-      buf = Buffer.allocUnsafe(2 + length);
-      buf.writeUInt16BE(code, 0);
-
-      if (typeof data === 'string') {
-        buf.write(data, 2);
-      } else {
-        buf.set(data, 2);
-      }
-    }
-
-    const options = {
-      [kByteLength]: buf.length,
-      fin: true,
-      generateMask: this._generateMask,
-      mask,
-      maskBuffer: this._maskBuffer,
-      opcode: 0x08,
-      readOnly: false,
-      rsv1: false
-    };
-
-    if (this._state !== DEFAULT) {
-      this.enqueue([this.dispatch, buf, false, options, cb]);
-    } else {
-      this.sendFrame(Sender.frame(buf, options), cb);
-    }
-  }
-
-  /**
-   * Sends a ping message to the other peer.
-   *
-   * @param {*} data The message to send
-   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-   * @param {Function} [cb] Callback
-   * @public
-   */
-  ping(data, mask, cb) {
-    let byteLength;
-    let readOnly;
-
-    if (typeof data === 'string') {
-      byteLength = Buffer.byteLength(data);
-      readOnly = false;
-    } else if (isBlob(data)) {
-      byteLength = data.size;
-      readOnly = false;
-    } else {
-      data = toBuffer(data);
-      byteLength = data.length;
-      readOnly = toBuffer.readOnly;
-    }
-
-    if (byteLength > 125) {
-      throw new RangeError('The data size must not be greater than 125 bytes');
-    }
-
-    const options = {
-      [kByteLength]: byteLength,
-      fin: true,
-      generateMask: this._generateMask,
-      mask,
-      maskBuffer: this._maskBuffer,
-      opcode: 0x09,
-      readOnly,
-      rsv1: false
-    };
-
-    if (isBlob(data)) {
-      if (this._state !== DEFAULT) {
-        this.enqueue([this.getBlobData, data, false, options, cb]);
-      } else {
-        this.getBlobData(data, false, options, cb);
-      }
-    } else if (this._state !== DEFAULT) {
-      this.enqueue([this.dispatch, data, false, options, cb]);
-    } else {
-      this.sendFrame(Sender.frame(data, options), cb);
-    }
-  }
-
-  /**
-   * Sends a pong message to the other peer.
-   *
-   * @param {*} data The message to send
-   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-   * @param {Function} [cb] Callback
-   * @public
-   */
-  pong(data, mask, cb) {
-    let byteLength;
-    let readOnly;
-
-    if (typeof data === 'string') {
-      byteLength = Buffer.byteLength(data);
-      readOnly = false;
-    } else if (isBlob(data)) {
-      byteLength = data.size;
-      readOnly = false;
-    } else {
-      data = toBuffer(data);
-      byteLength = data.length;
-      readOnly = toBuffer.readOnly;
-    }
-
-    if (byteLength > 125) {
-      throw new RangeError('The data size must not be greater than 125 bytes');
-    }
-
-    const options = {
-      [kByteLength]: byteLength,
-      fin: true,
-      generateMask: this._generateMask,
-      mask,
-      maskBuffer: this._maskBuffer,
-      opcode: 0x0a,
-      readOnly,
-      rsv1: false
-    };
-
-    if (isBlob(data)) {
-      if (this._state !== DEFAULT) {
-        this.enqueue([this.getBlobData, data, false, options, cb]);
-      } else {
-        this.getBlobData(data, false, options, cb);
-      }
-    } else if (this._state !== DEFAULT) {
-      this.enqueue([this.dispatch, data, false, options, cb]);
-    } else {
-      this.sendFrame(Sender.frame(data, options), cb);
-    }
-  }
-
-  /**
-   * Sends a data message to the other peer.
-   *
-   * @param {*} data The message to send
-   * @param {Object} options Options object
-   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
-   *     or text
-   * @param {Boolean} [options.compress=false] Specifies whether or not to
-   *     compress `data`
-   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
-   *     last one
-   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-   *     `data`
-   * @param {Function} [cb] Callback
-   * @public
-   */
-  send(data, options, cb) {
-    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-    let opcode = options.binary ? 2 : 1;
-    let rsv1 = options.compress;
-
-    let byteLength;
-    let readOnly;
-
-    if (typeof data === 'string') {
-      byteLength = Buffer.byteLength(data);
-      readOnly = false;
-    } else if (isBlob(data)) {
-      byteLength = data.size;
-      readOnly = false;
-    } else {
-      data = toBuffer(data);
-      byteLength = data.length;
-      readOnly = toBuffer.readOnly;
-    }
-
-    if (this._firstFragment) {
-      this._firstFragment = false;
-      if (
-        rsv1 &&
-        perMessageDeflate &&
-        perMessageDeflate.params[
-          perMessageDeflate._isServer
-            ? 'server_no_context_takeover'
-            : 'client_no_context_takeover'
-        ]
-      ) {
-        rsv1 = byteLength >= perMessageDeflate._threshold;
-      }
-      this._compress = rsv1;
-    } else {
-      rsv1 = false;
-      opcode = 0;
-    }
-
-    if (options.fin) this._firstFragment = true;
-
-    const opts = {
-      [kByteLength]: byteLength,
-      fin: options.fin,
-      generateMask: this._generateMask,
-      mask: options.mask,
-      maskBuffer: this._maskBuffer,
-      opcode,
-      readOnly,
-      rsv1
-    };
-
-    if (isBlob(data)) {
-      if (this._state !== DEFAULT) {
-        this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
-      } else {
-        this.getBlobData(data, this._compress, opts, cb);
-      }
-    } else if (this._state !== DEFAULT) {
-      this.enqueue([this.dispatch, data, this._compress, opts, cb]);
-    } else {
-      this.dispatch(data, this._compress, opts, cb);
-    }
-  }
-
-  /**
-   * Gets the contents of a blob as binary data.
-   *
-   * @param {Blob} blob The blob
-   * @param {Boolean} [compress=false] Specifies whether or not to compress
-   *     the data
-   * @param {Object} options Options object
-   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
-   *     FIN bit
-   * @param {Function} [options.generateMask] The function used to generate the
-   *     masking key
-   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-   *     `data`
-   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
-   *     key
-   * @param {Number} options.opcode The opcode
-   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-   *     modified
-   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
-   *     RSV1 bit
-   * @param {Function} [cb] Callback
-   * @private
-   */
-  getBlobData(blob, compress, options, cb) {
-    this._bufferedBytes += options[kByteLength];
-    this._state = GET_BLOB_DATA;
-
-    blob
-      .arrayBuffer()
-      .then((arrayBuffer) => {
-        if (this._socket.destroyed) {
-          const err = new Error(
-            'The socket was closed while the blob was being read'
-          );
-
-          //
-          // `callCallbacks` is called in the next tick to ensure that errors
-          // that might be thrown in the callbacks behave like errors thrown
-          // outside the promise chain.
-          //
-          process.nextTick(callCallbacks, this, err, cb);
-          return;
-        }
-
-        this._bufferedBytes -= options[kByteLength];
-        const data = toBuffer(arrayBuffer);
-
-        if (!compress) {
-          this._state = DEFAULT;
-          this.sendFrame(Sender.frame(data, options), cb);
-          this.dequeue();
-        } else {
-          this.dispatch(data, compress, options, cb);
-        }
-      })
-      .catch((err) => {
-        //
-        // `onError` is called in the next tick for the same reason that
-        // `callCallbacks` above is.
-        //
-        process.nextTick(onError, this, err, cb);
-      });
-  }
-
-  /**
-   * Dispatches a message.
-   *
-   * @param {(Buffer|String)} data The message to send
-   * @param {Boolean} [compress=false] Specifies whether or not to compress
-   *     `data`
-   * @param {Object} options Options object
-   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
-   *     FIN bit
-   * @param {Function} [options.generateMask] The function used to generate the
-   *     masking key
-   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-   *     `data`
-   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
-   *     key
-   * @param {Number} options.opcode The opcode
-   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-   *     modified
-   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
-   *     RSV1 bit
-   * @param {Function} [cb] Callback
-   * @private
-   */
-  dispatch(data, compress, options, cb) {
-    if (!compress) {
-      this.sendFrame(Sender.frame(data, options), cb);
-      return;
-    }
-
-    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-
-    this._bufferedBytes += options[kByteLength];
-    this._state = DEFLATING;
-    perMessageDeflate.compress(data, options.fin, (_, buf) => {
-      if (this._socket.destroyed) {
-        const err = new Error(
-          'The socket was closed while data was being compressed'
-        );
-
-        callCallbacks(this, err, cb);
-        return;
-      }
-
-      this._bufferedBytes -= options[kByteLength];
-      this._state = DEFAULT;
-      options.readOnly = false;
-      this.sendFrame(Sender.frame(buf, options), cb);
-      this.dequeue();
-    });
-  }
-
-  /**
-   * Executes queued send operations.
-   *
-   * @private
-   */
-  dequeue() {
-    while (this._state === DEFAULT && this._queue.length) {
-      const params = this._queue.shift();
-
-      this._bufferedBytes -= params[3][kByteLength];
-      Reflect.apply(params[0], this, params.slice(1));
-    }
-  }
-
-  /**
-   * Enqueues a send operation.
-   *
-   * @param {Array} params Send operation parameters.
-   * @private
-   */
-  enqueue(params) {
-    this._bufferedBytes += params[3][kByteLength];
-    this._queue.push(params);
-  }
-
-  /**
-   * Sends a frame.
-   *
-   * @param {(Buffer | String)[]} list The frame to send
-   * @param {Function} [cb] Callback
-   * @private
-   */
-  sendFrame(list, cb) {
-    if (list.length === 2) {
-      this._socket.cork();
-      this._socket.write(list[0]);
-      this._socket.write(list[1], cb);
-      this._socket.uncork();
-    } else {
-      this._socket.write(list[0], cb);
-    }
-  }
-}
-
-module.exports = Sender;
-
-/**
- * Calls queued callbacks with an error.
- *
- * @param {Sender} sender The `Sender` instance
- * @param {Error} err The error to call the callbacks with
- * @param {Function} [cb] The first callback
- * @private
- */
-function callCallbacks(sender, err, cb) {
-  if (typeof cb === 'function') cb(err);
-
-  for (let i = 0; i < sender._queue.length; i++) {
-    const params = sender._queue[i];
-    const callback = params[params.length - 1];
-
-    if (typeof callback === 'function') callback(err);
-  }
-}
-
-/**
- * Handles a `Sender` error.
- *
- * @param {Sender} sender The `Sender` instance
- * @param {Error} err The error
- * @param {Function} [cb] The first pending callback
- * @private
- */
-function onError(sender, err, cb) {
-  callCallbacks(sender, err, cb);
-  sender.onerror(err);
-}
--- a/test/node_modules/ws/lib/stream.js
+++ b/test/node_modules/ws/lib/stream.js
@@ -1,161 +0,0 @@
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
-'use strict';
-
-const WebSocket = require('./websocket');
-const { Duplex } = require('stream');
-
-/**
- * Emits the `'close'` event on a stream.
- *
- * @param {Duplex} stream The stream.
- * @private
- */
-function emitClose(stream) {
-  stream.emit('close');
-}
-
-/**
- * The listener of the `'end'` event.
- *
- * @private
- */
-function duplexOnEnd() {
-  if (!this.destroyed && this._writableState.finished) {
-    this.destroy();
-  }
-}
-
-/**
- * The listener of the `'error'` event.
- *
- * @param {Error} err The error
- * @private
- */
-function duplexOnError(err) {
-  this.removeListener('error', duplexOnError);
-  this.destroy();
-  if (this.listenerCount('error') === 0) {
-    // Do not suppress the throwing behavior.
-    this.emit('error', err);
-  }
-}
-
-/**
- * Wraps a `WebSocket` in a duplex stream.
- *
- * @param {WebSocket} ws The `WebSocket` to wrap
- * @param {Object} [options] The options for the `Duplex` constructor
- * @return {Duplex} The duplex stream
- * @public
- */
-function createWebSocketStream(ws, options) {
-  let terminateOnDestroy = true;
-
-  const duplex = new Duplex({
-    ...options,
-    autoDestroy: false,
-    emitClose: false,
-    objectMode: false,
-    writableObjectMode: false
-  });
-
-  ws.on('message', function message(msg, isBinary) {
-    const data =
-      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
-
-    if (!duplex.push(data)) ws.pause();
-  });
-
-  ws.once('error', function error(err) {
-    if (duplex.destroyed) return;
-
-    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
-    //
-    // - If the `'error'` event is emitted before the `'open'` event, then
-    //   `ws.terminate()` is a noop as no socket is assigned.
-    // - Otherwise, the error is re-emitted by the listener of the `'error'`
-    //   event of the `Receiver` object. The listener already closes the
-    //   connection by calling `ws.close()`. This allows a close frame to be
-    //   sent to the other peer. If `ws.terminate()` is called right after this,
-    //   then the close frame might not be sent.
-    terminateOnDestroy = false;
-    duplex.destroy(err);
-  });
-
-  ws.once('close', function close() {
-    if (duplex.destroyed) return;
-
-    duplex.push(null);
-  });
-
-  duplex._destroy = function (err, callback) {
-    if (ws.readyState === ws.CLOSED) {
-      callback(err);
-      process.nextTick(emitClose, duplex);
-      return;
-    }
-
-    let called = false;
-
-    ws.once('error', function error(err) {
-      called = true;
-      callback(err);
-    });
-
-    ws.once('close', function close() {
-      if (!called) callback(err);
-      process.nextTick(emitClose, duplex);
-    });
-
-    if (terminateOnDestroy) ws.terminate();
-  };
-
-  duplex._final = function (callback) {
-    if (ws.readyState === ws.CONNECTING) {
-      ws.once('open', function open() {
-        duplex._final(callback);
-      });
-      return;
-    }
-
-    // If the value of the `_socket` property is `null` it means that `ws` is a
-    // client websocket and the handshake failed. In fact, when this happens, a
-    // socket is never assigned to the websocket. Wait for the `'error'` event
-    // that will be emitted by the websocket.
-    if (ws._socket === null) return;
-
-    if (ws._socket._writableState.finished) {
-      callback();
-      if (duplex._readableState.endEmitted) duplex.destroy();
-    } else {
-      ws._socket.once('finish', function finish() {
-        // `duplex` is not destroyed here because the `'end'` event will be
-        // emitted on `duplex` after this `'finish'` event. The EOF signaling
-        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
-        callback();
-      });
-      ws.close();
-    }
-  };
-
-  duplex._read = function () {
-    if (ws.isPaused) ws.resume();
-  };
-
-  duplex._write = function (chunk, encoding, callback) {
-    if (ws.readyState === ws.CONNECTING) {
-      ws.once('open', function open() {
-        duplex._write(chunk, encoding, callback);
-      });
-      return;
-    }
-
-    ws.send(chunk, callback);
-  };
-
-  duplex.on('end', duplexOnEnd);
-  duplex.on('error', duplexOnError);
-  return duplex;
-}
-
-module.exports = createWebSocketStream;
--- a/test/node_modules/ws/lib/subprotocol.js
+++ b/test/node_modules/ws/lib/subprotocol.js
@@ -1,62 +0,0 @@
-'use strict';
-
-const { tokenChars } = require('./validation');
-
-/**
- * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
- *
- * @param {String} header The field value of the header
- * @return {Set} The subprotocol names
- * @public
- */
-function parse(header) {
-  const protocols = new Set();
-  let start = -1;
-  let end = -1;
-  let i = 0;
-
-  for (i; i < header.length; i++) {
-    const code = header.charCodeAt(i);
-
-    if (end === -1 && tokenChars[code] === 1) {
-      if (start === -1) start = i;
-    } else if (
-      i !== 0 &&
-      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
-    ) {
-      if (end === -1 && start !== -1) end = i;
-    } else if (code === 0x2c /* ',' */) {
-      if (start === -1) {
-        throw new SyntaxError(`Unexpected character at index ${i}`);
-      }
-
-      if (end === -1) end = i;
-
-      const protocol = header.slice(start, end);
-
-      if (protocols.has(protocol)) {
-        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
-      }
-
-      protocols.add(protocol);
-      start = end = -1;
-    } else {
-      throw new SyntaxError(`Unexpected character at index ${i}`);
-    }
-  }
-
-  if (start === -1 || end !== -1) {
-    throw new SyntaxError('Unexpected end of input');
-  }
-
-  const protocol = header.slice(start, i);
-
-  if (protocols.has(protocol)) {
-    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
-  }
-
-  protocols.add(protocol);
-  return protocols;
-}
-
-module.exports = { parse };
--- a/test/node_modules/ws/lib/validation.js
+++ b/test/node_modules/ws/lib/validation.js
@@ -1,152 +0,0 @@
-'use strict';
-
-const { isUtf8 } = require('buffer');
-
-const { hasBlob } = require('./constants');
-
-//
-// Allowed token characters:
-//
-// '!', '#', '$', '%', '&', ''', '*', '+', '-',
-// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
-//
-// tokenChars[32] === 0 // ' '
-// tokenChars[33] === 1 // '!'
-// tokenChars[34] === 0 // '"'
-// ...
-//
-// prettier-ignore
-const tokenChars = [
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
-  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
-];
-
-/**
- * Checks if a status code is allowed in a close frame.
- *
- * @param {Number} code The status code
- * @return {Boolean} `true` if the status code is valid, else `false`
- * @public
- */
-function isValidStatusCode(code) {
-  return (
-    (code >= 1000 &&
-      code <= 1014 &&
-      code !== 1004 &&
-      code !== 1005 &&
-      code !== 1006) ||
-    (code >= 3000 && code <= 4999)
-  );
-}
-
-/**
- * Checks if a given buffer contains only correct UTF-8.
- * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
- * Markus Kuhn.
- *
- * @param {Buffer} buf The buffer to check
- * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
- * @public
- */
-function _isValidUTF8(buf) {
-  const len = buf.length;
-  let i = 0;
-
-  while (i < len) {
-    if ((buf[i] & 0x80) === 0) {
-      // 0xxxxxxx
-      i++;
-    } else if ((buf[i] & 0xe0) === 0xc0) {
-      // 110xxxxx 10xxxxxx
-      if (
-        i + 1 === len ||
-        (buf[i + 1] & 0xc0) !== 0x80 ||
-        (buf[i] & 0xfe) === 0xc0 // Overlong
-      ) {
-        return false;
-      }
-
-      i += 2;
-    } else if ((buf[i] & 0xf0) === 0xe0) {
-      // 1110xxxx 10xxxxxx 10xxxxxx
-      if (
-        i + 2 >= len ||
-        (buf[i + 1] & 0xc0) !== 0x80 ||
-        (buf[i + 2] & 0xc0) !== 0x80 ||
-        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
-        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
-      ) {
-        return false;
-      }
-
-      i += 3;
-    } else if ((buf[i] & 0xf8) === 0xf0) {
-      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-      if (
-        i + 3 >= len ||
-        (buf[i + 1] & 0xc0) !== 0x80 ||
-        (buf[i + 2] & 0xc0) !== 0x80 ||
-        (buf[i + 3] & 0xc0) !== 0x80 ||
-        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
-        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
-        buf[i] > 0xf4 // > U+10FFFF
-      ) {
-        return false;
-      }
-
-      i += 4;
-    } else {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Determines whether a value is a `Blob`.
- *
- * @param {*} value The value to be tested
- * @return {Boolean} `true` if `value` is a `Blob`, else `false`
- * @private
- */
-function isBlob(value) {
-  return (
-    hasBlob &&
-    typeof value === 'object' &&
-    typeof value.arrayBuffer === 'function' &&
-    typeof value.type === 'string' &&
-    typeof value.stream === 'function' &&
-    (value[Symbol.toStringTag] === 'Blob' ||
-      value[Symbol.toStringTag] === 'File')
-  );
-}
-
-module.exports = {
-  isBlob,
-  isValidStatusCode,
-  isValidUTF8: _isValidUTF8,
-  tokenChars
-};
-
-if (isUtf8) {
-  module.exports.isValidUTF8 = function (buf) {
-    return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
-  };
-} /* istanbul ignore else  */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
-  try {
-    const isValidUTF8 = require('utf-8-validate');
-
-    module.exports.isValidUTF8 = function (buf) {
-      return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
-    };
-  } catch (e) {
-    // Continue regardless of the error.
-  }
-}
--- a/test/node_modules/ws/lib/websocket-server.js
+++ b/test/node_modules/ws/lib/websocket-server.js
@@ -1,550 +0,0 @@
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
-
-'use strict';
-
-const EventEmitter = require('events');
-const http = require('http');
-const { Duplex } = require('stream');
-const { createHash } = require('crypto');
-
-const extension = require('./extension');
-const PerMessageDeflate = require('./permessage-deflate');
-const subprotocol = require('./subprotocol');
-const WebSocket = require('./websocket');
-const { GUID, kWebSocket } = require('./constants');
-
-const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
-
-const RUNNING = 0;
-const CLOSING = 1;
-const CLOSED = 2;
-
-/**
- * Class representing a WebSocket server.
- *
- * @extends EventEmitter
- */
-class WebSocketServer extends EventEmitter {
-  /**
-   * Create a `WebSocketServer` instance.
-   *
-   * @param {Object} options Configuration options
-   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
-   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
-   *     multiple times in the same tick
-   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
-   *     automatically send a pong in response to a ping
-   * @param {Number} [options.backlog=511] The maximum length of the queue of
-   *     pending connections
-   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
-   *     track clients
-   * @param {Function} [options.handleProtocols] A hook to handle protocols
-   * @param {String} [options.host] The hostname where to bind the server
-   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
-   *     size
-   * @param {Boolean} [options.noServer=false] Enable no server mode
-   * @param {String} [options.path] Accept only connections matching this path
-   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
-   *     permessage-deflate
-   * @param {Number} [options.port] The port where to bind the server
-   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
-   *     server to use
-   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
-   *     not to skip UTF-8 validation for text and close messages
-   * @param {Function} [options.verifyClient] A hook to reject connections
-   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
-   *     class to use. It must be the `WebSocket` class or class that extends it
-   * @param {Function} [callback] A listener for the `listening` event
-   */
-  constructor(options, callback) {
-    super();
-
-    options = {
-      allowSynchronousEvents: true,
-      autoPong: true,
-      maxPayload: 100 * 1024 * 1024,
-      skipUTF8Validation: false,
-      perMessageDeflate: false,
-      handleProtocols: null,
-      clientTracking: true,
-      verifyClient: null,
-      noServer: false,
-      backlog: null, // use default (511 as implemented in net.js)
-      server: null,
-      host: null,
-      path: null,
-      port: null,
-      WebSocket,
-      ...options
-    };
-
-    if (
-      (options.port == null && !options.server && !options.noServer) ||
-      (options.port != null && (options.server || options.noServer)) ||
-      (options.server && options.noServer)
-    ) {
-      throw new TypeError(
-        'One and only one of the "port", "server", or "noServer" options ' +
-          'must be specified'
-      );
-    }
-
-    if (options.port != null) {
-      this._server = http.createServer((req, res) => {
-        const body = http.STATUS_CODES[426];
-
-        res.writeHead(426, {
-          'Content-Length': body.length,
-          'Content-Type': 'text/plain'
-        });
-        res.end(body);
-      });
-      this._server.listen(
-        options.port,
-        options.host,
-        options.backlog,
-        callback
-      );
-    } else if (options.server) {
-      this._server = options.server;
-    }
-
-    if (this._server) {
-      const emitConnection = this.emit.bind(this, 'connection');
-
-      this._removeListeners = addListeners(this._server, {
-        listening: this.emit.bind(this, 'listening'),
-        error: this.emit.bind(this, 'error'),
-        upgrade: (req, socket, head) => {
-          this.handleUpgrade(req, socket, head, emitConnection);
-        }
-      });
-    }
-
-    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
-    if (options.clientTracking) {
-      this.clients = new Set();
-      this._shouldEmitClose = false;
-    }
-
-    this.options = options;
-    this._state = RUNNING;
-  }
-
-  /**
-   * Returns the bound address, the address family name, and port of the server
-   * as reported by the operating system if listening on an IP socket.
-   * If the server is listening on a pipe or UNIX domain socket, the name is
-   * returned as a string.
-   *
-   * @return {(Object|String|null)} The address of the server
-   * @public
-   */
-  address() {
-    if (this.options.noServer) {
-      throw new Error('The server is operating in "noServer" mode');
-    }
-
-    if (!this._server) return null;
-    return this._server.address();
-  }
-
-  /**
-   * Stop the server from accepting new connections and emit the `'close'` event
-   * when all existing connections are closed.
-   *
-   * @param {Function} [cb] A one-time listener for the `'close'` event
-   * @public
-   */
-  close(cb) {
-    if (this._state === CLOSED) {
-      if (cb) {
-        this.once('close', () => {
-          cb(new Error('The server is not running'));
-        });
-      }
-
-      process.nextTick(emitClose, this);
-      return;
-    }
-
-    if (cb) this.once('close', cb);
-
-    if (this._state === CLOSING) return;
-    this._state = CLOSING;
-
-    if (this.options.noServer || this.options.server) {
-      if (this._server) {
-        this._removeListeners();
-        this._removeListeners = this._server = null;
-      }
-
-      if (this.clients) {
-        if (!this.clients.size) {
-          process.nextTick(emitClose, this);
-        } else {
-          this._shouldEmitClose = true;
-        }
-      } else {
-        process.nextTick(emitClose, this);
-      }
-    } else {
-      const server = this._server;
-
-      this._removeListeners();
-      this._removeListeners = this._server = null;
-
-      //
-      // The HTTP/S server was created internally. Close it, and rely on its
-      // `'close'` event.
-      //
-      server.close(() => {
-        emitClose(this);
-      });
-    }
-  }
-
-  /**
-   * See if a given request should be handled by this server instance.
-   *
-   * @param {http.IncomingMessage} req Request object to inspect
-   * @return {Boolean} `true` if the request is valid, else `false`
-   * @public
-   */
-  shouldHandle(req) {
-    if (this.options.path) {
-      const index = req.url.indexOf('?');
-      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
-
-      if (pathname !== this.options.path) return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Handle a HTTP Upgrade request.
-   *
-   * @param {http.IncomingMessage} req The request object
-   * @param {Duplex} socket The network socket between the server and client
-   * @param {Buffer} head The first packet of the upgraded stream
-   * @param {Function} cb Callback
-   * @public
-   */
-  handleUpgrade(req, socket, head, cb) {
-    socket.on('error', socketOnError);
-
-    const key = req.headers['sec-websocket-key'];
-    const upgrade = req.headers.upgrade;
-    const version = +req.headers['sec-websocket-version'];
-
-    if (req.method !== 'GET') {
-      const message = 'Invalid HTTP method';
-      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
-      return;
-    }
-
-    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
-      const message = 'Invalid Upgrade header';
-      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-      return;
-    }
-
-    if (key === undefined || !keyRegex.test(key)) {
-      const message = 'Missing or invalid Sec-WebSocket-Key header';
-      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-      return;
-    }
-
-    if (version !== 13 && version !== 8) {
-      const message = 'Missing or invalid Sec-WebSocket-Version header';
-      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
-        'Sec-WebSocket-Version': '13, 8'
-      });
-      return;
-    }
-
-    if (!this.shouldHandle(req)) {
-      abortHandshake(socket, 400);
-      return;
-    }
-
-    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
-    let protocols = new Set();
-
-    if (secWebSocketProtocol !== undefined) {
-      try {
-        protocols = subprotocol.parse(secWebSocketProtocol);
-      } catch (err) {
-        const message = 'Invalid Sec-WebSocket-Protocol header';
-        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-        return;
-      }
-    }
-
-    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
-    const extensions = {};
-
-    if (
-      this.options.perMessageDeflate &&
-      secWebSocketExtensions !== undefined
-    ) {
-      const perMessageDeflate = new PerMessageDeflate(
-        this.options.perMessageDeflate,
-        true,
-        this.options.maxPayload
-      );
-
-      try {
-        const offers = extension.parse(secWebSocketExtensions);
-
-        if (offers[PerMessageDeflate.extensionName]) {
-          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
-          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
-        }
-      } catch (err) {
-        const message =
-          'Invalid or unacceptable Sec-WebSocket-Extensions header';
-        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
-        return;
-      }
-    }
-
-    //
-    // Optionally call external client verification handler.
-    //
-    if (this.options.verifyClient) {
-      const info = {
-        origin:
-          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
-        secure: !!(req.socket.authorized || req.socket.encrypted),
-        req
-      };
-
-      if (this.options.verifyClient.length === 2) {
-        this.options.verifyClient(info, (verified, code, message, headers) => {
-          if (!verified) {
-            return abortHandshake(socket, code || 401, message, headers);
-          }
-
-          this.completeUpgrade(
-            extensions,
-            key,
-            protocols,
-            req,
-            socket,
-            head,
-            cb
-          );
-        });
-        return;
-      }
-
-      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
-    }
-
-    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
-  }
-
-  /**
-   * Upgrade the connection to WebSocket.
-   *
-   * @param {Object} extensions The accepted extensions
-   * @param {String} key The value of the `Sec-WebSocket-Key` header
-   * @param {Set} protocols The subprotocols
-   * @param {http.IncomingMessage} req The request object
-   * @param {Duplex} socket The network socket between the server and client
-   * @param {Buffer} head The first packet of the upgraded stream
-   * @param {Function} cb Callback
-   * @throws {Error} If called more than once with the same socket
-   * @private
-   */
-  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
-    //
-    // Destroy the socket if the client has already sent a FIN packet.
-    //
-    if (!socket.readable || !socket.writable) return socket.destroy();
-
-    if (socket[kWebSocket]) {
-      throw new Error(
-        'server.handleUpgrade() was called more than once with the same ' +
-          'socket, possibly due to a misconfiguration'
-      );
-    }
-
-    if (this._state > RUNNING) return abortHandshake(socket, 503);
-
-    const digest = createHash('sha1')
-      .update(key + GUID)
-      .digest('base64');
-
-    const headers = [
-      'HTTP/1.1 101 Switching Protocols',
-      'Upgrade: websocket',
-      'Connection: Upgrade',
-      `Sec-WebSocket-Accept: ${digest}`
-    ];
-
-    const ws = new this.options.WebSocket(null, undefined, this.options);
-
-    if (protocols.size) {
-      //
-      // Optionally call external protocol selection handler.
-      //
-      const protocol = this.options.handleProtocols
-        ? this.options.handleProtocols(protocols, req)
-        : protocols.values().next().value;
-
-      if (protocol) {
-        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
-        ws._protocol = protocol;
-      }
-    }
-
-    if (extensions[PerMessageDeflate.extensionName]) {
-      const params = extensions[PerMessageDeflate.extensionName].params;
-      const value = extension.format({
-        [PerMessageDeflate.extensionName]: [params]
-      });
-      headers.push(`Sec-WebSocket-Extensions: ${value}`);
-      ws._extensions = extensions;
-    }
-
-    //
-    // Allow external modification/inspection of handshake headers.
-    //
-    this.emit('headers', headers, req);
-
-    socket.write(headers.concat('\r\n').join('\r\n'));
-    socket.removeListener('error', socketOnError);
-
-    ws.setSocket(socket, head, {
-      allowSynchronousEvents: this.options.allowSynchronousEvents,
-      maxPayload: this.options.maxPayload,
-      skipUTF8Validation: this.options.skipUTF8Validation
-    });
-
-    if (this.clients) {
-      this.clients.add(ws);
-      ws.on('close', () => {
-        this.clients.delete(ws);
-
-        if (this._shouldEmitClose && !this.clients.size) {
-          process.nextTick(emitClose, this);
-        }
-      });
-    }
-
-    cb(ws, req);
-  }
-}
-
-module.exports = WebSocketServer;
-
-/**
- * Add event listeners on an `EventEmitter` using a map of <event, listener>
- * pairs.
- *
- * @param {EventEmitter} server The event emitter
- * @param {Object.<String, Function>} map The listeners to add
- * @return {Function} A function that will remove the added listeners when
- *     called
- * @private
- */
-function addListeners(server, map) {
-  for (const event of Object.keys(map)) server.on(event, map[event]);
-
-  return function removeListeners() {
-    for (const event of Object.keys(map)) {
-      server.removeListener(event, map[event]);
-    }
-  };
-}
-
-/**
- * Emit a `'close'` event on an `EventEmitter`.
- *
- * @param {EventEmitter} server The event emitter
- * @private
- */
-function emitClose(server) {
-  server._state = CLOSED;
-  server.emit('close');
-}
-
-/**
- * Handle socket errors.
- *
- * @private
- */
-function socketOnError() {
-  this.destroy();
-}
-
-/**
- * Close the connection when preconditions are not fulfilled.
- *
- * @param {Duplex} socket The socket of the upgrade request
- * @param {Number} code The HTTP response status code
- * @param {String} [message] The HTTP response body
- * @param {Object} [headers] Additional HTTP response headers
- * @private
- */
-function abortHandshake(socket, code, message, headers) {
-  //
-  // The socket is writable unless the user destroyed or ended it before calling
-  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
-  // error. Handling this does not make much sense as the worst that can happen
-  // is that some of the data written by the user might be discarded due to the
-  // call to `socket.end()` below, which triggers an `'error'` event that in
-  // turn causes the socket to be destroyed.
-  //
-  message = message || http.STATUS_CODES[code];
-  headers = {
-    Connection: 'close',
-    'Content-Type': 'text/html',
-    'Content-Length': Buffer.byteLength(message),
-    ...headers
-  };
-
-  socket.once('finish', socket.destroy);
-
-  socket.end(
-    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
-      Object.keys(headers)
-        .map((h) => `${h}: ${headers[h]}`)
-        .join('\r\n') +
-      '\r\n\r\n' +
-      message
-  );
-}
-
-/**
- * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
- * one listener for it, otherwise call `abortHandshake()`.
- *
- * @param {WebSocketServer} server The WebSocket server
- * @param {http.IncomingMessage} req The request object
- * @param {Duplex} socket The socket of the upgrade request
- * @param {Number} code The HTTP response status code
- * @param {String} message The HTTP response body
- * @param {Object} [headers] The HTTP response headers
- * @private
- */
-function abortHandshakeOrEmitwsClientError(
-  server,
-  req,
-  socket,
-  code,
-  message,
-  headers
-) {
-  if (server.listenerCount('wsClientError')) {
-    const err = new Error(message);
-    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
-
-    server.emit('wsClientError', err, socket, req);
-  } else {
-    abortHandshake(socket, code, message, headers);
-  }
-}
--- a/test/node_modules/ws/lib/websocket.js
+++ b/test/node_modules/ws/lib/websocket.js
--- a/test/node_modules/ws/package.json
+++ b/test/node_modules/ws/package.json
@@ -1,69 +0,0 @@
-{
-  "name": "ws",
-  "version": "8.18.3",
-  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
-  "keywords": [
-    "HyBi",
-    "Push",
-    "RFC-6455",
-    "WebSocket",
-    "WebSockets",
-    "real-time"
-  ],
-  "homepage": "https://github.com/websockets/ws",
-  "bugs": "https://github.com/websockets/ws/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/websockets/ws.git"
-  },
-  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
-  "license": "MIT",
-  "main": "index.js",
-  "exports": {
-    ".": {
-      "browser": "./browser.js",
-      "import": "./wrapper.mjs",
-      "require": "./index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "browser": "browser.js",
-  "engines": {
-    "node": ">=10.0.0"
-  },
-  "files": [
-    "browser.js",
-    "index.js",
-    "lib/*.js",
-    "wrapper.mjs"
-  ],
-  "scripts": {
-    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js",
-    "integration": "mocha --throw-deprecation test/*.integration.js",
-    "lint": "eslint . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\""
-  },
-  "peerDependencies": {
-    "bufferutil": "^4.0.1",
-    "utf-8-validate": ">=5.0.2"
-  },
-  "peerDependenciesMeta": {
-    "bufferutil": {
-      "optional": true
-    },
-    "utf-8-validate": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "bufferutil": "^4.0.1",
-    "eslint": "^9.0.0",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-plugin-prettier": "^5.0.0",
-    "globals": "^16.0.0",
-    "mocha": "^8.4.0",
-    "nyc": "^15.0.0",
-    "prettier": "^3.0.0",
-    "utf-8-validate": "^6.0.0"
-  }
-}
--- a/test/node_modules/ws/wrapper.mjs
+++ b/test/node_modules/ws/wrapper.mjs
@@ -1,8 +0,0 @@
-import createWebSocketStream from './lib/stream.js';
-import Receiver from './lib/receiver.js';
-import Sender from './lib/sender.js';
-import WebSocket from './lib/websocket.js';
-import WebSocketServer from './lib/websocket-server.js';
-
-export { createWebSocketStream, Receiver, Sender, WebSocket, WebSocketServer };
-export default WebSocket;
--- a/test/package-lock.json
+++ b/test/package-lock.json
@@ -1,33 +0,0 @@
-{
-  "name": "test",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "dependencies": {
-        "ws": "^8.18.3"
-      }
-    },
-    "node_modules/ws": {
-      "version": "8.18.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
-      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    }
-  }
-}
--- a/test/package.json
+++ b/test/package.json
@@ -1,5 +0,0 @@
-{
-  "dependencies": {
-    "ws": "^8.18.3"
-  }
-}
--- a/test/ws-cluster-broadcast-color.js
+++ b/test/ws-cluster-broadcast-color.js
@@ -1,46 +0,0 @@
-// WebSocket client to broadcast neopattern color changes across the cluster
-// Usage: node ws-cluster-broadcast-color.js ws://<device-ip>/ws
-
-const WebSocket = require('ws');
-
-const url = process.argv[2] || 'ws://127.0.0.1/ws';
-const ws = new WebSocket(url);
-
-const colors = ['#FF0000', '#00FF00', '#0000FF', '#FFFF00', '#FF00FF', '#00FFFF'];
-let idx = 0;
-
-ws.on('open', () => {
-  console.log('Connected to', url);
-  // Broadcast color change every 5 seconds via cluster/broadcast
-  setInterval(() => {
-    const color = colors[idx % colors.length];
-    idx++;
-    const payload = { color, brightness: 128 };
-    const envelope = {
-      event: 'api/neopattern/color',
-      data: payload // server will serialize object payloads
-    };
-    const msg = { event: 'cluster/broadcast', payload: envelope };
-    ws.send(JSON.stringify(msg));
-    console.log('Broadcasted color event', payload);
-  }, 5000);
-});
-
-ws.on('message', (data) => {
-  try {
-    const msg = JSON.parse(data.toString());
-    console.log('Received:', msg);
-  } catch (e) {
-    console.log('Received raw:', data.toString());
-  }
-});
-
-ws.on('error', (err) => {
-  console.error('WebSocket error:', err.message);
-});
-
-ws.on('close', () => {
-  console.log('WebSocket closed');
-});
-
-
--- a/test/ws-cluster-broadcast-rainbow.js
+++ b/test/ws-cluster-broadcast-rainbow.js
@@ -1,71 +0,0 @@
-// WebSocket client to broadcast smooth rainbow color changes across the cluster
-// Usage: node ws-cluster-broadcast-rainbow.js ws://<device-ip>/ws
-
-const WebSocket = require('ws');
-
-const url = process.argv[2] || 'ws://127.0.0.1/ws';
-const ws = new WebSocket(url);
-
-function hsvToRgb(h, s, v) {
-  const c = v * s;
-  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-  const m = v - c;
-  let r = 0, g = 0, b = 0;
-  if (h < 60) { r = c; g = x; b = 0; }
-  else if (h < 120) { r = x; g = c; b = 0; }
-  else if (h < 180) { r = 0; g = c; b = x; }
-  else if (h < 240) { r = 0; g = x; b = c; }
-  else if (h < 300) { r = x; g = 0; b = c; }
-  else { r = c; g = 0; b = x; }
-  const R = Math.round((r + m) * 255);
-  const G = Math.round((g + m) * 255);
-  const B = Math.round((b + m) * 255);
-  return { r: R, g: G, b: B };
-}
-
-function toHex({ r, g, b }) {
-  const h = (n) => n.toString(16).padStart(2, '0').toUpperCase();
-  return `#${h(r)}${h(g)}${h(b)}`;
-}
-
-let hue = 0;
-const SAT = 1.0;   // full saturation
-const VAL = 1.0;   // full value
-const BRIGHTNESS = 128;
-const UPDATE_RATE = 100; // 100 ms
-
-let timer = null;
-
-ws.on('open', () => {
-  console.log('Connected to', url);
-  // UPDATE_RATE ms updates (10 Hz). Be aware this can saturate slow links.
-  timer = setInterval(() => {
-    const rgb = hsvToRgb(hue, SAT, VAL);
-    const color = toHex(rgb);
-    const envelope = {
-      event: 'api/neopattern/color',
-      data: { color, brightness: BRIGHTNESS }
-    };
-    const msg = { event: 'cluster/broadcast', payload: envelope };
-    try {
-      ws.send(JSON.stringify(msg));
-    } catch (_) {}
-    hue = (hue + 2) % 360; // advance hue (adjust for speed)
-  }, UPDATE_RATE);
-});
-
-ws.on('message', (data) => {
-  // Optionally throttle logs: comment out for quieter output
-  // console.log('WS:', data.toString());
-});
-
-ws.on('error', (err) => {
-  console.error('WebSocket error:', err.message);
-});
-
-ws.on('close', () => {
-  if (timer) clearInterval(timer);
-  console.log('WebSocket closed');
-});
-
-
--- a/test/ws-color-client.js
+++ b/test/ws-color-client.js
@@ -1,48 +0,0 @@
-// Simple WebSocket client to test streaming API color changes
-// Usage: node ws-color-client.js ws://<device-ip>/ws
-
-const WebSocket = require('ws');
-
-const url = process.argv[2] || 'ws://127.0.0.1/ws';
-const ws = new WebSocket(url);
-
-const colors = [
-  '#FF0000', // red
-  '#00FF00', // green
-  '#0000FF', // blue
-  '#FFFF00', // yellow
-  '#FF00FF', // magenta
-  '#00FFFF'  // cyan
-];
-let idx = 0;
-
-ws.on('open', () => {
-  console.log('Connected to', url);
-  // Send a message every 5 seconds to set solid color
-  setInterval(() => {
-    const color = colors[idx % colors.length];
-    idx++;
-    const payload = { color, brightness: 128 };
-    // Send payload as an object (server supports string or object)
-    const msg = { event: 'api/neopattern/color', payload };
-    ws.send(JSON.stringify(msg));
-    console.log('Sent color event', payload);
-  }, 5000);
-});
-
-ws.on('message', (data) => {
-  try {
-    const msg = JSON.parse(data.toString());
-    console.log('Received:', msg);
-  } catch (e) {
-    console.log('Received raw:', data.toString());
-  }
-});
-
-ws.on('error', (err) => {
-  console.error('WebSocket error:', err.message);
-});
-
-ws.on('close', () => {
-  console.log('WebSocket closed');
-});