diff --git a/bench/Bench.hs b/bench/Bench.hs
--- a/bench/Bench.hs
+++ b/bench/Bench.hs
@@ -35,10 +35,7 @@
 
 main :: IO ()
 main =
-    defaultMain [ bgroup "buildSequence"
-                      [ bench "3" $ nf buildSequence deps
-                      , bench "6" $ nf buildSequence (bifunctors : microlens : deps)
-                      ]
-                , bgroup "resolveDependencies"
-                      [ bench "3" $ nf (resolveDependencies set) [lens] ]
+    defaultMain [ bgroup "resolveDependencies"
+                      [ bench "3" $ nf (resolveDependencies set) [lens]
+                      , bench "6" $ nf (resolveDependencies set) [lens, microlens, bifunctors] ]
                 ]
diff --git a/dependency.cabal b/dependency.cabal
--- a/dependency.cabal
+++ b/dependency.cabal
@@ -1,5 +1,5 @@
 name:                dependency
-version:             0.1.0.5
+version:             0.1.0.6
 synopsis:            Dependency resolution for package management
 description:         A library for resolving dependencies; uses a topological sort to construct a build plan and then allows choice between all compatible plans.
 license:             BSD3
diff --git a/src/Data/Dependency.hs b/src/Data/Dependency.hs
--- a/src/Data/Dependency.hs
+++ b/src/Data/Dependency.hs
@@ -40,31 +40,19 @@
 buildSequence = reverse . groupBy independent . sortDeps
     where independent (Dependency ln _ ls _) (Dependency ln' _ ls' _) = ln' `notElem` ls && ln `notElem` ls'
 
-dock :: (Eq a, Ord a) => [S.Set a] -> S.Set a
-dock [x] = x
-dock []  = S.fromList []
-dock (x:ys@(y:_))
-     | x == y = y
-     | otherwise = dock ys
-
 iterateM :: (Monad m) => Int -> (a -> m a) -> a -> m [a]
 iterateM 0 _ _ = pure []
 iterateM n f x = (x:) <$> (iterateM (n-1) f =<< f x)
 
--- FIXME saturate everything at once.
-saturateDeps :: PackageSet Dependency -> Dependency -> DepM [Dependency]
-saturateDeps ps = fmap toList . resolve <=< saturateDeps' ps
-    where resolve :: S.Set Dependency -> DepM (S.Set Dependency)
-          resolve set = dock <$> iterateM n next set
-          next :: S.Set Dependency -> DepM (S.Set Dependency)
+saturateDeps :: PackageSet Dependency -> Dependency -> DepM (S.Set Dependency)
+saturateDeps ps = resolve <=< saturateDeps' ps
+    where resolve set = last <$> iterateM n next set
           next depSet = S.unions <$> sequence (saturateDeps' ps <$> toList depSet)
-          n :: Int
           n = length (toList ps)
 
 saturateDeps' :: PackageSet Dependency -> Dependency -> DepM (S.Set Dependency)
 saturateDeps' (PackageSet ps) dep = do
-    let libDeps = _libDependencies dep
-    deps <- sequence [ lookupMap lib ps | lib <- libDeps ]
+    deps <- sequence [ lookupMap lib ps | lib <- _libDependencies dep ]
     list <- (:) dep <$> traverse lookupSet deps
     pure $ S.fromList list
 
@@ -78,11 +66,11 @@
 --
 -- 4. Specify an error for overconstrained builds
 --
--- 5. Specify an error if a package is not present.
+-- 5. Specify an error if a package is not present
 --
 -- This doesn't do any package resolution beyond versioning.
 resolveDependencies :: PackageSet Dependency -> [Dependency] -> DepM [[Dependency]]
-resolveDependencies ps = select . getLatest <=< fmap buildSequence . saturated
+resolveDependencies ps = select . getLatest <=< fmap (buildSequence . toList) . saturated
     where select = fmap (fmap (fmap snd))
-          saturated dep = join <$> traverse (saturateDeps ps) dep
+          saturated dep = S.unions <$> traverse (saturateDeps ps) dep
           getLatest = traverse (traverse (latest ps))