 @_exported import HTTPSerializer
 
 public struct Server {
-    public let server: C7.StreamServer
+    public let server: C7.Host
     public let parser: S4.RequestParser
     public let middleware: [S4.Middleware]
     public let responder: S4.Responder
     public let serializer: S4.ResponseSerializer
     public let port: Int
 
-    public init(address: String? = nil, port: Int = 8080, certificate: String, privateKey: String, certificateChain: String? = nil, parser: S4.RequestParser = RequestParser(), middleware: Middleware..., responder: S4.Responder, serializer: S4.ResponseSerializer = ResponseSerializer()) throws {
-        self.server = try TCPSSLStreamServer(
-            address: address,
-            port: port,
+    public init(at host: String = "0.0.0.0", on port: Int = 8080, certificate: String, privateKey: String, certificateChain: String? = nil, reusingPort reusePort: Bool = false, parser: S4.RequestParser = RequestParser(), middleware: Middleware..., responder: S4.Responder, serializer: S4.ResponseSerializer = ResponseSerializer()) throws {
+        self.server = try TCPSSLServer(
+            at: host,
+            on: port,
+            reusingPort: reusePort,
             certificate: certificate,
             privateKey: privateKey,
             certificateChain: certificateChain

    private func processStream(stream: Stream) throws {
        while !stream.closed {
            do {
                let data = try stream.receive()
                if let request = try parser.parse(data) {
                    let response = try middleware.intercept(responder).respond(request)
                    try serialize(response, stream: stream)

                    if let upgrade = response.upgrade {
                        try upgrade(request, stream)
                        stream.close()
                    }

                    if !request.isKeepAlive {
                        stream.close()
                        break
                    }
                }
            } catch StreamError.closedStream {
                break
            } catch {
                let response = Response(status: .internalServerError)
                try serialize(response, stream: stream)
                throw error
            }
        }
    }

    private func serialize(response: Response, stream: Stream) throws {
        try serializer.serialize(response) { data in
            try stream.send(data)
        }

        try stream.flush()
    }

    public func startInBackground(failure: ErrorProtocol -> Void = Server.printError) {

        self.port = port
    }

    public init(at host: String = "0.0.0.0", on port: Int = 8080, certificate: String, privateKey: String, certificateChain: String? = nil, reusingPort reusePort: Bool = false, parser: S4.RequestParser = RequestParser(), middleware: Middleware..., serializer: S4.ResponseSerializer = ResponseSerializer(), _ respond: Respond) throws {
        self.server = try TCPSSLServer(
            at: host,
            on: port,
            reusingPort: reusePort,
            certificate: certificate,
            privateKey: privateKey,
            certificateChain: certificateChain
