    updated-block]
   (assert (= ::specs/un-ackd-blocks
              (::specs/next-block-queue outgoing)))
-  (println "This should fail")
   (let [result
         (-> state
-            (update ::log2/state
-                    #(log2/debug %
-                                 ::mark-block-resent
-                                 "Resending a block"))
-            (update-in state [::specs/outgoing ::specs/un-ackd-blocks]
+            (update ::log/state
+                    #(log/debug %
+                                ::mark-block-resent
+                                "Resending a block"))
+            (update-in [::specs/outgoing ::specs/un-ackd-blocks]
                        (fn [cur]
                          (conj (disj cur prev-block) updated-block))))]
     (println "Got through that OK\nNew state keys:\n" (keys result))

                   ;; the message packet that it's going to send.
                   (not send-eof-processed))))]
    {::ok-send? result
     ::log2/state
     (if result
       log-state
       (log2/debug log-state
                   ::ok-to-send-new?
                   "Bad preconditions for sending a new block"
                   {::specs/recent recent
                    ::specs/earliest-send-time earliest-send-time
                    ::un-sent-count (count un-sent-blocks)
                    ::un-ackd-count (count un-ackd-blocks)
                    ::specs/want-ping want-ping
                    ::specs/send-eof send-eof
                    ::specs/send-eof-processed send-eof-processed
                    ::specs/strm-hwm strm-hwm}))}))

(s/fdef check-for-new-block-to-send
        :args (s/cat :state ::specs/state)

             ;; We haven't had another timeout since the last-panic.
             ;; Don't adjust those dials.
             state')
           ::log/state log-state)))
      ;; Honestly, it makes more sense to consolidate the
      ;; gap-buffer with any ACKs in this message before
      ;; looking for messages to resend.
      ;; TODO: That instead.
      (update state
              ::log/state
              #(log/debug %
                          label
                          "Conditions wrong for resending any of our previously sent un-ack'd blocks"
                          {::un-ackd-count (count un-ackd-blocks)
                           ::specs/earliest-time earliest-time
                           ::specs/n-sec-per-block n-sec-per-block
                           ::specs/rtt-timeout (long rtt-timeout)
                           ::specs/recent recent})))))

(declare send-eof-buffered?)
(s/fdef ok-to-send-new?
        :args (s/cat :state ::specs/state)
        :ret (s/keys :req [::ok-send? ::log/state]))
(defn ok-to-send-new?
  [{:keys [::specs/message-loop-name
           ::specs/recent]
