anchor.diff:          let key = (sources, packageName, semVer)
           startedGetPackageDetailsRequests.GetOrAdd (key, fun _ ->
               workerQueue
  -            |> ResolverRequestQueue.addWork WorkPriority.BackgroundWork (fun () ->
  +            |> ResolverRequestQueue.addWork WorkPriority.BackgroundWork (fun ct ->
                   (getPackageDetailsRaw sources groupName packageName semVer : Async<PackageDetails>)
                       |> Async.StartAsTask))
       let getPackageDetailsBlock sources groupName packageName semVer =
  
positive.code: 
  type RequestWork =
      private
          { StartWork : unit -> System.Threading.Tasks.Task
            mutable Priority : WorkPriority }
  
  type WorkHandle<'a> = private { Handle : Guid; Work : RequestWork; TaskSource : TaskCompletionSource<'a> }
  and ResolverRequestQueue =
      private { DynamicQueue : System.Collections.Concurrent.ConcurrentDictionary<Guid, RequestWork> }
  module ResolverRequestQueue =
      open System.Threading
  
      let Create() = { DynamicQueue = new System.Collections.Concurrent.ConcurrentDictionary<Guid, RequestWork>(); }
      let addWork prio (f: unit -> System.Threading.Tasks.Task<'a>) ({ DynamicQueue = queue } as q) =
          let tcs = new TaskCompletionSource<_>()
          let work =
              { StartWork = (fun () ->
                  let t =
                      try
                          f()
                      with e -> 
                          //Task.FromException (e)
                          let tcs = new TaskCompletionSource<_>()
  
negative.code:                         tcs.SetException(t.Exception)
                      else tcs.SetResult (t.Result)))
                Priority = prio }
          q.AddWork work
          { Work = work; TaskSource = tcs }
      let startProcessing (ct:CancellationToken) ({ DynamicQueue = queue } as q) =
          async {
              while not ct.IsCancellationRequested do
                  let! work = q.GetWork(ct) |> Async.AwaitTask
                  match work with
                  | Some work ->
                      do! work.StartWork(ct).ContinueWith(fun (t:System.Threading.Tasks.Task) -> ()) |> Async.AwaitTask
                  | None -> ()
          }
          |> Async.StartAsTask
  
  