   (fn [[groups group-order] _]
     (order-groups groups group-order)))
 
-(reg-sub-raw
+(reg-sub
   :group-bots
   (fn [state _ [group-id]]
-    (reaction (get-in @state [:groups group-id :bots]))))
-
-(reg-sub-raw
+    (get-in state [:groups group-id :bots])))
+
+(reg-sub
   :user
   (fn [state [_ q-user-id] [d-user-id]]
     (let [user-id (or d-user-id q-user-id)]
-      (reaction (if-let [u (get-in @state [:users user-id])]
-                  u
-                  (let [g-id (@state :open-group-id)
-                        group-bots (get-in @state [:groups g-id :bots])]
-                    (-> group-bots
-                        (->> (filter (fn [b] (= (b :user-id) user-id))))
-                        first
-                        (assoc :bot? true))))))))
-
-(reg-sub-raw
+      (if-let [u (get-in state [:users user-id])]
+        u
+        (let [g-id (state :open-group-id)
+              group-bots (get-in state [:groups g-id :bots])]
+          (-> group-bots
+              (->> (filter (fn [b] (= (b :user-id) user-id))))
+              first
+              (assoc :bot? true)))))))
+
+(reg-sub
   :users
   (fn [state _]
-    (reaction (@state :users))))
-
-(reg-sub-raw
+    (state :users)))
+
+(reg-sub
   :user-is-group-admin?
   (fn [state _ [user-id group-id]]
-    (reaction (contains? (get-in @state [:groups group-id :admins]) user-id))))
-
-(reg-sub-raw
+    (contains? (get-in state [:groups group-id :admins]) user-id)))
+
+(reg-sub
   :current-user-is-group-admin?
   (fn [state _ [group-id]]
-    (reaction (->> (get-in @state [:session :user-id])
-                   (contains? (set (get-in @state [:groups group-id :admins])))))))
-
-(reg-sub-raw
+    (->> (get-in state [:session :user-id])
+         (contains? (set (get-in state [:groups group-id :admins]))))))
+
+(reg-sub
   :open-thread-ids
   (fn [state _]
-    (reaction (get-in @state [:user :open-thread-ids]))))
+    (get-in state [:user :open-thread-ids])))
 
 (reg-sub-raw
   :group-unread-count

                             (filter thread-unseen?)))]
      (reaction (count @unseen-threads)))))

(reg-sub-raw
  :page
  (fn [state _]
    (reaction (@state :page))))

(reg-sub
  :page-path

    ; depend on page & group, so when the page changes this sub updates too
    (.getPath (.parse Uri js/window.location))))

(reg-sub
  :thread
  (fn [state _ [thread-id]]
    (get-in state [:threads thread-id])))

(reg-sub
  :threads
  (fn [state _]
    (state :threads)))

(reg-sub
  :page-id
  (fn [state _]
    (get-in state [:page :id])))

(reg-sub-raw
  :open-threads
