anchor.diff:      let resumedChannel = _toKey("resumed") |> keyToChannel
       let pausedChannel = _toKey("paused") |> keyToChannel
   
  -    let sub = subscriberFactory ()
  -    do sub.Subscribe(
  -                newJobChannel,
  -                (fun c v ->
  -                    async {
  -                        let jobId = v |> int64
  -                        return! this.emitNewJobEvent(jobId)
  -                    } |> Async.RunSynchronously))
  -
  -    let rec ensureSubscription () =
  -        async {
  -            let! res = sub.PublishAsync (newJobChannel, -1L |> toValueI64)  |> Async.AwaitTask
  -            if res >= 1L then 
  -                ()
  -            else 
  -                return! ensureSubscription ()
  -            do! Async.Sleep 10
  -        }
  -
  -    do ensureSubscription () |> Async.RunSynchronously
  -
  -    do sub.Subscribe(
  -                delayedJobChannel,
  -                (fun c v ->
  -                    async {
  -                        this.updateDelayTimer(v |> float)
  -                    } |> Async.RunSynchronously))
  -
  -    do sub.Subscribe(_toKey("paused") |> keyToChannel,
  -        (fun c v ->
  -            do
  -                match v |> string with
  -                | "paused" -> this.emitQueueEvent(Paused) |> Async.RunSynchronously
  -                | "resumed" -> this.emitQueueEvent(Resumed) |> Async.RunSynchronously
  -                | _ -> failwith "unexpected message on internal pause/resume channel"
  -    ))
  -
  -    do logger.Info "subscribed to %A" newJobChannel
  -
  -    let token = Guid.NewGuid ()
  -
       let completedEvent = new Event<OxenJobEventDelegate<'a>, OxenJobEvent<'a>> ()
       let progressEvent = new Event<OxenJobEventDelegate<'a>, OxenJobEvent<'a>> ()
       let failedEvent = new Event<OxenJobEventDelegate<'a>, OxenJobEvent<'a>> ()
  
positive.code:             | Paused -> pausedEvent.Trigger(x, { queue = this })
              | Resumed -> resumedEvent.Trigger(x, { queue = this })
              | _ -> failwith "Not a queue event!"
          }
  
      member internal x.emitNewJobEvent jobId =
          async {
              newJobEvent.Trigger(x, { jobId = jobId })
          }
  
      member internal x.emitJobEvent (eventType, job:Job<'a>, ?value, ?exn, ?data) =
  
negative.code:     let onPaused = pausedEvent.Publish
      let onResumed = resumedEvent.Publish
      let onNewJob = newJobEvent.Publish
  
      let sub = subscriberFactory ()
      do sub.Subscribe(
                  newJobChannel,
                  (fun c v ->
                      async {
                          let jobId = v |> int64
                          newJobEvent.Trigger(this, { jobId = jobId })
                      } |> Async.RunSynchronously))
  
      let rec ensureSubscription () =
          async {
              let! res = sub.PublishAsync (newJobChannel, -1L |> toValueI64)  |> Async.AwaitTask
              if res >= 1L then 
                  ()
              else 
                  return! ensureSubscription ()
              do! Async.Sleep 10
          }
  
      do ensureSubscription () |> Async.RunSynchronously
  
      do sub.Subscribe(
                  delayedJobChannel,
                  (fun c v ->
                      async {
                          this.updateDelayTimer(v |> float)
                      } |> Async.RunSynchronously))
  
      do sub.Subscribe(_toKey("paused") |> keyToChannel,
          (fun c v ->
              do
                  match v |> string with
                  | "paused" -> this.emitQueueEvent(Paused) |> Async.RunSynchronously
                  | "resumed" -> this.emitQueueEvent(Resumed) |> Async.RunSynchronously
                  | _ -> failwith "unexpected message on internal pause/resume channel"
      ))
  
      do logger.Info "subscribed to %A" newJobChannel
  
      let token = Guid.NewGuid ()
  
      let processJob handler job =
          async {
  