(let [reader (.. response -body getReader)]
                  (-> (.read reader)
                      (.then (fn [result]
                               ;; repeat the .read call when not done
                               (tap> {:done? (.-done result)})
                               ;; emit chunk to flow
                               #(js/console.log :chunk (.decode decoder (.-value result)))))))

I guess I can use observe :thinking_face:

Assuming you have a task to read the next chunk, you can use this pattern :

(m/ap
  (loop []
    (let [result (m/? (read! reader))]
      (if (.-done result) result (m/amb> result (recur))))))

(defn read-chunks
  [reader emit!]
  (let [decoder (js/TextDecoder.)]
    (-> (.read reader)
        (.then (fn [result]
                 ;; repeat the .read call when not done
                 (js/console.log :read-result result)
                 (if (.-done result)
                   (emit! {:done? (.-done result)})
                   (do (emit! {:chunk (.decode decoder (.-value result))})
                       (read-chunks reader emit!))))))))

what does amb> mean in the above?

it means emit the result, then emit the result of the next loop

this is very close to your approach in fact

(defn read-chunks [reader]
  (m/ap
    (let [decoder (js/TextDecoder.)]
      (loop []
        (let [result (m/? (fn [s f] (.then (.read reader) s f) #()))]
          (js/console.log :read-result result)
          (if (.-done result)
            {:done? (.-done result)}
            (m/amb> {:chunk (.decode decoder (.-value result))}
              (recur))))))))