                              many? (conj id))
                        xch (chan 1 (delta/nest ks'))]
                    (service/request compscribe-service
-                                    [(get direct-hooks ks) id]
+                                    [(get-in spec-map ks) id]
                                     xch)
                    (vswap! subs assoc ks' xch)
                    ;; xch will be closed by the subscribed-composition
-                   (mix-in target-mix xch)))
-        ch-in (chan)]
-    (service/request source-service [endpoint id] ch-in)
+                   (mix-in target-mix xch)))]
     (go-loop []
       (if-some [delta (<! ch-in)]
-        (let [[{:keys [subs-one subs-many unsubs]} delta]
-              (extract-hooks conformed-spec delta)
-
-              subs-by-pks (group-by-pks @subs)]
-          (doseq [[ks xch]
-                  (->> unsubs
-                       (mapcat (fn [ks]
-                                 (concat (->> (get subs-by-pks ks)
-                                              (map rest))
-                                         (some-> (find @subs ks)
-                                                 (vector)))))
-                       distinct)]
+        (let [[{:keys [subs-one subs-many unsubs]} delta :as dbg]
+              (extract-hooks spec-map delta)]
+          (doseq [[ks xch] (filter (fn [[ks v]]
+                                     (some (fn [uks]
+                                             (= uks (take (count uks) ks)))
+                                           unsubs))
+                                   @subs)]
             (service/cancel compscribe-service xch)
             (mix-out target-mix xch)
             (vswap! subs dissoc ks))

            (close! target)))))
    m))

(defn- compscribe*
  [outer-target source-service compscribe-service
   [endpoint direct-hooks deep-hooks :as conformed-spec] id]
  (let [;; Once intercepted, events need to go through target-mix so
        ;; that mix-ins and mix-outs have synchronous effects
        target (chan)

      service/IService
      (request [this spec target]
        (let [[spec id] spec
              [endpoint spec-map] spec
              subs-target (on-close-source target
                                           #(service/cancel this target))]
          (if (empty? spec-map)
            ;; OPT: If there is nothing to compscribe, directly reach
            ;; through to the source-service:
            (do
              (service/request source-service [endpoint id] subs-target)
              (swap! subscriptions assoc target subs-target))
            (let [ch-in (chan)]
              (compscribe* subs-target
                           ch-in
                           (service/cached this)
                           spec-map)
              (service/request source-service [endpoint id] ch-in)
              (swap! subscriptions assoc target ch-in)))))
      (cancel [this target]
        (when-let [ch (swap-out! subscriptions target)]
          (service/cancel source-service ch))))))

(defn compscriber
  "Return a service for requesting composite streams of multiple
