anchor.diff:              let multi = (this.client ()).CreateTransaction()
               let waitLength = multi.ListLengthAsync (this.toKey("wait"))
               let pausedLength = multi.ListLengthAsync (this.toKey("paused"))
  +            let delayedLength = multi.SortedSetLengthAsync (this.toKey("delayed"))
               do! multi.ExecuteAsync () |> Async.AwaitTask |> Async.Ignore
  -            return [| waitLength.Result; pausedLength.Result; |] |> Seq.max
  +            return [| waitLength.Result; pausedLength.Result; |] |> Seq.max + delayedLength.Result
           }
       
       /// empty the queue doesn't remove the jobs just removes the wait list so it won't do anything else.
  
positive.code:         }
  
      /// pause the queue
      /// note: (waits for the last job to finish before pausing the queue.)
      /// note 2: (this turns a bit akward when the jobs run in parallel so it might just do two more jobs before it pauses, but it will pause I promise)
      member x.pause () = 
          async {
              logger.Info "pausing queue %s" name
              if paused then 
                  return paused
              else 
                  if processing then 
                      do! this.on.Completed |> Async.AwaitEvent |> Async.Ignore
                  
                  paused <- true
                  do! this.emitQueueEvent Paused 
                  return paused
          }
        
      /// resume a paused queue  
      member x.resume handler = 
          async { 
              logger.Info "resuming queue %s" name
              if paused then
                  paused <- false
                  do! this.emitQueueEvent Resumed
                  this.run handler |> Async.Start
              else
                  failwith "Cannot resume running queue"
          }
  
      /// return the length of the queue
  
negative.code:                     async {
                          this.updateDelayTimer(v |> float)
                      } |> Async.RunSynchronously))
  
      do sub.Subscribe(_toKey("paused") |> keyToChannel, (fun c v -> this.emitQueueEvent(Paused)))
      do sub.Subscribe(_toKey("resumed") |> keyToChannel, (fun c v -> this.emitQueueEvent(Resumed)))
  
      do logger.Info "subscribed to %A" newJobChannel
  
  