Add a note to handle client socket stream errors.

io/src/main/scala/fs2/io/net/SocketGroup.scala

@@ -59,6 +59,7 @@ trait SocketGroup[F[_]] {
     * client sockets -- one per client that connects to the bound address/port.
     *
     * When the stream terminates, all open connections will terminate as well.
+    * Because of this, make sure to handle errors in the client socket Streams.
     *
     * @param address            address to accept connections from; none for all interfaces
     * @param port               port to bind
@@ -71,6 +72,8 @@ trait SocketGroup[F[_]] {
   ): Stream[F, Socket[F]]
 
   /** Like [[server]] but provides the `SocketAddress` of the bound server socket before providing accepted sockets.
+    *
+    * Make sure to handle errors in the client socket Streams.
     */
   def serverResource(
       address: Option[Host] = None,

site/io.md

@@ -142,6 +142,7 @@ def echoServer[F[_]: Concurrent: Network]: F[Unit] =
       .interleave(Stream.constant("\n"))
       .through(text.utf8Encode)
       .through(client.writes)
+      .handleErrorWith(_ => Stream.empty) // handle errors of client sockets
   }.parJoin(100).compile.drain
 ```
 
@@ -152,6 +153,8 @@ we read from the client socket, UTF-8 decode the received bytes, extract individ
 
 Since we mapped over the infinite client stream, we end up with a `Stream[F, Stream[F, Unit]]`. We flatten this to a single `Stream[F, Unit]` via `parJoin(100)`, which runs up to 100 of the inner streams concurrently. As inner streams finish, new inner streams are pulled from the source. Hence, `parJoin` is controlling the maximum number of concurrent client requests our server processes.
 
+In joining all these streams together, be prudent to handle errors in the client streams.
+
 The pattern of `Network[F].server(address).map(handleClient).parJoin(maxConcurrentClients)` is very common when working with server sockets.
 
 A simpler echo server could be implemented with this core logic: