                      collections: Set<PackageCollectionsModel.CollectionIdentifier>?,
                      callback: @escaping (Result<PackageCollectionsModel.PackageSearchResult.Item, Error>) -> Void) {
         self.storage.sources.list { result in
-            switch result {
+            let notFoundError = NotFoundError("identity: \(identity), location: \(location ?? "none")")
+            
+            switch result {
+            case .failure(is NotFoundError):
+                callback(.failure(notFoundError))
             case .failure(let error):
                 callback(.failure(error))
             case .success(let sources):

                            matches = packagesCollections.packages
                        }
                        guard let package = matches.first else {
                            return callback(.failure(NotFoundError("\(identity), \(location ?? "none")")))
                        }
                        callback(.success(.init(package: package, collections: packagesCollections.collections)))
                    }

                    collectionIdentifiers = collectionIdentifiers.filter { collections.contains($0) }
                }
                if collectionIdentifiers.isEmpty {
                    return callback(.failure(notFoundError))
                }
                self.storage.collections.findPackage(identifier: identity, collectionIdentifiers: collectionIdentifiers) { findPackageResult in
                    switch findPackageResult {
                    case .failure(is NotFoundError):
                        callback(.failure(notFoundError))
                    case .failure(let error):
                        callback(.failure(error))
                    case .success(let packagesCollections):
