                                   results)))
                      (if (seq (filter #(= ch (first %)) results))
                        (do (aclose net ch) ; Handle a completed result-ch aput.
-                           (recur (inc ts)
-                                  listens
-                                  streams
+                           (recur (inc ts) listens streams
                                   (remove #(= (first %) ch) results)))
                        (println "UNKNOWN ch"
                                 listens :streams streams :results results)))))))))

                         server-recv-ch (achan-buf net end-point-buf-size)
                         close-server-recv-ch (achan net)]
                     ; TODO: Need to model running out of ports.
                     (recur (inc ts)
                            listens
                            (-> streams
                                (assoc client-send-ch {:send-ch client-send-ch
                                                       :recv-ch server-recv-ch

                     stream (get streams send-ch)
                     [msg result-ch] v]
                 (if v
                   (recur (inc ts) listens
                          (if (:recv-ch stream)
                            (update-in streams [send-ch :msgs]
                                       conj [(+ ts (get opts :delivery-delay 0)) msg])
                            streams)
                          (add-result results result-ch :ok))
                   (recur (inc ts) listens
                          (if (:recv-ch stream)
                            (assoc-in streams [send-ch :send-closed] true)
                            (dissoc streams send-ch))
                          (add-result results result-ch :ok))))
               :else ; Test if it's a completed deliverable (recv-ch aput'ed).
               (if-let [stream (first (filter #(= (:recv-ch %) ch) (vals streams)))]
                 (let [stream2 (update-in stream [:msgs] rest)]
                   (if (and (:send-closed stream2)
                            (empty? (:msgs stream2)))
                     (do (aclose net (:recv-ch stream2))
                         (recur (inc ts) listens
                                (dissoc streams (:send-ch stream2))
                                results))
                     (recur (inc ts) listens
                            (assoc streams (:send-ch stream2) stream2)
                            results)))
                 (if-let [stream (first (filter #(= (:close-recv-ch %) ch) (vals streams)))]
