anchor.diff:              match gotIt with 
               | g when g.HasValue -> return! this.getJob (fromValueI64 g)
               | _ -> 
  -                do! this.on.NewJob |> Async.AwaitEvent |> Async.Ignore
  +                do! onNewJob |> Async.AwaitEvent |> Async.Ignore
                   return! getNextJob ()
           }
   
       let rec processJobs handler = 
           async {
               let! job = getNextJob ()
  -            do processJob handler job |> Async.Start
  +            match allowParallelProcessing |? false with
  +            | true -> do processJob handler job |> Async.Start
  +            | false -> do! processJob handler job
  +            
               if not(paused) then 
  -                do! processJobs handler
  +                return! processJobs handler
           }
   
       let processStalledJob handler (job:Job<'a>) = 
  
positive.code:         queue: Queue<'a>
      }
  
  and Events<'a> = {
      Completed: IEvent<OxenJobEvent<'a>>
      Progress: IEvent<OxenJobEvent<'a>>
      Failed: IEvent<OxenJobEvent<'a>>
      Paused: IEvent<OxenQueueEvent<'a>>
      Resumed: IEvent<OxenQueueEvent<'a>>
      NewJob: IEvent<OxenJobEvent<'a>>
  }
  
  and LockRenewer<'a> (job:Job<'a>, token:Guid) =
  
negative.code:     let failedEvent = new Event<OxenJobEvent<'a>> ()
      let pausedEvent = new Event<OxenQueueEvent<'a>> ()
      let resumedEvent = new Event<OxenQueueEvent<'a>> ()
      let newJobEvent = new Event<OxenNewJobEvent> ()
      let onNewJob = newJobEvent.Publish
  
      let once s = async { () }
  
  