        (let [result (from-child/consume-from-child state array-o-bytes)]
          result))
      ;; trigger-io does some state management, even
-     ;; if we discard the incoming buffer
-     state)))
-
+     ;; if we discard the incoming bytes because our
+     ;; buffer is full
+     ;; TODO: Need a way to signal the child to
+     ;; try again shortly
+     (do
+       (log/error "Discarding incoming bytes, silently")
+       state))))
+
+(s/fdef trigger-from-parent
+        :args (s/cat :state-agent ::specs/state-agent
+                     :state ::specs/state
+                     :array-o-bytes bytes?)
+        :ret ::specs/state)
 (defn trigger-from-parent
   "Message block arrived from parent. We have work to do."
   ;; TODO: Move as much of this as possible into from-parent

  ;; send to actually get through the queue
  (let [min-resend-time (+ last-block-time n-sec-per-block)
        _ (log/debug (cl-format nil
                                "~a: Minimum resend time: ~:d which is ~:d nanoseconds after ~:d"
                                message-loop-name
                                min-resend-time
                                n-sec-per-block
                                ;; last-block-time causes problems.
                                ;; Up until the point I've sent my
                                ;; last block, it basically progresses
                                ;; linearly up to 1907725432157608
                                ;; (for tonight's debug session).
                                ;; Then it jumps down to
                                ;; 1907725404755660, which leaves
                                ;; me with negative delays, because
                                ;; I'm trying to send the next send
                                ;; in the past.
                                ;; And doing this every millisecond
                                ;; leads to its own set of problems.
                                ;; FIXME: Start back here.
                                last-block-time))
        default-next (+ recent (utils/seconds->nanos 60))
        _ (log/debug (cl-format nil
                                "~a: Default +1 minute: ~:d from ~:d"

   {{:keys [::specs/->child]} ::specs/incoming
    :keys [::specs/message-loop-name]
    :as state}
   ^bytes message]
  {:pre [->child]}

  (cancel-timer! state)
  (log/info (str message-loop-name ": Incoming from parent"))

  ;; This is basically an iteration of the top-level
  ;; event-loop handler from main().
  ;; I can skip the pieces that only relate to reading
