anchor.diff:            |> List.sortDescending
             |> List.map loop
             |> AsyncSeq.mergeAll
  +          |> AsyncSeq.filter (fun x ->
  +            match x with
  +            | Candidate _ -> true
  +            | Unsatisfiable _ -> false
  +          )
             |> AsyncSeq.distinctUntilChanged
  +          |> appendIfEmpty (Unsatisfiable versionConstraint)
         | All xs ->
           let combine (xs : Set<PackageLocation * Set<Version>>) (ys : Set<PackageLocation * Set<Version>>) =
             xs
  
positive.code:   abstract member FetchManifest : PackageLock * Set<Version> -> Async<Manifest>
    abstract member FetchLock : PackageLock * Set<Version> -> Async<Lock>
  
  module SourceExplorer =
    let fetchLocationsForConstraint (sourceExplorer : ISourceExplorer) locations package versionConstraint =
      let rec loop (versionConstraint : Constraint) = asyncSeq {
        match Constraint.simplify versionConstraint with
        | Complement c ->
          let! complement =
            loop c
            |> AsyncSeq.map fst
            |> AsyncSeq.fold (fun s x -> Set.add x s) Set.empty
  
          yield!
            loop (Constraint.All [])
            |> AsyncSeq.filter (fun (location, _) -> complement |> Set.contains location |> not)
        | Any xs ->
          yield!
            xs
  
negative.code:           |> AsyncSeq.map (Version.SemVer)
            |> AsyncSeq.collect (fun version ->
              sourceExplorer.FetchLocations locations package version
              |> AsyncSeq.map (fun l -> Candidate (l, Set.singleton version))
            )
            |> appendIfEmpty (Unsatisfiable versionConstraint)
      }
  
      loop versionConstraint
      |> AsyncSeq.takeWhileInclusive (fun x ->
        match x with
        | Candidate _ -> true
        | Unsatisfiable _ -> false
      )