brilliantsole 0.0.1

package/src/server/BaseServer.ts

@@ -0,0 +1,344 @@
+import { createConsole } from "../utils/Console.ts";
+import EventDispatcher, { BoundEventListeners, Event, EventMap } from "../utils/EventDispatcher.ts";
+import {
+  createServerMessage,
+  ServerMessageTypes,
+  DeviceMessage,
+  ServerMessage,
+  ServerMessageType,
+  createDeviceMessage,
+} from "./ServerUtils.ts";
+import Device, { BoundDeviceEventListeners, DeviceEventMap, DeviceEventType } from "../Device.ts";
+import { addEventListeners, removeEventListeners } from "../utils/EventUtils.ts";
+import scanner from "../scanner/Scanner.ts";
+import { parseMessage, parseStringFromDataView } from "../utils/ParseUtils.ts";
+import { ConnectionMessageType, ConnectionMessageTypes } from "../connection/BaseConnectionManager.ts";
+import { BoundScannerEventListeners, DiscoveredDevice, ScannerEventMap } from "../scanner/BaseScanner.ts";
+import { concatenateArrayBuffers } from "../utils/ArrayBufferUtils.ts";
+import DeviceManager, { DeviceManagerEventMap, BoundDeviceManagerEventListeners } from "../DeviceManager.ts";
+
+const _console = createConsole("BaseServer", { log: true });
+
+export const ServerEventTypes = ["clientConnected", "clientDisconnected"] as const;
+export type ServerEventType = (typeof ServerEventTypes)[number];
+
+interface ServerEventMessages {
+  clientConnected: { client: any };
+  clientDisconnected: { client: any };
+}
+
+export type ServerEventDispatcher = EventDispatcher<BaseServer, ServerEventType, ServerEventMessages>;
+export type ServerEvent = Event<BaseServer, ServerEventType, ServerEventMessages>;
+export type ServerEventMap = EventMap<BaseServer, ServerEventType, ServerEventMessages>;
+export type BoundServerEventListeners = BoundEventListeners<BaseServer, ServerEventType, ServerEventMessages>;
+
+abstract class BaseServer {
+  // EVENT DISPATCHER
+  protected eventDispatcher: ServerEventDispatcher = new EventDispatcher(this as BaseServer, ServerEventTypes);
+  get addEventListener() {
+    return this.eventDispatcher.addEventListener;
+  }
+  protected get dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get removeEventListener() {
+    return this.eventDispatcher.removeEventListener;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  // CONSTRUCTOR
+
+  constructor() {
+    _console.assertWithError(scanner, "no scanner defined");
+
+    addEventListeners(scanner, this.#boundScannerListeners);
+    addEventListeners(DeviceManager, this.#boundDeviceManagerListeners);
+    addEventListeners(this, this.#boundServerListeners);
+  }
+
+  get numberOfClients() {
+    return 0;
+  }
+
+  static #ClearSensorConfigurationsWhenNoClients = true;
+  static get ClearSensorConfigurationsWhenNoClients() {
+    return this.#ClearSensorConfigurationsWhenNoClients;
+  }
+  static set ClearSensorConfigurationsWhenNoClients(newValue) {
+    _console.assertTypeWithError(newValue, "boolean");
+    this.#ClearSensorConfigurationsWhenNoClients = newValue;
+  }
+
+  #clearSensorConfigurationsWhenNoClients = BaseServer.#ClearSensorConfigurationsWhenNoClients;
+  get clearSensorConfigurationsWhenNoClients() {
+    return this.#clearSensorConfigurationsWhenNoClients;
+  }
+  set clearSensorConfigurationsWhenNoClients(newValue) {
+    _console.assertTypeWithError(newValue, "boolean");
+    this.#clearSensorConfigurationsWhenNoClients = newValue;
+  }
+
+  // SERVER LISTENERS
+  #boundServerListeners: BoundServerEventListeners = {
+    clientConnected: this.#onClientConnected.bind(this),
+    clientDisconnected: this.#onClientDisconnected.bind(this),
+  };
+  #onClientConnected(event: ServerEventMap["clientConnected"]) {
+    const client = event.message.client;
+    _console.log("onClientConnected");
+  }
+  #onClientDisconnected(event: ServerEventMap["clientDisconnected"]) {
+    const client = event.message.client;
+    _console.log("onClientDisconnected");
+    if (this.numberOfClients == 0 && this.clearSensorConfigurationsWhenNoClients) {
+      DeviceManager.ConnectedDevices.forEach((device) => {
+        device.clearSensorConfiguration();
+        device.setTfliteInferencingEnabled(false);
+      });
+    }
+  }
+
+  // CLIENT MESSAGING
+  broadcastMessage(message: ArrayBuffer) {
+    _console.log("broadcasting", message);
+  }
+
+  // SCANNER
+  #boundScannerListeners: BoundScannerEventListeners = {
+    isScanningAvailable: this.#onScannerIsAvailable.bind(this),
+    isScanning: this.#onScannerIsScanning.bind(this),
+    discoveredDevice: this.#onScannerDiscoveredDevice.bind(this),
+    expiredDiscoveredDevice: this.#onExpiredDiscoveredDevice.bind(this),
+  };
+
+  #onScannerIsAvailable(event: ScannerEventMap["isScanningAvailable"]) {
+    this.broadcastMessage(this.#isScanningAvailableMessage);
+  }
+  get #isScanningAvailableMessage() {
+    return createServerMessage({ type: "isScanningAvailable", data: scanner!.isScanningAvailable });
+  }
+
+  #onScannerIsScanning(event: ScannerEventMap["isScanning"]) {
+    this.broadcastMessage(this.#isScanningMessage);
+  }
+  get #isScanningMessage() {
+    return createServerMessage({ type: "isScanning", data: scanner!.isScanning });
+  }
+
+  #onScannerDiscoveredDevice(event: ScannerEventMap["discoveredDevice"]) {
+    const { discoveredDevice } = event.message;
+    _console.log(discoveredDevice);
+
+    this.broadcastMessage(this.#createDiscoveredDeviceMessage(discoveredDevice));
+  }
+  #createDiscoveredDeviceMessage(discoveredDevice: DiscoveredDevice) {
+    return createServerMessage({ type: "discoveredDevice", data: discoveredDevice });
+  }
+
+  #onExpiredDiscoveredDevice(event: ScannerEventMap["expiredDiscoveredDevice"]) {
+    const { discoveredDevice } = event.message;
+    _console.log("expired", discoveredDevice);
+    this.broadcastMessage(this.#createExpiredDiscoveredDeviceMessage(discoveredDevice));
+  }
+  #createExpiredDiscoveredDeviceMessage(discoveredDevice: DiscoveredDevice) {
+    return createServerMessage({ type: "expiredDiscoveredDevice", data: discoveredDevice.bluetoothId });
+  }
+
+  get #discoveredDevicesMessage() {
+    const serverMessages: ServerMessage[] = scanner!.discoveredDevicesArray
+      .filter((discoveredDevice) => {
+        const existingConnectedDevice = DeviceManager.ConnectedDevices.find(
+          (device) => device.bluetoothId == discoveredDevice.bluetoothId
+        );
+        return !existingConnectedDevice;
+      })
+      .map((discoveredDevice) => {
+        return { type: "discoveredDevice", data: discoveredDevice };
+      });
+    return createServerMessage(...serverMessages);
+  }
+
+  get #connectedDevicesMessage() {
+    return createServerMessage({
+      type: "connectedDevices",
+      data: JSON.stringify(DeviceManager.ConnectedDevices.map((device) => device.bluetoothId)),
+    });
+  }
+
+  // DEVICE LISTENERS
+
+  #boundDeviceListeners: BoundDeviceEventListeners = {
+    connectionMessage: this.#onDeviceConnectionMessage.bind(this),
+  };
+
+  #createDeviceMessage(device: Device, messageType: ConnectionMessageType, dataView?: DataView): DeviceMessage {
+    return {
+      type: messageType as DeviceEventType,
+      data: dataView || device.latestConnectionMessage.get(messageType),
+    };
+  }
+
+  #onDeviceConnectionMessage(deviceEvent: DeviceEventMap["connectionMessage"]) {
+    const { target: device, message } = deviceEvent;
+    _console.log("onDeviceConnectionMessage", deviceEvent.message);
+
+    if (!device.isConnected) {
+      return;
+    }
+
+    const { messageType, dataView } = message;
+
+    this.broadcastMessage(
+      this.#createDeviceServerMessage(device, this.#createDeviceMessage(device, messageType, dataView))
+    );
+  }
+
+  // STATIC DEVICE LISTENERS
+  #boundDeviceManagerListeners: BoundDeviceManagerEventListeners = {
+    deviceConnected: this.#onDeviceConnected.bind(this),
+    deviceDisconnected: this.#onDeviceDisconnected.bind(this),
+    deviceIsConnected: this.#onDeviceIsConnected.bind(this),
+  };
+
+  #onDeviceConnected(staticDeviceEvent: DeviceManagerEventMap["deviceConnected"]) {
+    const { device } = staticDeviceEvent.message;
+    _console.log("onDeviceConnected", device.bluetoothId);
+    addEventListeners(device, this.#boundDeviceListeners);
+    device.isServerSide = true;
+  }
+
+  #onDeviceDisconnected(staticDeviceEvent: DeviceManagerEventMap["deviceDisconnected"]) {
+    const { device } = staticDeviceEvent.message;
+    _console.log("onDeviceDisconnected", device.bluetoothId);
+    removeEventListeners(device, this.#boundDeviceListeners);
+  }
+
+  #onDeviceIsConnected(staticDeviceEvent: DeviceManagerEventMap["deviceIsConnected"]) {
+    const { device } = staticDeviceEvent.message;
+    _console.log("onDeviceIsConnected", device.bluetoothId);
+    this.broadcastMessage(this.#createDeviceIsConnectedMessage(device));
+  }
+  #createDeviceIsConnectedMessage(device: Device) {
+    return this.#createDeviceServerMessage(device, { type: "isConnected", data: device.isConnected });
+  }
+
+  #createDeviceServerMessage(device: Device, ...messages: DeviceMessage[]) {
+    return createServerMessage({
+      type: "deviceMessage",
+      data: [device.bluetoothId!, createDeviceMessage(...messages)],
+    });
+  }
+
+  // PARSING
+  protected parseClientMessage(dataView: DataView) {
+    let responseMessages: ArrayBuffer[] = [];
+
+    parseMessage(dataView, ServerMessageTypes, this.#onClientMessage.bind(this), { responseMessages }, true);
+
+    responseMessages = responseMessages.filter(Boolean);
+
+    if (responseMessages.length > 0) {
+      return concatenateArrayBuffers(responseMessages);
+    }
+  }
+
+  #onClientMessage(messageType: ServerMessageType, dataView: DataView, context: { responseMessages: ArrayBuffer[] }) {
+    const { responseMessages } = context;
+    switch (messageType) {
+      case "isScanningAvailable":
+        responseMessages.push(this.#isScanningAvailableMessage);
+        break;
+      case "isScanning":
+        responseMessages.push(this.#isScanningMessage);
+        break;
+      case "startScan":
+        scanner!.startScan();
+        break;
+      case "stopScan":
+        scanner!.stopScan();
+        break;
+      case "discoveredDevices":
+        responseMessages.push(this.#discoveredDevicesMessage);
+        break;
+      case "connectToDevice":
+        {
+          const { string: deviceId } = parseStringFromDataView(dataView);
+          scanner!.connectToDevice(deviceId);
+        }
+        break;
+      case "disconnectFromDevice":
+        {
+          const { string: deviceId } = parseStringFromDataView(dataView);
+          const device = DeviceManager.ConnectedDevices.find((device) => device.bluetoothId == deviceId);
+          if (!device) {
+            _console.error(`no device found with id ${deviceId}`);
+            break;
+          }
+          device.disconnect();
+        }
+        break;
+      case "connectedDevices":
+        responseMessages.push(this.#connectedDevicesMessage);
+        break;
+      case "deviceMessage":
+        {
+          const { string: deviceId, byteOffset } = parseStringFromDataView(dataView);
+          const device = DeviceManager.ConnectedDevices.find((device) => device.bluetoothId == deviceId);
+          if (!device) {
+            _console.error(`no device found with id ${deviceId}`);
+            break;
+          }
+          const _dataView = new DataView(dataView.buffer, dataView.byteOffset + byteOffset);
+          const responseMessage = this.parseClientDeviceMessage(device, _dataView);
+          if (responseMessage) {
+            responseMessages.push(responseMessage);
+          }
+        }
+        break;
+      default:
+        _console.error(`uncaught messageType "${messageType}"`);
+        break;
+    }
+  }
+
+  protected parseClientDeviceMessage(device: Device, dataView: DataView) {
+    _console.log("onDeviceMessage", device.bluetoothId, dataView);
+
+    let responseMessages: DeviceMessage[] = [];
+
+    parseMessage(
+      dataView,
+      ConnectionMessageTypes,
+      this.#parseClientDeviceMessageCallback.bind(this),
+      { responseMessages, device },
+      true
+    );
+
+    if (responseMessages.length > 0) {
+      return this.#createDeviceServerMessage(device, ...responseMessages);
+    }
+  }
+
+  #parseClientDeviceMessageCallback(
+    messageType: ConnectionMessageType,
+    dataView: DataView,
+    context: { responseMessages: DeviceMessage[]; device: Device }
+  ) {
+    _console.log(`clientDeviceMessage ${messageType} (${dataView.byteLength} bytes)`);
+    switch (messageType) {
+      case "smp":
+        context.device.connectionManager!.sendSmpMessage(dataView.buffer);
+        break;
+      case "tx":
+        context.device.connectionManager!.sendTxData(dataView.buffer);
+        break;
+      default:
+        context.responseMessages.push(this.#createDeviceMessage(context.device, messageType));
+        break;
+    }
+  }
+}
+
+export default BaseServer;

package/src/server/ServerUtils.ts

@@ -0,0 +1,93 @@
+import { DeviceEventTypes } from "../Device.ts";
+import { ConnectionMessageType, ConnectionMessageTypes } from "../connection/BaseConnectionManager.ts";
+import { concatenateArrayBuffers } from "../utils/ArrayBufferUtils.ts";
+import { createConsole } from "../utils/Console.ts";
+import { DeviceEventType } from "../Device.ts";
+
+const _console = createConsole("ServerUtils", { log: false });
+
+export const ServerMessageTypes = [
+  "isScanningAvailable",
+  "isScanning",
+  "startScan",
+  "stopScan",
+  "discoveredDevice",
+  "discoveredDevices",
+  "expiredDiscoveredDevice",
+  "connectToDevice",
+  "disconnectFromDevice",
+  "connectedDevices",
+  "deviceMessage",
+] as const;
+export type ServerMessageType = (typeof ServerMessageTypes)[number];
+
+export const DeviceMessageTypes = ["connectionStatus", "batteryLevel", "deviceInformation", "rx", "smp"] as const;
+export type DeviceMessageType = (typeof DeviceMessageTypes)[number];
+
+// MESSAGING
+
+export type MessageLike = number | number[] | ArrayBufferLike | DataView | boolean | string | any;
+
+export interface Message<MessageType extends string> {
+  type: MessageType;
+  data?: MessageLike | MessageLike[];
+}
+
+export function createMessage<MessageType extends string>(
+  enumeration: readonly MessageType[],
+  ...messages: (Message<MessageType> | MessageType)[]
+) {
+  _console.log("createMessage", ...messages);
+
+  const messageBuffers = messages.map((message) => {
+    if (typeof message == "string") {
+      message = { type: message };
+    }
+
+    if (message.data != undefined) {
+      if (!Array.isArray(message.data)) {
+        message.data = [message.data];
+      }
+    } else {
+      message.data = [];
+    }
+
+    const messageDataArrayBuffer = concatenateArrayBuffers(...message.data);
+    const messageDataArrayBufferByteLength = messageDataArrayBuffer.byteLength;
+
+    _console.assertEnumWithError(message.type, enumeration);
+    const messageTypeEnum = enumeration.indexOf(message.type);
+
+    const messageDataLengthDataView = new DataView(new ArrayBuffer(2));
+    messageDataLengthDataView.setUint16(0, messageDataArrayBufferByteLength, true);
+
+    return concatenateArrayBuffers(messageTypeEnum, messageDataLengthDataView, messageDataArrayBuffer);
+  });
+  _console.log("messageBuffers", ...messageBuffers);
+  return concatenateArrayBuffers(...messageBuffers);
+}
+
+export type ServerMessage = ServerMessageType | Message<ServerMessageType>;
+export function createServerMessage(...messages: ServerMessage[]) {
+  _console.log("createServerMessage", ...messages);
+  return createMessage(ServerMessageTypes, ...messages);
+}
+
+export type DeviceMessage = DeviceEventType | Message<DeviceEventType>;
+export function createDeviceMessage(...messages: DeviceMessage[]) {
+  _console.log("createDeviceMessage", ...messages);
+  return createMessage(DeviceEventTypes, ...messages);
+}
+
+export type ClientDeviceMessage = ConnectionMessageType | Message<ConnectionMessageType>;
+export function createClientDeviceMessage(...messages: ClientDeviceMessage[]) {
+  _console.log("createClientDeviceMessage", ...messages);
+  return createMessage(ConnectionMessageTypes, ...messages);
+}
+
+// STATIC MESSAGES
+export const isScanningAvailableRequestMessage = createServerMessage("isScanningAvailable");
+export const isScanningRequestMessage = createServerMessage("isScanning");
+export const startScanRequestMessage = createServerMessage("startScan");
+export const stopScanRequestMessage = createServerMessage("stopScan");
+export const discoveredDevicesMessage = createServerMessage("discoveredDevices");

package/src/server/udp/UDPServer.ts

@@ -0,0 +1,229 @@
+import { concatenateArrayBuffers, dataToArrayBuffer } from "../../utils/ArrayBufferUtils.ts";
+import { createConsole } from "../../utils/Console.ts";
+import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import { parseMessage } from "../../utils/ParseUtils.ts";
+import BaseServer from "../BaseServer.ts";
+import {
+  createUDPServerMessage,
+  pongUDPClientTimeout,
+  removeUDPClientTimeout,
+  udpPongMessage,
+  UDPServerMessageType,
+  UDPServerMessageTypes,
+} from "./UDPUtils.ts";
+
+/** NODE_START */
+import type * as dgram from "dgram";
+import Timer from "../../utils/Timer.ts";
+/** NODE_END */
+
+const _console = createConsole("UDPServer", { log: true });
+
+interface UDPClient extends dgram.RemoteInfo {
+  receivePort?: number;
+  isAlive?: boolean;
+  removeSelfTimer: Timer;
+  lastTimeSentData: number;
+}
+
+interface UDPClientContext {
+  client: UDPClient;
+  responseMessages: (ArrayBuffer | undefined)[];
+}
+
+class UDPServer extends BaseServer {
+  // CLIENTS
+  #clients: UDPClient[] = [];
+  get numberOfClients() {
+    return this.#clients.length;
+  }
+
+  #getClientByRemoteInfo(remoteInfo: dgram.RemoteInfo, createIfNotFound = false) {
+    const { address, port } = remoteInfo;
+    let client = this.#clients.find((client) => client.address == address && client.port == port);
+    if (!client && createIfNotFound) {
+      client = {
+        ...remoteInfo,
+        isAlive: true,
+        removeSelfTimer: new Timer(() => this.#removeClient(client!), removeUDPClientTimeout),
+        lastTimeSentData: 0,
+      };
+      _console.log("created new client", client);
+
+      this.#clients.push(client);
+      _console.log(`currently have ${this.numberOfClients} clients`);
+      this.dispatchEvent("clientConnected", { client });
+    }
+    return client;
+  }
+
+  #remoteInfoToString(client: dgram.RemoteInfo) {
+    const { address, port } = client;
+    return `${address}:${port}`;
+  }
+  #clientToString(client: UDPClient) {
+    const { address, port, receivePort } = client;
+    return `${address}:${port}=>${receivePort}`;
+  }
+
+  // UDP SOCKET
+
+  #socket?: dgram.Socket;
+  get socket() {
+    return this.#socket;
+  }
+  set socket(newSocket) {
+    if (this.#socket == newSocket) {
+      _console.log("redundant udp socket assignment");
+      return;
+    }
+    _console.log("assigning udp socket...");
+
+    if (this.#socket) {
+      _console.log("clearing existing udp socket...");
+      removeEventListeners(this.#socket, this.#boundSocketListeners);
+    }
+
+    addEventListeners(newSocket, this.#boundSocketListeners);
+    this.#socket = newSocket;
+
+    _console.log("assigned udp socket");
+  }
+
+  // UDP SOCKET LISTENERS
+
+  #boundSocketListeners = {
+    close: this.#onSocketClose.bind(this),
+    connect: this.#onSocketConnect.bind(this),
+    error: this.#onSocketError.bind(this),
+    listening: this.#onSocketListening.bind(this),
+    message: this.#onSocketMessage.bind(this),
+  };
+
+  #onSocketClose() {
+    _console.log("socket close");
+  }
+  #onSocketConnect() {
+    _console.log("socket connect");
+  }
+  #onSocketError(error: Error) {
+    _console.error("socket error", error);
+  }
+  #onSocketListening() {
+    const address = this.#socket!.address();
+    _console.log(`socket listening on port ${address.address}:${address.port}`);
+  }
+  #onSocketMessage(message: Buffer, remoteInfo: dgram.RemoteInfo) {
+    _console.log(`received ${message.length} bytes from ${this.#remoteInfoToString(remoteInfo)}`);
+    const client = this.#getClientByRemoteInfo(remoteInfo, true);
+    if (!client) {
+      _console.error("no client found");
+      return;
+    }
+    client.removeSelfTimer.restart();
+    const dataView = new DataView(dataToArrayBuffer(message));
+    this.#onClientData(client, dataView);
+  }
+
+  // PARSING
+  #onClientData(client: UDPClient, dataView: DataView) {
+    _console.log(`parsing ${dataView.byteLength} bytes from ${this.#clientToString(client)}`, dataView.buffer);
+    let responseMessages: ArrayBuffer[] = [];
+    parseMessage(
+      dataView,
+      UDPServerMessageTypes,
+      this.#onClientUDPMessage.bind(this),
+      { responseMessages, client },
+      true
+    );
+
+    responseMessages = responseMessages.filter(Boolean);
+
+    if (responseMessages.length == 0) {
+      _console.log("no response to send");
+      return;
+    }
+
+    if (client.receivePort == undefined) {
+      _console.log("client has no defined receivePort");
+      return;
+    }
+
+    const response = concatenateArrayBuffers(responseMessages);
+    _console.log(`responding with ${response.byteLength} bytes...`, response);
+    this.#sendToClient(client, response);
+  }
+  #onClientUDPMessage(messageType: UDPServerMessageType, dataView: DataView, context: UDPClientContext) {
+    const { client, responseMessages } = context;
+    _console.log(`received "${messageType}" message from ${client.address}:${client.port}`);
+    switch (messageType) {
+      case "ping":
+        responseMessages.push(this.#createPongMessage(context));
+        break;
+      case "pong":
+        break;
+      case "setRemoteReceivePort":
+        responseMessages.push(this.#parseRemoteReceivePort(dataView, client));
+        break;
+      case "serverMessage":
+        const responseMessage = this.parseClientMessage(dataView);
+        if (responseMessage) {
+          responseMessages.push(createUDPServerMessage({ type: "serverMessage", data: responseMessage }));
+        }
+        break;
+
+      default:
+        _console.error(`uncaught messageType "${messageType}"`);
+        break;
+    }
+  }
+
+  #createPongMessage(context: UDPClientContext) {
+    const { client } = context;
+    // TODO: - no need to ping if streaming sensor data
+    return udpPongMessage;
+  }
+
+  #parseRemoteReceivePort(dataView: DataView, client: UDPClient) {
+    const receivePort = dataView.getUint16(0);
+    client.receivePort = receivePort;
+    _console.log(`updated ${client.address}:${client.port} receivePort to ${receivePort}`);
+    const responseDataView = new DataView(new ArrayBuffer(2));
+    responseDataView.setUint16(0, client.receivePort);
+    return createUDPServerMessage({ type: "setRemoteReceivePort", data: responseDataView });
+  }
+
+  // CLIENT MESSAGING
+  #sendToClient(client: UDPClient, message: ArrayBuffer) {
+    _console.log(`sending ${message.byteLength} bytes to ${this.#clientToString(client)}...`);
+    try {
+      this.#socket!.send(new Uint8Array(message), client.receivePort, client.address, (error, bytes) => {
+        if (error) {
+          _console.error("error sending data", error);
+          return;
+        }
+        _console.log(`sent ${bytes} bytes`);
+        client.lastTimeSentData = Date.now();
+      });
+    } catch (error) {
+      _console.error("serious error sending data", error);
+    }
+  }
+  broadcastMessage(message: ArrayBuffer) {
+    super.broadcastMessage(message);
+    this.#clients.forEach((client) => {
+      this.#sendToClient(client, createUDPServerMessage({ type: "serverMessage", data: message }));
+    });
+  }
+
+  // REMOVE CLIENT
+  #removeClient(client: UDPClient) {
+    _console.log(`removing client ${this.#clientToString(client)}...`);
+    client.removeSelfTimer.stop();
+    this.#clients = this.#clients.filter((_client) => _client != client);
+    _console.log(`currently have ${this.numberOfClients} clients`);
+    this.dispatchEvent("clientDisconnected", { client });
+  }
+}
+
+export default UDPServer;

package/src/server/udp/UDPUtils.ts

@@ -0,0 +1,20 @@
+import { createConsole } from "../../utils/Console.ts";
+import { createMessage, Message } from "../ServerUtils.ts";
+
+const _console = createConsole("UDPUtils", { log: false });
+
+export const pongUDPClientTimeout = 2_000;
+export const removeUDPClientTimeout = 3_000;
+
+export const UDPServerMessageTypes = ["ping", "pong", "setRemoteReceivePort", "serverMessage"] as const;
+export type UDPServerMessageType = (typeof UDPServerMessageTypes)[number];
+
+export type UDPServerMessage = UDPServerMessageType | Message<UDPServerMessageType>;
+export function createUDPServerMessage(...messages: UDPServerMessage[]) {
+  _console.log("createUDPServerMessage", ...messages);
+  return createMessage(UDPServerMessageTypes, ...messages);
+}
+
+// STATIC MESSAGES
+export const udpPingMessage = createUDPServerMessage("ping");
+export const udpPongMessage = createUDPServerMessage("pong");