anchor.diff:    "Turns passed flow into a loop. Flow will be repeated while test function returns `t`.
   Test happens before each flow execution. Result of the last flow iteration is passed to the next
   flow block after the looped flow."
  -  (declare (type function test))
  -  (let (looped recurred-result)
  -    (setf looped (->> (value)
  -                   (setf recurred-result value)
  -                   (if (funcall test)
  -                       (>> (instantly ()
  -                             ;; prevent infinite recursion
  -                             (capture-loop flow)
  -                             ;; feed result from the previous loop iteration
  -                             recurred-result)
  -                           flow
  -                           looped)
  -                       (instantly ()
  -                         recurred-result))))))
  +  (flow:repeatedly (funcall test) flow))
   
   ;;
   (defclass system ()
  
positive.code: (defvar *predefined-event-callbacks* nil)
  (defvar *executable-p* nil)
  
  (declaim (special *system*
                    *recursive-flow*))
  
  
  (defvar *recursive-flow* nil)
  
  
  (define-constant +engine-resource-path+ "/bodge/"
  
negative.code:                           (when-let ((continue-handler (find-restart 'continue)))
                              (log/error "Error encountered while engine is in coma, ignoring: ~A" e)
                              (invoke-restart continue-handler))))))
        (labels ((traps-masking-task ()
                   (claw:with-float-traps-masked ()
                     (funcall task))))
          (etypecase invariant
            (null (if concurrently
                      (execute shared-pool #'traps-masking-task :priority priority)
  