@9c5s/node-tcnet 0.5.1

package/dist/index.mjs

@@ -0,0 +1,764 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/tcnet.ts
+import { createSocket } from "dgram";
+
+// src/utils.ts
+import { networkInterfaces } from "os";
+function calculateBroadcastAddress(address, netmask) {
+  const addrParts = address.split(".").map(Number);
+  const maskParts = netmask.split(".").map(Number);
+  return addrParts.map((a, i) => a | ~maskParts[i] & 255).join(".");
+}
+function interfaceAddress(ifname) {
+  const interfaces = networkInterfaces();
+  const intf = interfaces[ifname];
+  if (!intf) {
+    throw new Error(`Interface ${ifname} does not exist`);
+  }
+  const address = intf.find((el) => el.family === "IPv4");
+  if (!address) {
+    throw new Error(`Interface ${ifname} does not have IPv4 address`);
+  }
+  return calculateBroadcastAddress(address.address, address.netmask);
+}
+var assert = (condition, message) => {
+  if (!condition) {
+    throw new Error(`Assertion failed: ${message}`);
+  }
+};
+
+// src/network.ts
+var TCNetMessageType = /* @__PURE__ */ ((TCNetMessageType2) => {
+  TCNetMessageType2[TCNetMessageType2["OptIn"] = 2] = "OptIn";
+  TCNetMessageType2[TCNetMessageType2["OptOut"] = 3] = "OptOut";
+  TCNetMessageType2[TCNetMessageType2["Status"] = 5] = "Status";
+  TCNetMessageType2[TCNetMessageType2["TimeSync"] = 10] = "TimeSync";
+  TCNetMessageType2[TCNetMessageType2["Error"] = 13] = "Error";
+  TCNetMessageType2[TCNetMessageType2["Request"] = 20] = "Request";
+  TCNetMessageType2[TCNetMessageType2["ApplicationData"] = 30] = "ApplicationData";
+  TCNetMessageType2[TCNetMessageType2["Control"] = 101] = "Control";
+  TCNetMessageType2[TCNetMessageType2["Text"] = 128] = "Text";
+  TCNetMessageType2[TCNetMessageType2["Keyboard"] = 132] = "Keyboard";
+  TCNetMessageType2[TCNetMessageType2["Data"] = 200] = "Data";
+  TCNetMessageType2[TCNetMessageType2["File"] = 204] = "File";
+  TCNetMessageType2[TCNetMessageType2["Time"] = 254] = "Time";
+  return TCNetMessageType2;
+})(TCNetMessageType || {});
+var TCNetDataPacketType = /* @__PURE__ */ ((TCNetDataPacketType2) => {
+  TCNetDataPacketType2[TCNetDataPacketType2["MetricsData"] = 2] = "MetricsData";
+  TCNetDataPacketType2[TCNetDataPacketType2["MetaData"] = 4] = "MetaData";
+  TCNetDataPacketType2[TCNetDataPacketType2["BeatGridData"] = 8] = "BeatGridData";
+  TCNetDataPacketType2[TCNetDataPacketType2["CUEData"] = 12] = "CUEData";
+  TCNetDataPacketType2[TCNetDataPacketType2["SmallWaveFormData"] = 16] = "SmallWaveFormData";
+  TCNetDataPacketType2[TCNetDataPacketType2["BigWaveFormData"] = 32] = "BigWaveFormData";
+  TCNetDataPacketType2[TCNetDataPacketType2["MixerData"] = 150] = "MixerData";
+  return TCNetDataPacketType2;
+})(TCNetDataPacketType || {});
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Auto"] = 1] = "Auto";
+  NodeType2[NodeType2["Master"] = 2] = "Master";
+  NodeType2[NodeType2["Slave"] = 4] = "Slave";
+  NodeType2[NodeType2["Repeater"] = 8] = "Repeater";
+  return NodeType2;
+})(NodeType || {});
+var TCNetPacket = class {
+  buffer;
+  header;
+};
+var TCNetManagementHeader = class _TCNetManagementHeader {
+  static MAJOR_VERSION = 3;
+  static MAGIC_HEADER = "TCN";
+  buffer;
+  nodeId;
+  minorVersion;
+  messageType;
+  nodeName;
+  seq;
+  nodeType;
+  nodeOptions;
+  timestamp;
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  read() {
+    this.nodeId = this.buffer.readUInt16LE(0);
+    assert(this.buffer.readUInt8(2) == _TCNetManagementHeader.MAJOR_VERSION);
+    this.minorVersion = this.buffer.readUInt8(3);
+    assert(this.buffer.slice(4, 7).toString("ascii") == _TCNetManagementHeader.MAGIC_HEADER);
+    this.messageType = this.buffer.readUInt8(7);
+    this.nodeName = this.buffer.slice(8, 16).toString("ascii").replace(/\0.*$/g, "");
+    this.seq = this.buffer.readUInt8(16);
+    this.nodeType = this.buffer.readUInt8(17);
+    this.nodeOptions = this.buffer.readUInt16LE(18);
+    this.timestamp = this.buffer.readUInt32LE(20);
+  }
+  write() {
+    assert(Buffer.from(this.nodeName, "ascii").length <= 8);
+    this.buffer.writeUInt16LE(this.nodeId, 0);
+    this.buffer.writeUInt8(_TCNetManagementHeader.MAJOR_VERSION, 2);
+    this.buffer.writeUInt8(this.minorVersion, 3);
+    this.buffer.write(_TCNetManagementHeader.MAGIC_HEADER, 4, "ascii");
+    this.buffer.writeUInt8(this.messageType, 7);
+    this.buffer.write(this.nodeName.padEnd(8, "\0"), 8, "ascii");
+    this.buffer.writeUInt8(this.seq, 16);
+    this.buffer.writeUInt8(this.nodeType, 17);
+    this.buffer.writeUInt16LE(this.nodeOptions, 18);
+    this.buffer.writeUInt32LE(this.timestamp, 20);
+  }
+};
+var TCNetOptInPacket = class extends TCNetPacket {
+  nodeCount;
+  nodeListenerPort;
+  uptime;
+  vendorName;
+  appName;
+  majorVersion;
+  minorVersion;
+  bugVersion;
+  read() {
+    this.nodeCount = this.buffer.readUInt16LE(24);
+    this.nodeListenerPort = this.buffer.readUInt16LE(26);
+    this.uptime = this.buffer.readUInt16LE(28);
+    this.vendorName = this.buffer.slice(32, 48).toString("ascii").replace(/\0.*$/g, "");
+    this.appName = this.buffer.slice(48, 64).toString("ascii").replace(/\0.*$/g, "");
+    this.majorVersion = this.buffer.readUInt8(64);
+    this.minorVersion = this.buffer.readUInt8(65);
+    this.bugVersion = this.buffer.readUInt8(66);
+  }
+  write() {
+    assert(Buffer.from(this.vendorName, "ascii").length <= 16);
+    assert(Buffer.from(this.appName, "ascii").length <= 16);
+    this.buffer.writeUInt16LE(this.nodeCount, 24);
+    this.buffer.writeUInt16LE(this.nodeListenerPort, 26);
+    this.buffer.writeUInt16LE(this.uptime, 28);
+    this.buffer.write(this.vendorName.padEnd(16, "\0"), 32, "ascii");
+    this.buffer.write(this.appName.padEnd(16, "\0"), 48, "ascii");
+    this.buffer.writeUInt8(this.majorVersion, 64);
+    this.buffer.writeUInt8(this.minorVersion, 65);
+    this.buffer.writeUInt8(this.bugVersion, 66);
+  }
+  length() {
+    return 68;
+  }
+  type() {
+    return 2 /* OptIn */;
+  }
+};
+var TCNetOptOutPacket = class extends TCNetPacket {
+  nodeCount;
+  nodeListenerPort;
+  read() {
+    this.nodeCount = this.buffer.readUInt16LE(24);
+    this.nodeListenerPort = this.buffer.readUInt16LE(26);
+  }
+  write() {
+    this.buffer.writeUInt16LE(this.nodeCount, 24);
+    this.buffer.writeUInt16LE(this.nodeListenerPort, 26);
+  }
+  length() {
+    return 28;
+  }
+  type() {
+    return 3 /* OptOut */;
+  }
+};
+var TCNetLayerStatus = /* @__PURE__ */ ((TCNetLayerStatus2) => {
+  TCNetLayerStatus2[TCNetLayerStatus2["IDLE"] = 0] = "IDLE";
+  TCNetLayerStatus2[TCNetLayerStatus2["PLAYING"] = 3] = "PLAYING";
+  TCNetLayerStatus2[TCNetLayerStatus2["LOOPING"] = 4] = "LOOPING";
+  TCNetLayerStatus2[TCNetLayerStatus2["PAUSED"] = 5] = "PAUSED";
+  TCNetLayerStatus2[TCNetLayerStatus2["STOPPED"] = 6] = "STOPPED";
+  TCNetLayerStatus2[TCNetLayerStatus2["CUEDOWN"] = 7] = "CUEDOWN";
+  TCNetLayerStatus2[TCNetLayerStatus2["PLATTERDOWN"] = 8] = "PLATTERDOWN";
+  TCNetLayerStatus2[TCNetLayerStatus2["FFWD"] = 9] = "FFWD";
+  TCNetLayerStatus2[TCNetLayerStatus2["FFRV"] = 10] = "FFRV";
+  TCNetLayerStatus2[TCNetLayerStatus2["HOLD"] = 11] = "HOLD";
+  return TCNetLayerStatus2;
+})(TCNetLayerStatus || {});
+var TCNetStatusPacket = class extends TCNetPacket {
+  data = null;
+  layers = new Array(8);
+  read() {
+    this.data = {
+      nodeCount: this.buffer.readUInt16LE(24),
+      nodeListenerPort: this.buffer.readUInt16LE(26),
+      smpteMode: this.buffer.readUInt8(83),
+      autoMasterMode: this.buffer.readUInt8(84)
+    };
+    for (let n = 0; n < 8; n++) {
+      this.layers[n] = {
+        source: this.buffer.readUInt8(34 + n),
+        status: this.buffer.readUInt8(42 + n),
+        trackID: this.buffer.readUInt32LE(50 + n * 4),
+        name: this.buffer.slice(172 + n * 16, 172 + (n + 1) * 16).toString("ascii").replace(/\0.*$/g, "")
+      };
+    }
+  }
+  write() {
+    throw new Error("not supported!");
+  }
+  length() {
+    return 300;
+  }
+  type() {
+    return 5 /* Status */;
+  }
+};
+var TCNetRequestPacket = class extends TCNetPacket {
+  dataType;
+  layer;
+  read() {
+    this.dataType = this.buffer.readUInt8(24);
+    this.layer = this.buffer.readUInt8(25);
+  }
+  write() {
+    assert(0 <= this.dataType && this.dataType <= 255);
+    assert(0 <= this.layer && this.layer <= 255);
+    this.buffer.writeUInt8(this.dataType, 24);
+    this.buffer.writeUInt8(this.layer, 25);
+  }
+  length() {
+    return 26;
+  }
+  type() {
+    return 20 /* Request */;
+  }
+};
+var TCNetTimecodeState = /* @__PURE__ */ ((TCNetTimecodeState2) => {
+  TCNetTimecodeState2[TCNetTimecodeState2["Stopped"] = 0] = "Stopped";
+  TCNetTimecodeState2[TCNetTimecodeState2["Running"] = 1] = "Running";
+  TCNetTimecodeState2[TCNetTimecodeState2["ForceReSync"] = 2] = "ForceReSync";
+  return TCNetTimecodeState2;
+})(TCNetTimecodeState || {});
+var TCNetTimecode = class {
+  mode;
+  state;
+  hours;
+  minutes;
+  seconds;
+  frames;
+  read(buffer, offset) {
+    this.mode = buffer.readUInt8(offset + 0);
+    this.state = buffer.readUInt8(offset + 1);
+    this.hours = buffer.readUInt8(offset + 2);
+    this.minutes = buffer.readUInt8(offset + 3);
+    this.seconds = buffer.readUInt8(offset + 4);
+    this.frames = buffer.readUInt8(offset + 5);
+  }
+};
+var TCNetTimePacket = class extends TCNetPacket {
+  _layers = new Array(8);
+  _generalSMPTEMode = 0;
+  read() {
+    for (let n = 0; n < 8; n++) {
+      this._layers[n] = {
+        currentTimeMillis: this.buffer.readUInt32LE(24 + n * 4),
+        totalTimeMillis: this.buffer.readUInt32LE(56 + n * 4),
+        beatMarker: this.buffer.readUInt8(88 + n),
+        state: this.buffer.readUInt8(96 + n),
+        onAir: this.buffer.length > 154 ? this.buffer.readUInt8(154 + n) : 255
+      };
+    }
+    this._generalSMPTEMode = this.buffer.readUInt8(105);
+  }
+  write() {
+    throw new Error("not supported!");
+  }
+  length() {
+    switch (this.buffer.length) {
+      case 154:
+      case 162:
+        return this.buffer.length;
+      default:
+        return -1;
+    }
+  }
+  type() {
+    return 254 /* Time */;
+  }
+  get layers() {
+    return this._layers;
+  }
+  get generalSMPTEMode() {
+    return this._generalSMPTEMode;
+  }
+};
+var TCNetDataPacket = class extends TCNetPacket {
+  dataType;
+  /**
+   * 0-indexed layer ID (0-7)
+   */
+  layer;
+  read() {
+    this.dataType = this.buffer.readUInt8(24);
+    this.layer = this.buffer.readUInt8(25) - 1;
+  }
+  write() {
+    assert(0 <= this.dataType && this.dataType <= 255);
+    assert(0 <= this.layer && this.layer <= 255);
+    this.buffer.writeUInt8(this.dataType, 24);
+    this.buffer.writeUInt8(this.layer, 25);
+  }
+  length() {
+    return -1;
+  }
+  type() {
+    return 200 /* Data */;
+  }
+};
+var TCNetLayerSyncMaster = /* @__PURE__ */ ((TCNetLayerSyncMaster2) => {
+  TCNetLayerSyncMaster2[TCNetLayerSyncMaster2["Slave"] = 0] = "Slave";
+  TCNetLayerSyncMaster2[TCNetLayerSyncMaster2["Master"] = 1] = "Master";
+  return TCNetLayerSyncMaster2;
+})(TCNetLayerSyncMaster || {});
+var TCNetDataPacketMetrics = class extends TCNetDataPacket {
+  data = null;
+  read() {
+    this.data = {
+      state: this.buffer.readUInt8(27),
+      syncMaster: this.buffer.readUInt8(29),
+      beatMarker: this.buffer.readUInt8(31),
+      trackLength: this.buffer.readUInt32LE(32),
+      currentPosition: this.buffer.readUInt32LE(36),
+      speed: this.buffer.readUInt32LE(40),
+      beatNumber: this.buffer.readUInt32LE(57),
+      bpm: this.buffer.readUInt32LE(112),
+      pitchBend: this.buffer.readInt16LE(116),
+      trackID: this.buffer.readUInt32LE(118)
+    };
+  }
+  write() {
+    throw new Error("not supported!");
+  }
+  length() {
+    return 122;
+  }
+};
+var TCNetDataPacketMetadata = class extends TCNetDataPacket {
+  info = null;
+  read() {
+    if (this.header.minorVersion < 5) {
+      throw new Error("Unsupported packet version");
+    }
+    this.info = {
+      trackArtist: this.buffer.slice(29, 285).toString("utf16le").replace(/\0/g, ""),
+      trackTitle: this.buffer.slice(285, 541).toString("utf16le").replace(/\0/g, ""),
+      trackKey: this.buffer.readUInt16LE(541),
+      trackID: this.buffer.readUInt32LE(543)
+    };
+  }
+  write() {
+    throw new Error("not supported!");
+  }
+  length() {
+    return 548;
+  }
+};
+var TCNetPackets = {
+  [2 /* OptIn */]: TCNetOptInPacket,
+  [3 /* OptOut */]: TCNetOptOutPacket,
+  [5 /* Status */]: TCNetStatusPacket,
+  [10 /* TimeSync */]: null,
+  // not yet implemented
+  [13 /* Error */]: null,
+  // not yet implemented
+  [20 /* Request */]: TCNetRequestPacket,
+  [30 /* ApplicationData */]: null,
+  // not yet implemented
+  [101 /* Control */]: null,
+  // not yet implemented
+  [128 /* Text */]: null,
+  // not yet implemented
+  [132 /* Keyboard */]: null,
+  // not yet implemented
+  [200 /* Data */]: TCNetDataPacket,
+  [204 /* File */]: null,
+  // not yet implemented
+  [254 /* Time */]: TCNetTimePacket
+};
+var TCNetDataPackets = {
+  [2 /* MetricsData */]: TCNetDataPacketMetrics,
+  [4 /* MetaData */]: TCNetDataPacketMetadata,
+  [8 /* BeatGridData */]: null,
+  // not yet implemented
+  [12 /* CUEData */]: null,
+  // not yet implemented
+  [16 /* SmallWaveFormData */]: null,
+  // not yet implemented
+  [32 /* BigWaveFormData */]: null,
+  // not yet implemented
+  [150 /* MixerData */]: null
+  // not yet implemented
+};
+
+// src/tcnet.ts
+var EventEmitter = __require("events");
+var TCNET_BROADCAST_PORT = 6e4;
+var TCNET_TIMESTAMP_PORT = 60001;
+var TCNetConfiguration = class {
+  logger = null;
+  unicastPort = 65023;
+  applicationCode = 65535;
+  nodeId = Math.floor(Math.random() * 65535);
+  nodeName = "TCNET.JS";
+  vendorName = "CHDXD1";
+  appName = "NODE-TCNET";
+  broadcastInterface = null;
+  broadcastAddress = "255.255.255.255";
+  broadcastListeningAddress = "";
+  requestTimeout = 2e3;
+};
+var closeSocket = (socket) => new Promise((resolve) => socket.close(() => resolve()));
+var TCNetClient = class extends EventEmitter {
+  config;
+  broadcastSocket;
+  unicastSocket;
+  timestampSocket;
+  server;
+  seq = 0;
+  uptime = 0;
+  connected = false;
+  connectedHandler = null;
+  requests = /* @__PURE__ */ new Map();
+  announcementInterval;
+  /**
+   *
+   * @param config configuration for TCNet access
+   */
+  constructor(config) {
+    super();
+    this.config = config || new TCNetConfiguration();
+    if (this.config.broadcastInterface && this.config.broadcastAddress == "255.255.255.255") {
+      this.config.broadcastAddress = interfaceAddress(this.config.broadcastInterface);
+    }
+    this.config.broadcastListeningAddress ||= "0.0.0.0";
+  }
+  get log() {
+    return this.config.logger;
+  }
+  /**
+   * Wrapper method to bind a socket with a Promise
+   * @param socket socket to bind
+   * @param port port to bind to
+   * @param address address to bind to
+   * @returns Promise which always resolves (no errors in callback)
+   */
+  bindSocket(socket, port, address) {
+    return new Promise((resolve, reject) => {
+      socket.once("error", reject);
+      socket.bind(port, address, () => {
+        socket.removeListener("error", reject);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Connect to the TCNet networks
+   */
+  async connect() {
+    this.broadcastSocket = createSocket({ type: "udp4", reuseAddr: true }, this.receiveBroadcast.bind(this));
+    await this.bindSocket(this.broadcastSocket, TCNET_BROADCAST_PORT, this.config.broadcastListeningAddress);
+    this.broadcastSocket.setBroadcast(true);
+    this.timestampSocket = createSocket({ type: "udp4", reuseAddr: true }, this.receiveTimestamp.bind(this));
+    await this.bindSocket(this.timestampSocket, TCNET_TIMESTAMP_PORT, this.config.broadcastListeningAddress);
+    this.timestampSocket.setBroadcast(true);
+    this.unicastSocket = createSocket({ type: "udp4", reuseAddr: false }, this.receiveUnicast.bind(this));
+    await this.bindSocket(this.unicastSocket, this.config.unicastPort, "0.0.0.0");
+    await this.announceApp();
+    this.announcementInterval = setInterval(this.announceApp.bind(this), 1e3);
+    await this.waitConnected();
+  }
+  /**
+   * Disconnects from TCNet network
+   */
+  disconnect() {
+    clearInterval(this.announcementInterval);
+    this.removeAllListeners();
+    this.connected = false;
+    return Promise.all([
+      closeSocket(this.broadcastSocket),
+      closeSocket(this.unicastSocket),
+      closeSocket(this.timestampSocket)
+    ]).catch((err) => {
+      const error = new Error("Error disconnecting from TCNet");
+      error.cause = err instanceof Error ? err : new Error(String(err));
+      this.log?.error(error);
+    }).then(() => void 0);
+  }
+  /**
+   * Waiting for unicast from a master
+   */
+  waitConnected() {
+    return new Promise((resolve, reject) => {
+      this.connectedHandler = resolve;
+      setTimeout(() => {
+        if (!this.connected) {
+          this.disconnect();
+          reject(new Error("Timeout connecting to network"));
+        }
+      }, this.config.requestTimeout);
+    });
+  }
+  /**
+   * Parse a packet from a ManagementHeader
+   * @param header the received management header
+   * @returns the parsed packet
+   */
+  parsePacket(header) {
+    const packetClass = TCNetPackets[header.messageType];
+    if (packetClass !== null) {
+      const packet = new packetClass();
+      packet.buffer = header.buffer;
+      packet.header = header;
+      if (packet.length() !== -1 && packet.length() !== header.buffer.length) {
+        this.log?.debug(
+          `${TCNetMessageType[header.messageType]} packet has the wrong length (expected: ${packet.length()}, received: ${header.buffer.length})`
+        );
+        return null;
+      }
+      packet.read();
+      return packet;
+    } else {
+      this.log?.debug(`Unknown packet type: ${header.messageType} ${TCNetMessageType[header.messageType]}`);
+    }
+    return null;
+  }
+  /**
+   * Callback method to receive datagrams on the broadcast socket
+   *
+   * @param msg datagram buffer
+   * @param rinfo remoteinfo
+   */
+  receiveBroadcast(msg, rinfo) {
+    const mgmtHeader = new TCNetManagementHeader(msg);
+    mgmtHeader.read();
+    const packet = this.parsePacket(mgmtHeader);
+    if (packet) {
+      if (packet instanceof TCNetOptInPacket) {
+        if (mgmtHeader.nodeType == 2 /* Master */) {
+          this.server = rinfo;
+          this.server.port = packet.nodeListenerPort;
+          if (this.connectedHandler) {
+            this.connected = true;
+            this.announceApp().catch((err) => {
+              const error = err instanceof Error ? err : new Error(String(err));
+              this.log?.debug(`Failed to announce on connect: ${error.message}`);
+            });
+            this.connectedHandler();
+            this.connectedHandler = null;
+          }
+        }
+      }
+      if (packet instanceof TCNetOptOutPacket) {
+        if (mgmtHeader.nodeType == 2 /* Master */) {
+          this.log?.debug("Received optout from current Master");
+          if (this.server?.address == rinfo.address && this.server?.port == packet.nodeListenerPort) {
+            this.server = null;
+          }
+        }
+      }
+      if (this.connected) {
+        this.emit("broadcast", packet);
+      }
+    } else {
+      this.log?.debug(`Unknown broadcast packet type: ${mgmtHeader.messageType}`);
+    }
+  }
+  /**
+   * Callback method to receive datagrams on the unicast socket
+   *
+   * @param msg datagram buffer
+   * @param rinfo remoteinfo
+   */
+  receiveUnicast(msg, rinfo) {
+    const mgmtHeader = new TCNetManagementHeader(msg);
+    mgmtHeader.read();
+    const packet = this.parsePacket(mgmtHeader);
+    if (packet instanceof TCNetDataPacket) {
+      const dataPacketClass = TCNetDataPackets[packet.dataType];
+      if (dataPacketClass !== null) {
+        const dataPacket = new dataPacketClass();
+        dataPacket.buffer = msg;
+        dataPacket.header = mgmtHeader;
+        dataPacket.dataType = packet.dataType;
+        dataPacket.layer = packet.layer;
+        dataPacket.read();
+        if (this.connected) {
+          this.emit("data", dataPacket);
+        }
+        const key = `${dataPacket.dataType}-${dataPacket.layer}`;
+        const pendingRequest = this.requests.get(key);
+        if (pendingRequest) {
+          this.requests.delete(key);
+          clearTimeout(pendingRequest.timeout);
+          pendingRequest.resolve(dataPacket);
+        }
+      }
+    } else if (packet instanceof TCNetOptInPacket) {
+      if (mgmtHeader.nodeType == 2 /* Master */) {
+        this.server = rinfo;
+        this.server.port = packet.nodeListenerPort;
+        if (this.connectedHandler) {
+          this.connected = true;
+          this.connectedHandler();
+          this.connectedHandler = null;
+        }
+      }
+    } else {
+      if (this.connected) {
+        this.emit("broadcast", packet);
+      }
+    }
+  }
+  /**
+   * Callback method to receive datagrams on the timestamp socket
+   * @param msg datagram buffer
+   * @param rinfo remoteinfo
+   */
+  receiveTimestamp(msg, _rinfo) {
+    const mgmtHeader = new TCNetManagementHeader(msg);
+    mgmtHeader.read();
+    if (mgmtHeader.messageType !== 254 /* Time */) {
+      this.log?.debug("Received non Time packet on Time port");
+      return;
+    }
+    const packet = this.parsePacket(mgmtHeader);
+    this.emit("time", packet);
+  }
+  /**
+   * Fill headers of a packet
+   *
+   * @param packet Packet that needs header information
+   */
+  fillHeader(packet) {
+    packet.header = new TCNetManagementHeader(packet.buffer);
+    packet.header.minorVersion = 5;
+    packet.header.nodeId = this.config.nodeId;
+    packet.header.messageType = packet.type();
+    packet.header.nodeName = this.config.nodeName;
+    packet.header.seq = this.seq = (this.seq + 1) % 255;
+    packet.header.nodeType = 4;
+    packet.header.nodeOptions = 0;
+    packet.header.timestamp = 0;
+  }
+  /**
+   * Generalized method to send packets to a given destination on a given socket
+   *
+   * @param packet Packet to send
+   * @param socket Socket to send on
+   * @param port Destination Port
+   * @param address Destination Address
+   */
+  sendPacket(packet, socket, port, address) {
+    return new Promise((resolve, reject) => {
+      const buffer = Buffer.alloc(packet.length());
+      packet.buffer = buffer;
+      this.fillHeader(packet);
+      packet.header.write();
+      packet.write();
+      socket.send(buffer, port, address, (err) => {
+        if (err) reject(err);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Sends a packet to the discovered server
+   * @param packet Packet to send
+   */
+  async sendServer(packet) {
+    if (this.server === null) {
+      throw new Error("Server not yet discovered");
+    }
+    await this.sendPacket(packet, this.broadcastSocket, this.server.port, this.server.address);
+  }
+  /**
+   * Called every second to announce our app on the network
+   */
+  async announceApp() {
+    const optInPacket = new TCNetOptInPacket();
+    optInPacket.nodeCount = 0;
+    optInPacket.nodeListenerPort = this.config.unicastPort;
+    optInPacket.uptime = this.uptime++;
+    if (this.uptime >= 12 * 60 * 60) {
+      this.uptime = 0;
+    }
+    optInPacket.vendorName = this.config.vendorName;
+    optInPacket.appName = this.config.appName;
+    optInPacket.majorVersion = 1;
+    optInPacket.minorVersion = 1;
+    optInPacket.bugVersion = 1;
+    await this.broadcastPacket(optInPacket);
+    if (this.server) {
+      await this.sendServer(optInPacket);
+    }
+  }
+  /**
+   * Broadcasts a packet to the network
+   *
+   * @param packet packet to broadcast
+   */
+  async broadcastPacket(packet) {
+    await this.sendPacket(packet, this.broadcastSocket, TCNET_BROADCAST_PORT, this.config.broadcastAddress);
+  }
+  /**
+   * Sends a request packet to the discovered server
+   *
+   * @param dataType requested data type
+   * @param layer requested layer
+   * @returns Promise to wait for answer on request
+   */
+  requestData(dataType, layer) {
+    return new Promise((resolve, reject) => {
+      if (!Number.isInteger(layer) || layer < 0 || layer > 7) {
+        reject(new RangeError("layer must be an integer between 0 and 7"));
+        return;
+      }
+      const request = new TCNetRequestPacket();
+      request.dataType = dataType;
+      request.layer = layer + 1;
+      const key = `${dataType}-${layer}`;
+      const timeout = setTimeout(() => {
+        if (this.requests.delete(key)) {
+          reject(new Error("Timeout while requesting data"));
+        }
+      }, this.config.requestTimeout);
+      this.requests.set(key, { resolve, timeout });
+      this.sendServer(request).catch((err) => {
+        if (this.requests.delete(key)) {
+          clearTimeout(timeout);
+          reject(err);
+        }
+      });
+    });
+  }
+};
+export {
+  NodeType,
+  TCNetClient,
+  TCNetConfiguration,
+  TCNetDataPacket,
+  TCNetDataPacketMetadata,
+  TCNetDataPacketMetrics,
+  TCNetDataPacketType,
+  TCNetDataPackets,
+  TCNetLayerStatus,
+  TCNetLayerSyncMaster,
+  TCNetManagementHeader,
+  TCNetMessageType,
+  TCNetOptInPacket,
+  TCNetOptOutPacket,
+  TCNetPacket,
+  TCNetPackets,
+  TCNetRequestPacket,
+  TCNetStatusPacket,
+  TCNetTimePacket,
+  TCNetTimecode,
+  TCNetTimecodeState
+};