anchor.diff:            (update-timestamp-until-day)
             (update-timestamp-until-week))))
   
  -    (timestamp-to-universal new-timestamp)))
  +    (awhen new-timestamp (timestamp-to-universal it))))
   
   (defun update-recurring-event-time (id &optional data result-struct)
  -  (let ((result (or result-struct (gethash id *db-results*)))
  -        (new-time (next-recurring-event-time id data)))
  -    (modify-db id :auto-updated-time new-time)
  -    (with-locked-hash-table (*db-results*)
  -      (setf (result-time result) new-time))
  -    (event-index-update result)))
  +  (let ((result (or result-struct (gethash id *db-results*))))
  +    (awhen (next-recurring-event-time id data)
  +      (modify-db id :auto-updated-time it)
  +      (with-locked-hash-table (*db-results*)
  +        (setf (result-time result) it))
  +      (event-index-update result))))
   
   (defun recurring-event-schedule (id &optional data)
     (let* ((event (or data (db id)))
  
positive.code:                             (getf event :local-time)))
           (previous-timestamp (universal-to-timestamp previous-time))
           (timestamp (universal-to-timestamp time))
           (new-timestamp)
           (new-day-of-week)
           (new-week-of-month))
  
negative.code:                (asetf new-timestamp
                        (adjust-timestamp (or it previous-timestamp)
                          (offset offset-period offset-count)))
                 (cond
                   ((and end-timestamp (> new-timestamp end-timestamp))
                    (setf new-timestamp nil))
                   ((timestamp< new-timestamp timestamp)
                    (update-timestamp offset-period))))
  
               (update-timestamp-until-day ()
                 (update-timestamp :day)
  