anchor.diff:           (if universal
                universal
                (+ unix *unix-epoch-difference*)))
  +        ((or in)
  +         (+ (get-universal-time)
  +            (parse-delay in)))
           ((and from every)
  -         (cons (parse-delay from)
  -               (parse-delay every)))))))
  -
  -(defun schedule-timer (timer type delay)
  -  ""
  -  (assert (find type '(:date :time :once :when :interval :repeating :loop :every)) ()
  -          "TYPE must be one of (:DATE :TIME :ONCE :INTERVAL :REPEATING :LOOP).")
  -  (let ((handler (time-handler timer))
  -        (delay (parse-delay delay)))
  -    (unless handler
  -      (error "No such time-handler found: ~a" timer))
  -    (v:debug :timer "Scheduling timer ~a with ~a ~a" timer type delay)
  -    (funcall (launcher-function handler)
  -             type delay)))
  +         (list (parse-delay from)
  +               (parse-delay every)
  +               (if until (parse-delay until) -1)))))))
   
   (defun timer-timeout (type delay function)
     (flet ((inner (time-target)
              (v:trace :timer "Timing ~a seconds" (- time-target (get-universal-time)))
              (loop while (< (get-universal-time) time-target)
                    do (sleep (- time-target (get-universal-time))))
  -           (funcall function)))
  +           (handler-bind
  +               ((error #'(lambda (err)
  +                           (v:warn :timer "ERROR: ~a" err)
  +                           (when *debugger*
  +                             (invoke-debugger err)))))
  +             (funcall function))))
       (ecase type
         ((:date :time :once :when)
          (inner (if (consp delay) (car delay) delay)))
         ((:interval :repeating :loop :every)
  -       (if (consp delay)
  -           (loop for current = (car delay)
  -                   then (+ (get-universal-time) (cdr delay))
  -                 do (inner current)
  -                    (thread-yield))
  +       (if (listp delay)
  +           (destructuring-bind (from every until) delay
  +             (loop for current = from
  +                     then (+ (get-universal-time) every)
  +                   while (or (< until 0)
  +                             (< (get-universal-time) until))
  +                   do (inner current)
  +                      (thread-yield)))
              (loop do (inner (+ (get-universal-time) delay))
                       (thread-yield)))))))
   
  -(defun launch-module-timer (handler-name module-name type delay)
  -  (let ((handler (time-handler handler-name))
  -        (module (get-module module-name))
  -        (uuid) (launch-done NIL))
  -    (setf uuid (with-module-thread (module)
  -                 (unwind-protect
  -                      (timer-timeout type delay (handler-function handler))
  -                   ;; Yield until the launch has completed.
  -                   (loop until launch-done do (thread-yield))
  -                   (with-lock-held ((handler-lock handler))
  -                     (let ((thread (module-thread module uuid)))
  -                       (v:debug :timer "CLEANUP ~a" thread)
  -                       (setf (active-timers handler)
  -                             (delete thread (active-timers handler))))))))
  -    (let ((thread (module-thread module uuid)))
  -      (with-lock-held ((handler-lock handler))
  -        (push thread (active-timers handler)))
  -      ;; We can only set this now to ensure the thread definitely waits
  -      ;; with its self-removal until we've actually pushed it.
  -      (setf launch-done T)
  -      thread)))
  -
  -(defun launch-generic-timer (handler-name type delay)
  -  (let ((handler (time-handler handler-name))
  -        (thread NIL) (launch-done NIL))
  +(defun launch-timer (handler type delay arguments)
  +  (let ((thread) (launch-done NIL))
       (setf thread (make-thread #'(lambda ()
                                     (unwind-protect
  -                                       (timer-timeout type delay (handler-function handler))
  +                                       (timer-timeout
  +                                        type delay
  +                                        #'(lambda () (apply (handler-function handler) arguments)))
                                       ;; Yield until the launch has completed.
  -                                    (loop until launch-done do (thread-yield))
  +                                    (loop do (thread-yield) until launch-done)
                                       (with-lock-held ((handler-lock handler))
                                         (v:debug :timer "CLEANUP ~a" thread)
                                         (setf (active-timers handler)
                                               (delete thread (active-timers handler))))))
  -                              :name (format NIL "Timer thread for ~a" handler-name)))
  +                              :name (format NIL "Timer thread for ~a" handler)))
       (with-lock-held ((handler-lock handler))
         (push thread (active-timers handler)))
       ;; We can only set this now to ensure the thread definitely waits
  
positive.code:     (setf launch-done T)
      thread))
  
  (defmacro define-timer (name (&key documentation module-name (modulevar 'module)) &body body)
    ""
    (unless module-name
      (setf module-name (get-current-module-name)))
    (let ((launcher (gensym "LAUNCHER-FUNCTION"))
          (handler (gensym "HANDLER-FUNCTION")))
      `(eval-when (:compile-toplevel :load-toplevel :execute)
         (let ((,handler
                 #'(lambda ()
                     ,@(if module-name
                           `((with-module (,modulevar ,module-name)
                               (when (active ,modulevar)
                                 (with-module-lock (,modulevar)
                                   (with-module-storage (,modulevar)
                                     ,@body)))))
                           body)))
               (,launcher
                 #'(lambda (type delay)
                     ,(if module-name
                          `(launch-module-timer ',name ',module-name type delay)
                          `(launch-generic-timer ',name type delay)))))
           (set-timer-function ',name ,launcher ,handler :docstring ,documentation)))))
  
negative.code:     Creates a relative (in seconds) timestamp for the
      specified timespan.
  
    :IN
      Creates an absolute (universal-time) timestamp using
      the specified relative sub-delay, which is parsed by
      PARSE-DELAY.
  
    :FROM :EVERY :UNTIL
      Creates a timestamp with an initial delay specified by
      :FROM and a following delay of :EVERY. Both parameters
      are again parsed with PARSE-DELAY. If :UNTIL is passed,
      the timestamp will only repeat until the absolute 
      timestamp :UNTIL is reached.")
    (:method ((delay integer))
      delay)
    (:method ((delay cons))
      (destructuring-bind (&key sec min hour day month year secs mins hours days months years unix universal in from every until) delay
        (unless (xor (or sec min hour day month year)
                     (or secs mins hours days months years)
                     (or unix universal)
                     (or in)
                     (or from every until))
          (error "Cannot use multiple delay descriptors at the same time."))
        (cond
          ((or sec min hour day month year)
  