docs: function createTransportServerType() {
      log.info("create transport server type");
      // [ -Events- ]
      // message - a message with transport client source
      // client closed - emitted when a client is closed, with the client
      // close - emitted when the transport is closed
      // error - emitted when the underlying ws has an error
      // listening - emitted when the server is listening
      // [ -Constructor- ]
      function TransportServer() {
          log.info("instantiate transport server");
          // get non-ambiguous this
          var self = this;
          // Call parent constructor
          TransportServer.super_.call(self);
          // Internal structures
          self._ws = undefined;
          self._id = _.uniqueId();
          self._closed = false;
          // state listeners
          self.once('close', function handleClosed() {
              self._closed = true;
          });
          // constructor. return undefined
          return undefined;
      }
      // [ -Inheritance- ]
      util.inherits(TransportServer, events.EventEmitter);
      // [ -Private API- ]
      TransportServer.prototype._handleConnection = function transportServerHandleConnection(wsc) {
          log.info("Transport server handle connection");
          // create a source with send/close
          var source = new ActualTransportClient();
          source.wrap(wsc);
          // proxy events
          source.on('message', this.emit.bind(this, 'message', source));
          source.on('close', this.emit.bind(this, 'client closed', source));
          // Higher layers don't currently need any insight.  If a source
          // has an error, just close it.
          source.on('error', function handleError() {
              source.close();
          });
          // allow chaining
          return this;
      };
      // [ -Public API- ]
      // listen for remote websocket connections
      TransportServer.prototype.listen = function websocketListen(options, cb) {
          log.info("websocket server listen");
          // only allow this to be called once on the object
          if (this._ws) {
              // throw immediately - this is programmer error
              throw new VError("'listen' has already been called on this transport object.");
          }
          // add cb to listeners
          if (cb) {
              this.on('listening', cb);
          }
          // set up websocket server
          this._ws = new ws.Server(options);
          // proxy some events
          // FIXME - be intentional about what errors are passed up
          // at each stage
          this._ws.on('listening', this.emit.bind(this, 'listening'));
          this._ws.on('error', this.emit.bind(this, 'error'));
          this._ws._server.on('close', this.emit.bind(this, 'close'));
          // handle connections from clients
          this._ws.on('connection', this._handleConnection.bind(this));
          // it doesn't make sense to do anything with the object until listen
          // calls back, so return null
          return null;
      };
      // close connection(s)
      TransportServer.prototype.close = function websocketClose() {
          log.info("websocket close");
          if (this._closed) {
              throw new VError("Transport Server has already been closed");
          }
          this._ws.close();
          // it doesn't make sense to do anything with the object
          // after close, so return null
          return null;
      };
      return TransportServer;
  }