                                            (when-let [close-recv-ch (:close-recv-ch stream)]
                                              [close-recv-ch]))
                                          streams)
-                  deliverables (mapcat (fn [[send-ch stream]]
-                                         (when-let [[deliver-at msg] (first (:msgs stream))]
-                                           (when (and (:recv-ch stream)
-                                                      (>= ts deliver-at))
-                                             [[(:recv-ch stream) msg]])))
-                                       streams)
+                  deliverable-msgs (mapcat (fn [[send-ch stream]]
+                                             (when-let [[deliver-at msg] (first (:msgs stream))]
+                                               (when (and (:recv-ch stream)
+                                                          (>= ts deliver-at))
+                                                 [[(:recv-ch stream) msg]])))
+                                           streams)
                   send-chs (mapcat (fn [[send-ch stream]]
                                      (when (and (not (:send-closed stream))
                                                 (< (count (:msgs stream))

                  chs (-> [request-listen-ch request-connect-ch]
                          (into close-accept-chs)
                          (into close-recv-chs)
                          (into deliverables)
                          (into send-chs)
                          (into results))
                  [v ch] (aalts net chs)]
              (cond
               (= ch request-listen-ch)
               (if-let [[addr port result-ch] v]
                 (if (get listens [addr port])
                   (do (aclose net result-ch)

                                results)))
                   (if-let [[addr-port [close-accept-ch accept-ch]]
                            (first (filter #(= ch (first (second %))) (seq listens)))]
                     (if v ; Or, test if it's a closed close-accept-ch.
                       (recur (inc ts) listens streams results)
                       (do (aclose net accept-ch)
                           (recur (inc ts)
                                  (dissoc listens addr-port)
                                  streams
                                  results)))
                     (do (aclose net ch) ; Or, handle a completed result-ch aput.
                         (recur (inc ts) listens streams
                                (remove #(= (first %) ch) results))))))))))
