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:             | Paused -> pausedEvent.Trigger({ queue = this });
              | Resumed -> resumedEvent.Trigger({ queue = this });
              | _ -> failwith "Not a queue event!"
          }
  
      member internal x.emitJobEvent (eventType, job:Job<'a>, ?value, ?exn, ?data) = 
  
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 { () }
  
  