         (swap! addrs #(assoc-in % [(:client-addr stream) :outs
                                    [(:accept-addr stream) (:accept-port stream)]
                                    [(:client-port stream)
-                                    (:server-addr stream) (:server-port stream)]] (:msgs stream)))
+                                    (:server-addr stream) (:server-port stream)]]
+                                (:msgs stream)))
         (swap! addrs #(assoc-in % [(:server-addr stream) :outs
                                    [(:accept-addr stream) (:accept-port stream)]
                                    [(:server-port stream)
-                                    (:client-addr stream) (:client-port stream)]] (:msgs stream)))))
+                                    (:client-addr stream) (:client-port stream)]]
+                                (:msgs stream)))))
     (let [naddrs (count @addrs) ; Assign coords.
           conns (sort (mapcat (fn [[addr addr-v]]
-                                (mapcat (fn [[[accept-addr accept-port] accept-addr-port-v]]
+                                (mapcat (fn [[[accept-addr accept-port]
+                                              accept-addr-port-v]]
                                           (map (fn [[[from-port to-addr to-port] msgs]]
                                                  [(not= addr accept-addr)
-                                                  addr accept-addr accept-port from-port])
+                                                  addr accept-addr accept-port
+                                                  from-port])
                                                accept-addr-port-v))
                                         (:outs addr-v)))
                               @addrs))]
       (doall (map-indexed (fn [addr-idx [addr addr-v]]
-                            (swap! coords #(assoc % addr
-                                                  [addr-idx (rem (* (dec naddrs) addr-idx) naddrs)])))
+                            (swap! coords
+                                   #(assoc % addr
+                                           [addr-idx (rem (* (dec naddrs) addr-idx)
+                                                          naddrs)])))
               (sort-by first @addrs)))
       (reduce (fn [prev [is-client addr accept-addr accept-port port]]
                 (let [idx (if (= (first prev) addr) (second prev) 0)]

(defn world-vis-init [el-prefix init-event-delay]
  (let [cmd-inject-ch (chan)
        cmd-ch (replay-cmd-ch cmd-inject-ch (keys cbfg.world.lane/cmd-handlers)
                              (fn [ev] {:op (.-id (.-target ev))
                                        :x (js/parseInt (get-el-value "x"))
                                        :y (js/parseInt (get-el-value "y"))
                                        :delay (js/parseInt (get-el-value "delay"))
                                        :fence (= (get-el-value "fence") "1")
                                        :lane (get-el-value "lane")
                                        :client (get-el-value "client")
                                        :color (get-el-value "color")
                                        :sleep (js/parseInt (get-el-value "sleep"))}))
        render-state (atom {})
        num-clients 3]
    (vis-init (fn [world vis-chs]

    cmd-ch))

(defn render-msg [msg class-extra style-extra]
  ["<div class='msg " class-extra
   "' style='color:" (:color msg) "; " style-extra "'>&#9679;"
   "<div class='result'>" (:result msg) "</div></div>"])

(defn render-msgs [curr-msgs prev-msgs dist line-height]
