anchor.diff:    Project = name
   }
   
  -let branch b = Version.Git (GitVersion.Branch b)
  +let br b = Version.Git (GitVersion.Branch b)
   let rev (x : int) = Version.Git(GitVersion.Revision (x.ToString()))
   let ver (x : int) = Version.SemVer {SemVer.zero with Major = x}
   
  -type TestingSourceExplorer (manifestSpec : List<PackageIdentifier * Version * Manifest>) =
  +type TestingSourceExplorer (manifestSpec : List<PackageIdentifier * Set<Version> * Manifest>) =
   
     interface ISourceExplorer with
       member this.FetchVersions (_ : PackageSources) (package: PackageIdentifier) : AsyncSeq<Version>  = asyncSeq {
  -
         yield!
           manifestSpec
             |> Seq.choose (fun (p, v, _) ->
               if p = package
  -            then Some v
  +            then Some (v |> Set.toSeq |> Seq.sortDescending)
               else None)
  +          |> Seq.collect (id)
             |> AsyncSeq.ofSeq
       }
   
       member this.FetchLocations (_: PackageSources) (package: PackageIdentifier) (version: Version) : AsyncSeq<PackageLocation> = asyncSeq {
  -        match package, version with
  -        | (Adhoc a, SemVer v) ->
  -          yield PackageLocation.GitHub {
  -            Package = { Owner = a.Owner; Project = a.Project };
  -            Revision = v.Major.ToString()
  -          }
  -        | (Adhoc a, _) ->
  +        match package with
  +        | (Adhoc a) ->
             yield! manifestSpec
  -            |> List.filter (fun (p, _, _) -> p = package )
  -            |> List.map(fun (_, v,_) -> v)
  +            |> List.filter (fun (p, vs, _) -> p = package && vs |> Set.contains version)
  +            |> List.map(fun (_, vs,_) -> vs)
  +            |> List.collect(Set.toList)
               |> List.choose(fun x ->
                   match x with
  -                | SemVer v -> Some v
  +                | Version.Git (GitVersion.Revision r) -> Some r
  +                | SemVer v -> Some (v.Major.ToString())
                   | _ -> None)
  -            |> List.map(fun v ->
  +            |> List.map(fun r ->
                   PackageLocation.GitHub {
                     Package = { Owner = a.Owner; Project = a.Project };
  -                  Revision = v.Major.ToString()
  +                  Revision = r
                   })
               |> AsyncSeq.ofSeq
  -
           | _ -> raise <| new System.SystemException "package not found"
       }
   
  
positive.code:     }
  
  
  let dep (p : string, vs : List<Version>) : Buckaroo.Dependency = {
      Package = package p;
      Constraint = Any ( vs |> List.map (Exactly));
      Targets = None
  }
  
  
negative.code:     with Dependencies = xs |> List.map dep |> Set.ofList
  }
  
  type ManifestSpec = List<PackageIdentifier * Set<Version> * Manifest>
  
  let solve (manifests : ManifestSpec) style root =
      let console = new ConsoleManager(LoggingLevel.Debug);
  