diff --git a/libpkg/algo/search.cpp b/libpkg/algo/search.cpp
index b3433fb..bc5c2b9 100644
--- a/libpkg/algo/search.cpp
+++ b/libpkg/algo/search.cpp
@@ -128,11 +128,10 @@ PackageSearchResult Config::findPackage(const Dependency &dependency)
     auto result = PackageSearchResult();
     auto exactMatch = false;
     for (auto &db : databases) {
-        db.providingPackages(dependency, false, [&](StorageID id, Package &&package) {
-            // FIXME: avoid copy
-            exactMatch = dependency.name == package.name;
+        db.providingPackages(dependency, false, [&](StorageID id, const std::shared_ptr<Package> &package) {
+            exactMatch = dependency.name == package->name;
             result.db = &db;
-            result.pkg = std::make_shared<Package>(std::move(package));
+            result.pkg = package;
             result.id = id;
             // prefer package where the name matches exactly; so if we found one no need to look further
             return exactMatch;
@@ -152,10 +151,9 @@ std::vector<PackageSearchResult> Config::findPackages(const Dependency &dependen
     auto results = std::vector<PackageSearchResult>();
     for (auto &db : databases) {
         auto visited = std::unordered_set<StorageID>();
-        db.providingPackages(dependency, reverse, [&](StorageID packageID, Package &&package) {
-            // FIXME: avoid copy
+        db.providingPackages(dependency, reverse, [&](StorageID packageID, const std::shared_ptr<Package> &package) {
             if (visited.emplace(packageID).second) {
-                results.emplace_back(db, std::make_shared<Package>(std::move(package)), packageID);
+                results.emplace_back(db, package, packageID);
             }
             return false;
         });
@@ -171,10 +169,9 @@ std::vector<PackageSearchResult> Config::findPackagesProvidingLibrary(const std:
     auto results = std::vector<PackageSearchResult>();
     auto visited = std::unordered_set<StorageID>();
     for (auto &db : databases) {
-        db.providingPackages(library, reverse, [&](StorageID packageID, Package &&package) {
-            // FIXME: avoid copy
+        db.providingPackages(library, reverse, [&](StorageID packageID, const std::shared_ptr<Package> &package) {
             if (visited.emplace(packageID).second) {
-                results.emplace_back(db, std::make_shared<Package>(std::move(package)), packageID);
+                results.emplace_back(db, package, packageID);
             }
             return false;
         });
@@ -189,10 +186,9 @@ std::vector<PackageSearchResult> Config::findPackages(const std::regex &regex)
 {
     auto pkgs = std::vector<PackageSearchResult>();
     for (auto &db : databases) {
-        db.allPackages([&](StorageID packageID, Package &&package) {
-            if (std::regex_match(package.name, regex)) {
-                // FIXME: avoid copy
-                pkgs.emplace_back(db, std::make_shared<Package>(std::move(package)), packageID);
+        db.allPackages([&](StorageID packageID, const std::shared_ptr<Package> &package) {
+            if (std::regex_match(package->name, regex)) {
+                pkgs.emplace_back(db, package, packageID);
             }
             return false;
         });
@@ -226,10 +222,9 @@ std::vector<PackageSearchResult> Config::findPackages(
         if (!databasePred(db)) {
             continue;
         }
-        db.allPackages([&](StorageID packageID, const Package &package) {
-            if (packagePred(db, package)) {
-                // FIXME: avoid copy
-                pkgs.emplace_back(db, std::make_shared<Package>(package), packageID);
+        db.allPackages([&](StorageID packageID, const std::shared_ptr<Package> &package) {
+            if (packagePred(db, *package)) {
+                pkgs.emplace_back(db, package, packageID);
             }
             return false;
         });
@@ -244,10 +239,9 @@ std::vector<PackageSearchResult> Config::findPackages(const std::function<bool(c
 {
     auto pkgs = std::vector<PackageSearchResult>();
     for (auto &db : databases) {
-        db.allPackages([&](StorageID packageID, const Package &package) {
-            if (pred(db, package)) {
-                // FIXME: avoid copy
-                pkgs.emplace_back(db, std::make_shared<Package>(package), packageID);
+        db.allPackages([&](StorageID packageID, const std::shared_ptr<Package> &package) {
+            if (pred(db, *package)) {
+                pkgs.emplace_back(db, package, packageID);
             }
             return false;
         });
diff --git a/libpkg/data/config.cpp b/libpkg/data/config.cpp
index 4dd474d..f5f9def 100644
--- a/libpkg/data/config.cpp
+++ b/libpkg/data/config.cpp
@@ -151,13 +151,12 @@ void Config::pullDependentPackages(const std::vector<Dependency> &dependencies,
             if (relevantDbs.find(&db) == relevantDbs.end()) {
                 continue;
             }
-            db.providingPackages(dependency, false, [&](StorageID packageID, Package &&package) {
+            db.providingPackages(dependency, false, [&](StorageID packageID, const std::shared_ptr<Package> &package) {
                 found = true;
-                // FIXME: avoid copy
                 if (visited.emplace(packageID).second) {
                     const auto &[i, inserted] = runtimeDependencies.try_emplace(packageID);
                     if (inserted) {
-                        i->second = std::make_shared<Package>(std::move(package));
+                        i->second = package;
                     }
                     pullDependentPackages(i->second, relevantDbs, runtimeDependencies, missingDependencies, visited);
                 }
diff --git a/libpkg/data/database.cpp b/libpkg/data/database.cpp
index 3b61dc6..f0d1e6a 100644
--- a/libpkg/data/database.cpp
+++ b/libpkg/data/database.cpp
@@ -265,11 +265,10 @@ void Database::addPackageDependencies(StorageID packageID, const std::shared_ptr
 
 void Database::allPackages(const PackageVisitor &visitor)
 {
-    // TODO: use cache here
-    //auto &cachedPackages = m_storage->packageCache;
+    // TODO: use cache here, e.g. implement a "lazy" iterator for LMDB that also directly yields a std::shared_ptr
     auto txn = m_storage->packages.getROTransaction();
     for (auto i = txn.begin(); i != txn.end(); ++i) {
-        if (visitor(i.getID(), std::move(i.value()))) {
+        if (visitor(i.getID(), std::make_shared<Package>(std::move(i.value())))) {
             return;
         }
     }
@@ -282,8 +281,6 @@ std::size_t Database::packageCount() const
 
 void Database::providingPackages(const Dependency &dependency, bool reverse, const PackageVisitor &visitor)
 {
-    // TODO: use cache here
-    auto package = Package();
     auto providesTxn = (reverse ? m_storage->requiredDeps : m_storage->providedDeps).getROTransaction();
     auto packagesTxn = m_storage->packages.getROTransaction();
     for (auto [i, end] = providesTxn.equal_range<0>(dependency.name); i != end; ++i) {
@@ -292,7 +289,8 @@ void Database::providingPackages(const Dependency &dependency, bool reverse, con
             continue;
         }
         for (const auto packageID : i->relevantPackages) {
-            if (packagesTxn.get(packageID, package) && visitor(packageID, std::move(package))) {
+            const auto res = m_storage->packageCache.retrieve(*m_storage, &packagesTxn, packageID);
+            if (res.pkg && visitor(packageID, res.pkg)) {
                 return;
             }
         }
@@ -301,13 +299,12 @@ void Database::providingPackages(const Dependency &dependency, bool reverse, con
 
 void Database::providingPackages(const std::string &libraryName, bool reverse, const PackageVisitor &visitor)
 {
-    // TODO: use cache here
-    auto package = Package();
     auto providesTxn = (reverse ? m_storage->requiredLibs : m_storage->providedLibs).getROTransaction();
     auto packagesTxn = m_storage->packages.getROTransaction();
     for (auto [i, end] = providesTxn.equal_range<0>(libraryName); i != end; ++i) {
         for (const auto packageID : i->relevantPackages) {
-            if (packagesTxn.get(packageID, package) && visitor(packageID, std::move(package))) {
+            const auto res = m_storage->packageCache.retrieve(*m_storage, &packagesTxn, packageID);
+            if (res.pkg && visitor(packageID, res.pkg)) {
                 return;
             }
         }
@@ -506,23 +503,22 @@ std::unordered_map<PackageSpec, UnresolvedDependencies> Database::detectUnresolv
 LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPkg::Database *> &updateSources, UpdateCheckOptions options)
 {
     auto results = PackageUpdates();
-    allPackages([&](StorageID myPackageID, Package &&package) {
-        auto myPackage = std::make_shared<Package>(std::move(package));
+    allPackages([&](StorageID myPackageID, const std::shared_ptr<Package> &package) {
         auto regularName = std::string();
         if (options & UpdateCheckOptions::ConsiderRegularPackage) {
-            const auto decomposedName = myPackage->decomposeName();
+            const auto decomposedName = package->decomposeName();
             if ((!decomposedName.targetPrefix.empty() || !decomposedName.vcsSuffix.empty()) && !decomposedName.isVcsPackage()) {
                 regularName = decomposedName.actualName;
             }
         }
         auto foundPackage = false;
         for (auto *const updateSource : updateSources) {
-            const auto [updatePackageID, updatePackage] = updateSource->findPackageWithID(myPackage->name);
+            const auto [updatePackageID, updatePackage] = updateSource->findPackageWithID(package->name);
             if (!updatePackage) {
                 continue;
             }
             foundPackage = true;
-            const auto versionDiff = myPackage->compareVersion(*updatePackage);
+            const auto versionDiff = package->compareVersion(*updatePackage);
             std::vector<PackageUpdate> *list = nullptr;
             switch (versionDiff) {
             case PackageVersionComparison::SoftwareUpgrade:
@@ -538,11 +534,11 @@ LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPk
             }
             if (list) {
                 list->emplace_back(
-                    PackageSearchResult(*this, myPackage, myPackageID), PackageSearchResult(*updateSource, updatePackage, updatePackageID));
+                    PackageSearchResult(*this, package, myPackageID), PackageSearchResult(*updateSource, updatePackage, updatePackageID));
             }
         }
         if (!foundPackage) {
-            results.orphans.emplace_back(PackageSearchResult(*this, myPackage, myPackageID));
+            results.orphans.emplace_back(PackageSearchResult(*this, package, myPackageID));
         }
         if (regularName.empty()) {
             return false;
@@ -552,7 +548,7 @@ LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPk
             if (!updatePackage) {
                 continue;
             }
-            const auto versionDiff = myPackage->compareVersion(*updatePackage);
+            const auto versionDiff = package->compareVersion(*updatePackage);
             std::vector<PackageUpdate> *list = nullptr;
             switch (versionDiff) {
             case PackageVersionComparison::SoftwareUpgrade:
@@ -568,7 +564,7 @@ LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPk
             }
             if (list) {
                 list->emplace_back(
-                    PackageSearchResult(*this, myPackage, myPackageID), PackageSearchResult(*updateSource, updatePackage, updatePackageID));
+                    PackageSearchResult(*this, package, myPackageID), PackageSearchResult(*updateSource, updatePackage, updatePackageID));
             }
         }
         return false;
diff --git a/libpkg/data/database.h b/libpkg/data/database.h
index 0b29091..cdc5ff2 100644
--- a/libpkg/data/database.h
+++ b/libpkg/data/database.h
@@ -111,7 +111,7 @@ private:
 };
 
 struct LIBPKG_EXPORT Database : public ReflectiveRapidJSON::JsonSerializable<Database>, public ReflectiveRapidJSON::BinarySerializable<Database> {
-    using PackageVisitor = std::function<bool(StorageID, Package &&)>;
+    using PackageVisitor = std::function<bool(StorageID, const std::shared_ptr<Package> &)>;
 
     friend struct PackageUpdater;
 
diff --git a/libpkg/data/storage.cpp b/libpkg/data/storage.cpp
index 8d25946..5e73873 100644
--- a/libpkg/data/storage.cpp
+++ b/libpkg/data/storage.cpp
@@ -43,8 +43,8 @@ template <typename StorageEntryType> std::size_t StorageCacheEntries<StorageEntr
     return count;
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-auto StorageCache<StorageEntriesType, TransactionType, SpecType>::retrieve(Storage &storage, StorageID storageID) -> SpecType
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+auto StorageCache<StorageEntriesType, StorageType, SpecType>::retrieve(Storage &storage, ROTxn *txn, StorageID storageID) -> SpecType
 {
     // check for package in cache
     const auto ref = typename StorageEntryByID<typename Entries::StorageEntry>::result_type{ storageID, &storage };
@@ -55,8 +55,7 @@ auto StorageCache<StorageEntriesType, TransactionType, SpecType>::retrieve(Stora
     // check for package in storage, populate cache entry
     lock.unlock();
     auto entry = std::make_shared<Entry>();
-    auto txn = storage.packages.getROTransaction();
-    if (auto id = txn.get(storageID, *entry)) {
+    if (auto id = txn ? txn->get(storageID, *entry) : storage.packages.getROTransaction().get(storageID, *entry)) {
         using CacheEntry = typename Entries::StorageEntry;
         using CacheRef = typename Entries::Ref;
         auto newCacheEntry = CacheEntry(CacheRef(storage, entry), id);
@@ -69,8 +68,14 @@ auto StorageCache<StorageEntriesType, TransactionType, SpecType>::retrieve(Stora
     return SpecType(0, std::shared_ptr<Entry>());
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-auto StorageCache<StorageEntriesType, TransactionType, SpecType>::retrieve(Storage &storage, const std::string &entryName) -> SpecType
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+auto StorageCache<StorageEntriesType, StorageType, SpecType>::retrieve(Storage &storage, StorageID storageID) -> SpecType
+{
+    return retrieve(storage, nullptr, storageID);
+}
+
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+auto StorageCache<StorageEntriesType, StorageType, SpecType>::retrieve(Storage &storage, const std::string &entryName) -> SpecType
 {
     // check for package in cache
     using CacheRef = typename Entries::Ref;
@@ -95,9 +100,8 @@ auto StorageCache<StorageEntriesType, TransactionType, SpecType>::retrieve(Stora
     return SpecType(0, std::shared_ptr<Entry>());
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-auto StorageCache<StorageEntriesType, TransactionType, SpecType>::store(Storage &storage, const std::shared_ptr<Entry> &entry, bool force)
-    -> StoreResult
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+auto StorageCache<StorageEntriesType, StorageType, SpecType>::store(Storage &storage, const std::shared_ptr<Entry> &entry, bool force) -> StoreResult
 {
     // check for package in cache
     using CacheEntry = typename Entries::StorageEntry;
@@ -144,9 +148,8 @@ auto StorageCache<StorageEntriesType, TransactionType, SpecType>::store(Storage
     return res;
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-auto StorageCache<StorageEntriesType, TransactionType, SpecType>::store(Storage &storage, Txn &txn, const std::shared_ptr<Entry> &entry)
-    -> StoreResult
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+auto StorageCache<StorageEntriesType, StorageType, SpecType>::store(Storage &storage, RWTxn &txn, const std::shared_ptr<Entry> &entry) -> StoreResult
 {
     // check for package in cache
     using CacheEntry = typename Entries::StorageEntry;
@@ -185,8 +188,8 @@ auto StorageCache<StorageEntriesType, TransactionType, SpecType>::store(Storage
     return res;
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-bool StorageCache<StorageEntriesType, TransactionType, SpecType>::invalidate(Storage &storage, const std::string &entryName)
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+bool StorageCache<StorageEntriesType, StorageType, SpecType>::invalidate(Storage &storage, const std::string &entryName)
 {
     // remove package from cache
     const auto ref = typename Entries::Ref(storage, entryName);
@@ -203,8 +206,8 @@ bool StorageCache<StorageEntriesType, TransactionType, SpecType>::invalidate(Sto
     return false;
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-void StorageCache<StorageEntriesType, TransactionType, SpecType>::clear(Storage &storage)
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+void StorageCache<StorageEntriesType, StorageType, SpecType>::clear(Storage &storage)
 {
     clearCacheOnly(storage);
     auto packagesTxn = storage.packages.getRWTransaction();
@@ -224,8 +227,8 @@ void StorageCache<StorageEntriesType, TransactionType, SpecType>::clear(Storage
     requiredLibsTxn.commit();
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType>
-void StorageCache<StorageEntriesType, TransactionType, SpecType>::clearCacheOnly(Storage &storage)
+template <typename StorageEntriesType, typename StorageType, typename SpecType>
+void StorageCache<StorageEntriesType, StorageType, SpecType>::clearCacheOnly(Storage &storage)
 {
     const auto lock = std::unique_lock(m_mutex);
     m_entries.clear(storage);
@@ -234,7 +237,7 @@ void StorageCache<StorageEntriesType, TransactionType, SpecType>::clearCacheOnly
 template struct StorageCacheRef<DatabaseStorage, Package>;
 template struct StorageCacheEntry<PackageCacheRef, Package>;
 template class StorageCacheEntries<PackageCacheEntry>;
-template struct StorageCache<PackageCacheEntries, PackageStorage::RWTransaction, PackageSpec>;
+template struct StorageCache<PackageCacheEntries, PackageStorage, PackageSpec>;
 
 StorageDistribution::StorageDistribution(const char *path, std::uint32_t maxDbs)
 {
diff --git a/libpkg/data/storageprivate.h b/libpkg/data/storageprivate.h
index 9f2f6d1..29ac416 100644
--- a/libpkg/data/storageprivate.h
+++ b/libpkg/data/storageprivate.h
@@ -136,10 +136,11 @@ template <typename StorageEntryType> inline auto StorageCacheEntries<StorageEntr
     return m_entries.end();
 }
 
-template <typename StorageEntriesType, typename TransactionType, typename SpecType> struct StorageCache {
+template <typename StorageEntriesType, typename StorageType, typename SpecType> struct StorageCache {
     using Entries = StorageEntriesType;
     using Entry = typename Entries::Entry;
-    using Txn = TransactionType;
+    using ROTxn = typename StorageType::ROTransaction;
+    using RWTxn = typename StorageType::RWTransaction;
     using Storage = typename Entries::Storage;
     struct StoreResult {
         StorageID id = 0;
@@ -147,10 +148,11 @@ template <typename StorageEntriesType, typename TransactionType, typename SpecTy
         std::shared_ptr<typename Entries::Entry> oldEntry;
     };
 
+    SpecType retrieve(Storage &storage, ROTxn *, StorageID storageID);
     SpecType retrieve(Storage &storage, StorageID storageID);
     SpecType retrieve(Storage &storage, const std::string &entryName);
     StoreResult store(Storage &storage, const std::shared_ptr<Entry> &entry, bool force);
-    StoreResult store(Storage &storage, Txn &txn, const std::shared_ptr<Entry> &entry);
+    StoreResult store(Storage &storage, RWTxn &txn, const std::shared_ptr<Entry> &entry);
     bool invalidate(Storage &storage, const std::string &entryName);
     void clear(Storage &storage);
     void clearCacheOnly(Storage &storage);
@@ -168,12 +170,12 @@ using PackageCacheRef = StorageCacheRef<DatabaseStorage, Package>;
 using PackageCacheEntry = StorageCacheEntry<PackageCacheRef, Package>;
 using PackageCacheEntries = StorageCacheEntries<PackageCacheEntry>;
 using PackageCacheEntryByID = typename PackageCacheEntries::ByID::result_type;
-using PackageCache = StorageCache<PackageCacheEntries, PackageStorage::RWTransaction, PackageSpec>;
+using PackageCache = StorageCache<PackageCacheEntries, PackageStorage, PackageSpec>;
 
 extern template struct StorageCacheRef<DatabaseStorage, Package>;
 extern template struct StorageCacheEntry<PackageCacheRef, Package>;
 extern template class StorageCacheEntries<PackageCacheEntry>;
-extern template struct StorageCache<PackageCacheEntries, PackageStorage::RWTransaction, PackageSpec>;
+extern template struct StorageCache<PackageCacheEntries, PackageStorage, PackageSpec>;
 
 struct StorageDistribution {
     explicit StorageDistribution(const char *path, std::uint32_t maxDbs);
diff --git a/librepomgr/buildactions/conductbuild.cpp b/librepomgr/buildactions/conductbuild.cpp
index 7b6aed1..4b47ff0 100644
--- a/librepomgr/buildactions/conductbuild.cpp
+++ b/librepomgr/buildactions/conductbuild.cpp
@@ -1520,31 +1520,31 @@ PackageStagingNeeded ConductBuild::checkWhetherStagingIsNeededAndPopulateRebuild
             const auto &removedDependencyName = removedDependency.first;
             const auto &removedDependencyDetail = removedDependency.second;
             db->providingPackages(LibPkg::Dependency(removedDependencyName, removedDependencyDetail.version, removedDependencyDetail.mode), true,
-                [&](LibPkg::StorageID, LibPkg::Package &&affectedPackage) {
-                    if (isDestinationDb && isPackageWeWantToUpdateItself(affectedPackage)) {
+                [&](LibPkg::StorageID, const std::shared_ptr<LibPkg::Package> &affectedPackage) {
+                    if (isDestinationDb && isPackageWeWantToUpdateItself(*affectedPackage)) {
                         return false; // skip if that's just the package we want to update itself
                     }
                     if (!rebuildInfoForDb) {
                         rebuildInfoForDb = &m_buildProgress.rebuildList[db->name];
                     }
                     needsStaging = true;
-                    (*rebuildInfoForDb)[affectedPackage.name].provides.emplace_back(
+                    (*rebuildInfoForDb)[affectedPackage->name].provides.emplace_back(
                         removedDependencyName, removedDependencyDetail.version, removedDependencyDetail.mode);
-                    listOfAffectedPackages.emplace_back(db->name % '/' + affectedPackage.name);
+                    listOfAffectedPackages.emplace_back(db->name % '/' + affectedPackage->name);
                     return false;
                 });
         }
         for (const auto &removedLibProvide : removedLibProvides) {
-            db->providingPackages(removedLibProvide, true, [&](LibPkg::StorageID, LibPkg::Package &&affectedPackage) {
-                if (isDestinationDb && isPackageWeWantToUpdateItself(affectedPackage)) {
+            db->providingPackages(removedLibProvide, true, [&](LibPkg::StorageID, const std::shared_ptr<LibPkg::Package> &affectedPackage) {
+                if (isDestinationDb && isPackageWeWantToUpdateItself(*affectedPackage)) {
                     return false; // skip if that's just the package we want to update itself
                 }
                 if (!rebuildInfoForDb) {
                     rebuildInfoForDb = &m_buildProgress.rebuildList[db->name];
                 }
                 needsStaging = true;
-                (*rebuildInfoForDb)[affectedPackage.name].libprovides.emplace_back(removedLibProvide);
-                listOfAffectedPackages.emplace_back(db->name % '/' + affectedPackage.name);
+                (*rebuildInfoForDb)[affectedPackage->name].libprovides.emplace_back(removedLibProvide);
+                listOfAffectedPackages.emplace_back(db->name % '/' + affectedPackage->name);
                 return false;
             });
         }
diff --git a/librepomgr/buildactions/reloadlibrarydependencies.cpp b/librepomgr/buildactions/reloadlibrarydependencies.cpp
index c70868c..ba54c64 100644
--- a/librepomgr/buildactions/reloadlibrarydependencies.cpp
+++ b/librepomgr/buildactions/reloadlibrarydependencies.cpp
@@ -85,9 +85,8 @@ void ReloadLibraryDependencies::run()
             }
         }
         for (auto *const destinationDb : m_destinationDbs) {
-            destinationDb->allPackages([&, this](LibPkg::StorageID, LibPkg::Package &&package) {
-                m_setup.config.pullDependentPackages(
-                    std::make_shared<LibPkg::Package>(std::move(package)), relevantDbs, relevantPkgs, missingDeps, visitedPackages);
+            destinationDb->allPackages([&, this](LibPkg::StorageID, const std::shared_ptr<LibPkg::Package> &package) {
+                m_setup.config.pullDependentPackages(package, relevantDbs, relevantPkgs, missingDeps, visitedPackages);
                 return false;
             });
         }
@@ -104,20 +103,20 @@ void ReloadLibraryDependencies::run()
     for (auto *const db : relevantDbs) {
         const auto isDestinationDb = m_destinationDbs.empty() || m_destinationDbs.find(db) != m_destinationDbs.end();
         auto &relevantDbInfo = m_relevantPackagesByDatabase.emplace_back(DatabaseToConsider{ .name = db->name, .arch = db->arch });
-        db->allPackages([&](LibPkg::StorageID packageID, LibPkg::Package &&package) {
+        db->allPackages([&](LibPkg::StorageID packageID, const std::shared_ptr<LibPkg::Package> &package) {
             // allow aborting the build action
             if (reportAbortedIfAborted()) {
                 return true;
             }
             // skip if package should be excluded
-            if (!packageExcludeRegexValue.empty() && std::regex_match(package.name, packageExcludeRegex)) {
-                m_messages.notes.emplace_back(db->name % '/' % package.name + ": matches exclude regex");
+            if (!packageExcludeRegexValue.empty() && std::regex_match(package->name, packageExcludeRegex)) {
+                m_messages.notes.emplace_back(db->name % '/' % package->name + ": matches exclude regex");
                 return false;
             }
             // skip if the package info is missing (we need the binary package's file name here)
-            const auto &packageInfo = package.packageInfo;
+            const auto &packageInfo = package->packageInfo;
             if (!packageInfo) {
-                m_messages.errors.emplace_back(db->name % '/' % package.name + ": no package info");
+                m_messages.errors.emplace_back(db->name % '/' % package->name + ": no package info");
                 return false;
             }
             // skip the package if it is not part of the destination DB or required by a package of the destination DB
@@ -125,7 +124,7 @@ void ReloadLibraryDependencies::run()
                 if (m_skippingNote.tellp()) {
                     m_skippingNote << ", ";
                 }
-                m_skippingNote << db->name << '/' << package.name;
+                m_skippingNote << db->name << '/' << package->name;
                 return false;
             }
             // find the package on disk; otherwise add an URL to download it from the configured mirror
@@ -162,16 +161,16 @@ void ReloadLibraryDependencies::run()
                 }
             }
             if (path.empty()) {
-                m_messages.errors.emplace_back(db->name % '/' % package.name + ": binary package not found and no mirror configured");
+                m_messages.errors.emplace_back(db->name % '/' % package->name + ": binary package not found and no mirror configured");
                 return false;
             }
             // skip if the package info has already been loaded from package contents and the present binary package is not newer
             auto lastModified = DateTime();
             if (url.empty()) {
                 lastModified = LibPkg::lastModified(path);
-                if (!force && package.origin == LibPkg::PackageOrigin::PackageContents && package.timestamp >= lastModified) {
-                    m_messages.notes.emplace_back(db->name % '/' % package.name % ": skipping because \"" % path % "\" is newer ("
-                            % package.timestamp.toString() % " >= " % lastModified.toString()
+                if (!force && package->origin == LibPkg::PackageOrigin::PackageContents && package->timestamp >= lastModified) {
+                    m_messages.notes.emplace_back(db->name % '/' % package->name % ": skipping because \"" % path % "\" is newer ("
+                            % package->timestamp.toString() % " >= " % lastModified.toString()
                         + ")\n");
                     return false;
                 }
@@ -180,11 +179,11 @@ void ReloadLibraryDependencies::run()
             auto &relevantPkg = relevantDbInfo.packages.emplace_back(
                 PackageToConsider{ .path = std::move(path), .url = std::move(url), .lastModified = lastModified });
             // create a temporary package object to hold the info parsed from the .PKGINFO file
-            relevantPkg.info.name = package.name;
+            relevantPkg.info.name = package->name;
             // -> assign certain fields which are used by addDepsAndProvidesFromOtherPackage() to check whether the packages are matching
-            relevantPkg.info.version = package.version;
+            relevantPkg.info.version = package->version;
             relevantPkg.info.packageInfo = std::make_unique<LibPkg::PackageInfo>();
-            relevantPkg.info.packageInfo->buildDate = package.packageInfo->buildDate;
+            relevantPkg.info.packageInfo->buildDate = package->packageInfo->buildDate;
             // -> gather source info such as make and check dependencies as well
             relevantPkg.info.sourceInfo = std::make_shared<LibPkg::SourceInfo>();
             ++m_remainingPackages;
diff --git a/librepomgr/buildactions/repomanagement.cpp b/librepomgr/buildactions/repomanagement.cpp
index 6a2b729..fe4012c 100644
--- a/librepomgr/buildactions/repomanagement.cpp
+++ b/librepomgr/buildactions/repomanagement.cpp
@@ -444,21 +444,21 @@ void CheckForProblems::run()
                 problems.emplace_back(
                     RepositoryProblem{ .desc = "configured local package directory \"" % db->localPkgDir + "\" is not a directory" });
             }
-            db->allPackages([&](LibPkg::StorageID, LibPkg::Package &&package) {
-                if (!package.packageInfo) {
-                    problems.emplace_back(RepositoryProblem{ .desc = "no package info present", .pkg = package.name });
+            db->allPackages([&](LibPkg::StorageID, const std::shared_ptr<LibPkg::Package> &package) {
+                if (!package->packageInfo) {
+                    problems.emplace_back(RepositoryProblem{ .desc = "no package info present", .pkg = package->name });
                     return false;
                 }
-                const auto packageLocation = db->locatePackage(package.packageInfo->fileName);
+                const auto packageLocation = db->locatePackage(package->packageInfo->fileName);
                 if (!packageLocation.exists) {
                     problems.emplace_back(
-                        RepositoryProblem{ .desc = "binary package \"" % package.packageInfo->fileName + "\" not present", .pkg = package.name });
+                        RepositoryProblem{ .desc = "binary package \"" % package->packageInfo->fileName + "\" not present", .pkg = package->name });
                 }
                 if (m_requirePackageSignatures) {
-                    const auto signatureLocation = db->locatePackage(package.packageInfo->fileName + ".sig");
+                    const auto signatureLocation = db->locatePackage(package->packageInfo->fileName + ".sig");
                     if (!signatureLocation.exists) {
                         problems.emplace_back(RepositoryProblem{
-                            .desc = "signature file for package \"" % package.packageInfo->fileName + "\" not present", .pkg = package.name });
+                            .desc = "signature file for package \"" % package->packageInfo->fileName + "\" not present", .pkg = package->name });
                     }
                 }
                 return false;
diff --git a/librepomgr/serversetup.cpp b/librepomgr/serversetup.cpp
index 68a8733..11358b6 100644
--- a/librepomgr/serversetup.cpp
+++ b/librepomgr/serversetup.cpp
@@ -399,13 +399,13 @@ RAPIDJSON_NAMESPACE::Document ServiceSetup::libraryDependenciesToJson()
     auto &alloc = document.GetAllocator();
     for (auto &db : config.databases) {
         auto dbValue = RAPIDJSON_NAMESPACE::Value(RAPIDJSON_NAMESPACE::Type::kObjectType);
-        db.allPackages([&](StorageID, Package &&package) {
-            if (!package.packageInfo) {
+        db.allPackages([&](StorageID, const std::shared_ptr<Package> &package) {
+            if (!package->packageInfo) {
                 return false;
             }
-            if (package.libdepends.empty() && package.libprovides.empty()) {
+            if (package->libdepends.empty() && package->libprovides.empty()) {
                 auto hasVersionedPythonOrPerlDep = false;
-                for (const auto &dependency : package.dependencies) {
+                for (const auto &dependency : package->dependencies) {
                     if (dependency.mode == DependencyMode::Any || dependency.version.empty()
                         || (dependency.name != "python" && dependency.name != "python2" && dependency.name != "perl")) {
                         return false;
@@ -419,12 +419,12 @@ RAPIDJSON_NAMESPACE::Document ServiceSetup::libraryDependenciesToJson()
             }
             auto pkgValue = RAPIDJSON_NAMESPACE::Value(RAPIDJSON_NAMESPACE::Type::kObjectType);
             auto pkgObj = pkgValue.GetObject();
-            JR::push(package.version, "v", pkgObj, alloc);
-            JR::push(package.packageInfo->buildDate, "t", pkgObj, alloc);
-            JR::push(package.dependencies, "d", pkgObj, alloc); // for versioned Python/Perl deps
-            JR::push(package.libdepends, "ld", pkgObj, alloc);
-            JR::push(package.libprovides, "lp", pkgObj, alloc);
-            dbValue.AddMember(RAPIDJSON_NAMESPACE::StringRef(package.name.data(), JR::rapidJsonSize(package.name.size())), pkgValue, alloc);
+            JR::push(package->version, "v", pkgObj, alloc);
+            JR::push(package->packageInfo->buildDate, "t", pkgObj, alloc);
+            JR::push(package->dependencies, "d", pkgObj, alloc); // for versioned Python/Perl deps
+            JR::push(package->libdepends, "ld", pkgObj, alloc);
+            JR::push(package->libprovides, "lp", pkgObj, alloc);
+            dbValue.AddMember(RAPIDJSON_NAMESPACE::StringRef(package->name.data(), JR::rapidJsonSize(package->name.size())), pkgValue, alloc);
             return false;
         });
         document.AddMember(RAPIDJSON_NAMESPACE::Value(db.name % '@' + db.arch, alloc), dbValue, alloc);
diff --git a/librepomgr/tests/buildactions.cpp b/librepomgr/tests/buildactions.cpp
index 6d4f0dc..483c507 100644
--- a/librepomgr/tests/buildactions.cpp
+++ b/librepomgr/tests/buildactions.cpp
@@ -149,8 +149,8 @@ void BuildActionsTests::logTestSetup()
 {
     for (auto &db : m_setup.config.databases) {
         cout << EscapeCodes::Phrases::Info << "Packages of " << db.name << ':' << EscapeCodes::Phrases::End;
-        db.allPackages([](LibPkg::StorageID, LibPkg::Package &&package) {
-            cout << " - " << package.name << '\n';
+        db.allPackages([](LibPkg::StorageID, const std::shared_ptr<LibPkg::Package> &package) {
+            cout << " - " << package->name << '\n';
             return false;
         });
     }
diff --git a/librepomgr/webclient/aur.cpp b/librepomgr/webclient/aur.cpp
index 540d802..6ce6791 100644
--- a/librepomgr/webclient/aur.cpp
+++ b/librepomgr/webclient/aur.cpp
@@ -169,9 +169,9 @@ std::shared_ptr<AurQuerySession> queryAurPackagesForDatabase(LogContext &log, Se
         configReadLock = &ownConfigReadLock;
     }
     auto &aurDb = setup.config.aur;
-    database.allPackages([&aurDb, &missingPackages](StorageID, Package &&package) {
-        if (const auto aurPackage = aurDb.findPackage(package.name); !aurPackage) {
-            missingPackages.emplace_back(package.name);
+    database.allPackages([&aurDb, &missingPackages](StorageID, const std::shared_ptr<Package> &package) {
+        if (const auto aurPackage = aurDb.findPackage(package->name); !aurPackage) {
+            missingPackages.emplace_back(package->name);
         }
         return false;
     });
diff --git a/pacfind/main.cpp b/pacfind/main.cpp
index 1b58558..2d3dbd1 100644
--- a/pacfind/main.cpp
+++ b/pacfind/main.cpp
@@ -131,8 +131,8 @@ int main(int argc, const char *argv[])
         }
     }
     for (auto &db : cfg.databases) {
-        db.allPackages([&](LibPkg::StorageID, LibPkg::Package &&package) {
-            const auto &pkgInfo = package.packageInfo;
+        db.allPackages([&](LibPkg::StorageID, const std::shared_ptr<LibPkg::Package> &package) {
+            const auto &pkgInfo = package->packageInfo;
             if (!pkgInfo) {
                 return false;
             }
@@ -154,7 +154,7 @@ int main(int argc, const char *argv[])
                     if (!db.name.empty()) {
                         std::cout << db.name << '/';
                     }
-                    std::cout << package.name << '\n';
+                    std::cout << package->name << '\n';
                     foundOne = true;
                 }
                 std::cout << " - " << file << '\n';
@@ -163,7 +163,7 @@ int main(int argc, const char *argv[])
                 if (!db.name.empty()) {
                     std::cout << db.name << '/';
                 }
-                std::cout << package.name << '\n';
+                std::cout << package->name << '\n';
             }
             return false;
         });