   :done)
 
 (defn make-net [actx request-listen-ch request-connect-ch & opts]
-  (ago-loop net actx
+  (ago-loop net actx     ; A conn is represented by dual streams.
             [ts 0        ; A increasing event / time stamp counter.
              listens {}  ; Keyed by [addr port], value is [close-accept-ch accept-ch].
-             streams {}  ; A conn is represented by dual streams, where streams
-                         ; is keyed by send-ch and a value of...
+             streams {}  ; Keyed by send-ch and a value is...
                          ; {:send-addr :send-port :send-ch
                          ;  :recv-addr :recv-port :recv-ch
-                         ;  :side (:client|:server)
-                         ;  :server-addr :server-port
+                         ;  :side (:client|:server) :server-addr :server-port
                          ;  :msgs [[deliver-at msg] ...]}.
              results []] ; A result entry is [result-ch msg].
             (let [close-accept-chs (map first (vals listens))

                            streams
                            (conj results [result-ch accept-chs]))))
                 (net-clean-up net listens streams results))
               (= ch request-connect-ch)
               (if-let [[to-addr to-port from-addr result-ch] v]
                 ; TODO: Need to model connection delay, perhaps with a generic "later".
                 (if-let [[close-accept-ch accept-ch] (get listens [to-addr to-port])]

                                           (when-let [close-recv-ch (:close-recv-ch stream)]
                                             [close-recv-ch]))
                                         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))
