diff --git a/include/cppship/cmake/dependency_injector.h b/include/cppship/cmake/dependency_injector.h
index c618c15..bf812ea 100644
--- a/include/cppship/cmake/dependency_injector.h
+++ b/include/cppship/cmake/dependency_injector.h
@@ -2,6 +2,7 @@
 
 #include <ostream>
 
+#include "cppship/core/dependency.h"
 #include "cppship/core/manifest.h"
 #include "cppship/util/class.h"
 
@@ -18,7 +19,22 @@ class DependencyInjector {
 
 class CmakeDependencyInjector : public DependencyInjector {
 public:
+    CmakeDependencyInjector(const fs::path& deps_dir, const std::vector<DeclaredDependency>& declared_deps,
+        const ResolvedDependencies& cppship_deps, const ResolvedDependencies& all_deps)
+        : mDepsDir(deps_dir)
+        , mDeclaredDeps(declared_deps)
+        , mCppshipDeps(cppship_deps)
+        , mAllDeps(all_deps)
+    {
+    }
+
     void inject(std::ostream& out, const Manifest& manifest) override;
+
+private:
+    fs::path mDepsDir;
+    std::vector<DeclaredDependency> mDeclaredDeps;
+    ResolvedDependencies mCppshipDeps;
+    ResolvedDependencies mAllDeps;
 };
 
 }
\ No newline at end of file
diff --git a/include/cppship/cmake/lib.h b/include/cppship/cmake/lib.h
index fd29166..4c601fe 100644
--- a/include/cppship/cmake/lib.h
+++ b/include/cppship/cmake/lib.h
@@ -12,6 +12,7 @@ namespace cppship::cmake {
 
 struct LibDesc {
     std::string name;
+    std::optional<std::string> name_alias;
     std::set<fs::path> include_dirs;
     std::set<fs::path> sources;
     std::vector<Dep> deps;
@@ -30,6 +31,7 @@ class CmakeLib {
 
 private:
     std::string mName;
+    std::optional<std::string> mNameAlias;
     std::set<std::string> mIncludes;
     std::set<std::string> mSources;
     std::vector<Dep> mDeps;
diff --git a/include/cppship/cmake/package_configurer.h b/include/cppship/cmake/package_configurer.h
new file mode 100644
index 0000000..de6717b
--- /dev/null
+++ b/include/cppship/cmake/package_configurer.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "cppship/core/dependency.h"
+#include "cppship/util/fs.h"
+
+#include <functional>
+
+namespace cppship::cmake {
+
+struct ConfigOptions {
+    fs::path deps_dir;
+    fs::path out_dir = deps_dir;
+    std::string cmake_deps_dir = "${CMAKE_SOURCE_DIR}/deps";
+    std::function<void(std::string&)> post_process;
+};
+
+void config_packages(
+    const ResolvedDependencies& cppship_deps, const ResolvedDependencies& all_deps, const ConfigOptions& options);
+
+}
\ No newline at end of file
diff --git a/include/cppship/core/dependency.h b/include/cppship/core/dependency.h
index 56e43b3..dd6ef1e 100644
--- a/include/cppship/core/dependency.h
+++ b/include/cppship/core/dependency.h
@@ -3,6 +3,7 @@
 #include <map>
 #include <string>
 #include <string_view>
+#include <variant>
 #include <vector>
 
 #include <toml.hpp>
@@ -11,6 +12,28 @@
 
 namespace cppship {
 
+struct ConanDep {
+    std::string version;
+    std::unordered_map<std::string, std::string> options;
+};
+
+struct GitDep {
+    std::string git;
+    std::string commit;
+};
+
+using DependencyDesc = std::variant<ConanDep, GitDep>;
+
+struct DeclaredDependency {
+    std::string package;
+    std::vector<std::string> components;
+    DependencyDesc desc;
+
+    bool is_conan() const { return std::holds_alternative<ConanDep>(desc); }
+
+    bool is_git() const { return std::holds_alternative<GitDep>(desc); }
+};
+
 struct Dependency {
     std::string package;
     std::string cmake_package;
diff --git a/include/cppship/core/manifest.h b/include/cppship/core/manifest.h
index 476d0fc..1a3e458 100644
--- a/include/cppship/core/manifest.h
+++ b/include/cppship/core/manifest.h
@@ -4,34 +4,16 @@
 #include <string>
 #include <string_view>
 #include <unordered_map>
-#include <variant>
 #include <vector>
 
 #include <fmt/format.h>
 
+#include "cppship/core/dependency.h"
 #include "cppship/core/profile.h"
 #include "cppship/util/fs.h"
 
 namespace cppship {
 
-struct ConanDep {
-    std::string version;
-    std::unordered_map<std::string, std::string> options;
-};
-
-struct GitHeaderOnlyDep {
-    std::string git;
-    std::string commit;
-};
-
-using DependencyDesc = std::variant<ConanDep, GitHeaderOnlyDep>;
-
-struct DeclaredDependency {
-    std::string package;
-    std::vector<std::string> components;
-    DependencyDesc desc;
-};
-
 enum class CxxStd { cxx11 = 11, cxx14 = 14, cxx17 = 17, cxx20 = 20, cxx23 = 23 };
 
 inline constexpr auto format_as(CxxStd std) { return fmt::underlying(std); }
diff --git a/lib/cmake/dependency_injector.cpp b/lib/cmake/dependency_injector.cpp
index ef60a4d..ee33942 100644
--- a/lib/cmake/dependency_injector.cpp
+++ b/lib/cmake/dependency_injector.cpp
@@ -1,12 +1,13 @@
 #include "cppship/cmake/dependency_injector.h"
+#include "cppship/cmake/package_configurer.h"
 #include "cppship/util/fs.h"
 #include "cppship/util/io.h"
 
 #include <boost/algorithm/cxx11/any_of.hpp>
+#include <boost/algorithm/string/replace.hpp>
 #include <fmt/format.h>
 #include <fmt/os.h>
 #include <range/v3/range/conversion.hpp>
-#include <range/v3/view/concat.hpp>
 #include <range/v3/view/filter.hpp>
 
 using namespace cppship;
@@ -258,16 +259,19 @@ void inject_conan_deps(std::ostream& out)
     out << "include(cmake/conan.cmake)\n";
 }
 
-void inject_git_deps(std::ostream& out, const std::vector<DeclaredDependency>& deps)
+void inject_git_deps(std::ostream& out, const fs::path& deps_dir, const std::vector<DeclaredDependency>& deps,
+    const ResolvedDependencies& cppship_deps, const ResolvedDependencies& all_deps)
 {
     const fs::path cmake_util_dir = "cmake";
     create_if_not_exist(cmake_util_dir);
 
+    static constexpr std::string_view kCmakeDepsDir = "${CMAKE_BINARY_DIR}/deps";
+
     auto oss = fmt::output_file((cmake_util_dir / "deps.cmake").string());
     oss.print("include(FetchContent)\n\n");
 
     for (const auto& dep : deps) {
-        const auto& desc = get<GitHeaderOnlyDep>(dep.desc);
+        const auto& desc = get<GitDep>(dep.desc);
 
         oss.print(R"(# Dep for {package}
 FetchContent_Declare({package}
@@ -276,11 +280,10 @@ FetchContent_Declare({package}
     SOURCE_DIR "{deps_dir}/{package}"
 )
 FetchContent_MakeAvailable({package})
-message("-- Deps: download {package} from {git}:{commit}")
+message("-- Deps: download {package} from {git}::{commit}")
 
 )",
-            "package"_a = dep.package, "git"_a = desc.git, "commit"_a = desc.commit,
-            "deps_dir"_a = "${CMAKE_BINARY_DIR}/deps");
+            "package"_a = dep.package, "git"_a = desc.git, "commit"_a = desc.commit, "deps_dir"_a = kCmakeDepsDir);
     }
 
     // commit file
@@ -288,40 +291,38 @@ message("-- Deps: download {package} from {git}:{commit}")
     oss.print("\n");
     oss.close();
 
-    for (const auto& dep : deps) {
-        write(cmake_util_dir / fmt::format("{}-config.cmake", dep.package),
-            fmt::format(R"(# export {package}
-add_library(cppship::{package} INTERFACE IMPORTED)
-target_include_directories(cppship::{package} INTERFACE ${{CMAKE_BINARY_DIR}}/deps/{package}/include)
-)",
-                "package"_a = dep.package));
-    }
+    auto content_fix
+        = [deps_dir = deps_dir.string()](std::string& str) { boost::replace_all(str, deps_dir, kCmakeDepsDir); };
+    cmake::config_packages(cppship_deps, all_deps,
+        {
+            .deps_dir = deps_dir,
+            .out_dir = cmake_util_dir,
+            .cmake_deps_dir = std::string { kCmakeDepsDir },
+            .post_process = std::move(content_fix),
+        });
 
     out << "include(cmake/deps.cmake)\n";
 }
 
 }
 
-void CmakeDependencyInjector::inject(std::ostream& out, const Manifest& manifest)
+void CmakeDependencyInjector::inject(std::ostream& out, const Manifest&)
 {
-    const auto deps = concat(manifest.dependencies(), manifest.dev_dependencies());
-    if (deps.empty()) {
+    if (mDeclaredDeps.empty()) {
         return;
     }
 
-    const auto has_conan_deps
-        = any_of(deps, [](const DeclaredDependency& dep) { return std::holds_alternative<ConanDep>(dep.desc); });
-    const auto has_git_deps = any_of(
-        deps, [](const DeclaredDependency& dep) { return std::holds_alternative<GitHeaderOnlyDep>(dep.desc); });
+    const auto has_conan_deps = any_of(mDeclaredDeps, [](const DeclaredDependency& dep) { return dep.is_conan(); });
 
     out << "\n# Dependency management\n";
     if (has_conan_deps) {
         inject_conan_deps(out);
     }
 
-    if (has_git_deps) {
-        inject_git_deps(out, deps | filter([](const DeclaredDependency& dep) {
-            return std::holds_alternative<GitHeaderOnlyDep>(dep.desc);
-        }) | ranges::to<std::vector<DeclaredDependency>>());
+    if (!mCppshipDeps.empty()) {
+        const auto declared_cppship_deps = mDeclaredDeps
+            | filter([](const DeclaredDependency& dep) { return dep.is_git(); })
+            | ranges::to<std::vector<DeclaredDependency>>();
+        inject_git_deps(out, mDepsDir, declared_cppship_deps, mCppshipDeps, mAllDeps);
     }
 }
\ No newline at end of file
diff --git a/lib/cmake/generator.cpp b/lib/cmake/generator.cpp
index 5166a3f..9160a13 100644
--- a/lib/cmake/generator.cpp
+++ b/lib/cmake/generator.cpp
@@ -167,6 +167,7 @@ void CmakeGenerator::add_lib_sources_()
 
     cmake::CmakeLib lib({
         .name = target->name,
+        .name_alias = target->name,
         .include_dirs = target->includes,
         .sources = target->sources,
         .deps = mDeps,
diff --git a/lib/cmake/lib.cpp b/lib/cmake/lib.cpp
index c169c51..56f4bfe 100644
--- a/lib/cmake/lib.cpp
+++ b/lib/cmake/lib.cpp
@@ -21,6 +21,7 @@ std::set<std::string> to_strings(const std::set<fs::path>& paths)
 
 CmakeLib::CmakeLib(LibDesc desc)
     : mName(std::move(desc.name))
+    , mNameAlias(std::move(desc.name_alias))
     , mIncludes(to_strings(desc.include_dirs))
     , mSources(to_strings(desc.sources))
     , mDeps(desc.deps)
@@ -38,7 +39,10 @@ void CmakeLib::build(std::ostream& out) const
     } else {
         out << fmt::format("add_library({} {})\n", lib_name, boost::join(mSources, "\n"));
     }
-    out << fmt::format(R"(set_target_properties({} PROPERTIES OUTPUT_NAME "{}"))", lib_name, mName) << '\n';
+
+    if (mNameAlias) {
+        out << fmt::format(R"(set_target_properties({} PROPERTIES OUTPUT_NAME "{}"))", lib_name, *mNameAlias) << '\n';
+    }
 
     const std::string_view lib_type = is_interface() ? "INTERFACE" : "PUBLIC";
     if (!mIncludes.empty()) {
diff --git a/lib/cmake/package_configurer.cpp b/lib/cmake/package_configurer.cpp
new file mode 100644
index 0000000..7d25b2f
--- /dev/null
+++ b/lib/cmake/package_configurer.cpp
@@ -0,0 +1,58 @@
+#include "cppship/cmake/package_configurer.h"
+#include "cppship/cmake/lib.h"
+#include "cppship/core/layout.h"
+#include "cppship/core/manifest.h"
+#include "cppship/util/io.h"
+#include "cppship/util/repo.h"
+
+#include <fmt/core.h>
+#include <fmt/format.h>
+
+using namespace cppship;
+using namespace fmt::literals;
+
+void cmake::config_packages(
+    const ResolvedDependencies& cppship_deps, const ResolvedDependencies& all_deps, const ConfigOptions& options)
+{
+    for (const auto& [package, dep] : cppship_deps) {
+        const auto& cmake_target = dep.cmake_target;
+        const auto package_dir = options.deps_dir / package;
+        const auto package_manifest = package_dir / kRepoConfigFile;
+        const auto package_cmake_config_file = options.out_dir / fmt::format("{}-config.cmake", package);
+
+        if (!fs::exists(package_manifest)) {
+            write(package_cmake_config_file,
+                fmt::format(R"(# header only lib config generated by cppship
+add_library({target} INTERFACE IMPORTED)
+target_include_directories({target} INTERFACE {cmake_deps_dir}/{package}/include)
+)",
+                    "target"_a = cmake_target, "package"_a = dep.package, "cmake_deps_dir"_a = options.cmake_deps_dir));
+
+            continue;
+        }
+
+        Manifest manifest(package_manifest);
+        Layout layout(package_dir, package);
+        const auto lib_target = *layout.lib();
+        const auto cmake_deps = cmake::collect_cmake_deps(manifest.dependencies(), all_deps);
+        cmake::CmakeLib lib({
+            .name = lib_target.name,
+            .include_dirs = lib_target.includes,
+            .sources = lib_target.sources,
+            .deps = cmake_deps,
+            .definitions = manifest.default_profile().definitions,
+        });
+
+        std::ostringstream out;
+        lib.build(out);
+
+        out << fmt::format("\nadd_library({} ALIAS {})\n", cmake_target, lib.target());
+
+        auto content = out.str();
+        if (const auto& func = options.post_process) {
+            func(content);
+        }
+
+        write(package_cmake_config_file, content);
+    }
+}
\ No newline at end of file
diff --git a/lib/cmd/build.cpp b/lib/cmd/build.cpp
index a13203f..f609467 100644
--- a/lib/cmd/build.cpp
+++ b/lib/cmd/build.cpp
@@ -1,7 +1,7 @@
 #include "cppship/cmd/build.h"
 #include "cppship/cmake/generator.h"
 #include "cppship/cmake/group.h"
-#include "cppship/cmake/lib.h"
+#include "cppship/cmake/package_configurer.h"
 #include "cppship/core/compiler.h"
 #include "cppship/core/dependency.h"
 #include "cppship/core/resolver.h"
@@ -207,41 +207,7 @@ void cmd::conan_install(const BuildContext& ctx)
 void cmd::cppship_install(
     const BuildContext& ctx, const ResolvedDependencies& cppship_deps, const ResolvedDependencies& all_deps)
 {
-    for (const auto& [package, dep] : cppship_deps) {
-        const auto cmake_target = fmt::format("cppship::{}", dep.package);
-        const auto package_dir = ctx.deps_dir / package;
-        const auto package_manifest = package_dir / kRepoConfigFile;
-        const auto package_cmake_config_file = ctx.deps_dir / fmt::format("{}-config.cmake", package);
-
-        if (!fs::exists(package_manifest)) {
-            write(package_cmake_config_file,
-                fmt::format(R"(# header only lib config generated by cppship
-add_library({target} INTERFACE IMPORTED)
-target_include_directories({target} INTERFACE ${{CMAKE_SOURCE_DIR}}/deps/{package}/include)
-)",
-                    "target"_a = cmake_target, "package"_a = dep.package));
-
-            continue;
-        }
-
-        Manifest manifest(package_manifest);
-        Layout layout(package_dir, package);
-        const auto lib_target = *layout.lib();
-        const auto cmake_deps = cmake::collect_cmake_deps(manifest.dependencies(), all_deps);
-        cmake::CmakeLib lib({
-            .name = lib_target.name,
-            .include_dirs = lib_target.includes,
-            .sources = lib_target.sources,
-            .deps = cmake_deps,
-            .definitions = manifest.default_profile().definitions,
-        });
-
-        std::ostringstream out;
-        lib.build(out);
-
-        out << fmt::format("\nadd_library({} ALIAS {})\n", cmake_target, lib.target());
-        write(package_cmake_config_file, out.str());
-    }
+    cmake::config_packages(cppship_deps, all_deps, { .deps_dir = ctx.deps_dir });
 }
 
 void cmd::cmake_setup(const BuildContext& ctx)
diff --git a/lib/cmd/cmake.cpp b/lib/cmd/cmake.cpp
index 328f629..365200b 100644
--- a/lib/cmd/cmake.cpp
+++ b/lib/cmd/cmake.cpp
@@ -1,6 +1,8 @@
 #include <cstdlib>
 
 #include <boost/algorithm/string/replace.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/view/concat.hpp>
 
 #include "cppship/cmake/generator.h"
 #include "cppship/cmd/build.h"
@@ -11,6 +13,7 @@
 
 using namespace cppship;
 using namespace cppship::cmake;
+using namespace ranges::views;
 
 int cmd::run_cmake(const CmakeOptions&)
 {
@@ -26,11 +29,14 @@ int cmd::run_cmake(const CmakeOptions&)
     const auto result = std::move(resolver).resolve();
 
     ResolvedDependencies deps = toml::get<ResolvedDependencies>(toml::parse(ctx.dependency_file));
+    const auto declared_deps
+        = concat(result.dependencies, result.dev_dependencies) | ranges::to<std::vector<DeclaredDependency>>();
     CmakeGenerator gen(&ctx.layout, ctx.manifest,
         GeneratorOptions {
             .deps = cmake::collect_cmake_deps(result.dependencies, deps),
             .dev_deps = cmake::collect_cmake_deps(result.dev_dependencies, deps),
-            .injector = std::make_unique<CmakeDependencyInjector>(),
+            .injector = std::make_unique<CmakeDependencyInjector>(
+                ctx.deps_dir, declared_deps, result.resolved_dependencies, deps),
         });
     auto script = std::move(gen).build();
 
diff --git a/lib/core/manifest.cpp b/lib/core/manifest.cpp
index 61c822f..47a7595 100644
--- a/lib/core/manifest.cpp
+++ b/lib/core/manifest.cpp
@@ -65,7 +65,7 @@ std::vector<DeclaredDependency> parse_dependencis(const toml::value& manifest, c
             pkg.desc = ConanDep { .version = dep.as_string() };
         } else if (dep.is_table()) {
             if (dep.contains("git")) {
-                GitHeaderOnlyDep desc;
+                GitDep desc;
                 desc.git = find<std::string>(dep, "git");
                 desc.commit = find_or<std::string>(dep, "commit", "");
                 if (desc.git.empty()) {
diff --git a/lib/core/resolver.cpp b/lib/core/resolver.cpp
index 5226b19..aea20cd 100644
--- a/lib/core/resolver.cpp
+++ b/lib/core/resolver.cpp
@@ -50,14 +50,12 @@ cppship::ResolveResult Resolver::resolve() &&
         const auto dep = std::move(mUnresolved.front());
         mUnresolved.pop();
 
-        if (mPackageSeen.contains(dep.package)) {
+        if (const bool existed = !mPackageSeen.insert(dep.package).second; existed) {
             status("resolve", "package {} already seen, skip", dep.package);
             continue;
         }
 
         do_resolve_(dep);
-
-        mPackageSeen.insert(dep.package);
     }
 
     ranges::push_back(mResult.dependencies, mResult.conan_dependencies);
@@ -90,7 +88,7 @@ void verify_git_dependency(const std::string_view package, const fs::path& dep_d
 
 void Resolver::do_resolve_(const DeclaredDependency& dep)
 {
-    const auto& desc = get<GitHeaderOnlyDep>(dep.desc);
+    const auto& desc = get<GitDep>(dep.desc);
     const auto package_dir = mDepsDir / dep.package;
     const auto footprint = fmt::format("{}/cppship.{}", package_dir.string(), desc.commit);
     if (!fs::exists(footprint) && mFetcher) {
@@ -135,7 +133,7 @@ void Resolver::resolve_package_(std::string_view package, const fs::path& packag
             continue;
         }
 
-        if (std::holds_alternative<ConanDep>(sub_dep.desc)) {
+        if (sub_dep.is_conan()) {
             mPackageSeen.insert(sub_dep.package);
             mResult.conan_dependencies.push_back(sub_dep);
             continue;
diff --git a/tests/cmake/lib.cpp b/tests/cmake/lib.cpp
index bf66eb5..ec6aefb 100644
--- a/tests/cmake/lib.cpp
+++ b/tests/cmake/lib.cpp
@@ -28,7 +28,6 @@ TEST(lib, Interface)
         fmt::format(R"(
 # LIB
 add_library(test_lib INTERFACE)
-set_target_properties(test_lib PROPERTIES OUTPUT_NAME "test")
 
 target_include_directories(test_lib INTERFACE {})
 
@@ -67,6 +66,45 @@ TEST(lib, Source)
 # LIB
 add_library(test_lib {0}/a.cpp
 {0}/b.cpp)
+
+target_include_directories(test_lib PUBLIC {1})
+
+target_link_libraries(test_lib PUBLIC pkg1 pkg2)
+
+target_compile_definitions(test_lib PUBLIC A B)
+)",
+            libdir.string(), incdir.string()));
+}
+
+TEST(lib, Alias)
+{
+    const auto dir = fs::temp_directory_path();
+    const auto incdir = dir / kIncludePath;
+    fs::create_directory(incdir);
+
+    const auto libdir = dir / kLibPath;
+    fs::remove_all(libdir);
+    fs::create_directory(libdir);
+    write(libdir / "a.cpp", "");
+    write(libdir / "b.cpp", "");
+
+    CmakeLib lib({
+        .name = "test",
+        .name_alias = "test",
+        .include_dirs = { incdir },
+        .sources = { libdir / "a.cpp", libdir / "b.cpp" },
+        .deps = { { .cmake_package = "pkg", .cmake_targets = { "pkg1", "pkg2" } } },
+        .definitions = { "A", "B" },
+    });
+
+    std::ostringstream oss;
+    lib.build(oss);
+
+    EXPECT_EQ(oss.str(),
+        fmt::format(R"(
+# LIB
+add_library(test_lib {0}/a.cpp
+{0}/b.cpp)
 set_target_properties(test_lib PROPERTIES OUTPUT_NAME "test")
 
 target_include_directories(test_lib PUBLIC {1})
diff --git a/tests/cmake/package_configurer.cpp b/tests/cmake/package_configurer.cpp
new file mode 100644
index 0000000..a72c595
--- /dev/null
+++ b/tests/cmake/package_configurer.cpp
@@ -0,0 +1,166 @@
+#include "cppship/cmake/package_configurer.h"
+#include "cppship/util/fs.h"
+#include "cppship/util/io.h"
+#include "cppship/util/repo.h"
+
+#include <string>
+
+#include <boost/algorithm/string/replace.hpp>
+#include <fmt/core.h>
+#include <gtest/gtest.h>
+
+using namespace cppship;
+using namespace std::string_literals;
+
+TEST(package_configurer, HeaderOnly)
+{
+    const auto package = "test_pack"s;
+    const auto tmpdir = fs::temp_directory_path();
+    const auto deps_dir = tmpdir / "deps";
+    const auto package_dir = deps_dir / package;
+    fs::remove_all(deps_dir);
+
+    fs::create_directory(deps_dir);
+    fs::create_directory(package_dir);
+    fs::create_directory(package_dir / "include");
+
+    cppship::ResolvedDependencies deps { {
+        package,
+        Dependency {
+            .package = package,
+            .cmake_package = package,
+            .cmake_target = fmt::format("cppship::{}", package),
+        },
+    } };
+
+    cmake::config_packages(deps, deps,
+        {
+            .deps_dir = deps_dir,
+            .post_process
+            = [deps_dir](std::string& str) { boost::replace_all(str, deps_dir.string(), "${CMAKE_BINARY_DIR}/deps"); },
+        });
+
+    const auto package_config_file = deps_dir / fmt::format("{}-config.cmake", package);
+    ASSERT_TRUE(fs::exists(package_config_file));
+    ASSERT_EQ(read_as_string(package_config_file), R"(# header only lib config generated by cppship
+add_library(cppship::test_pack INTERFACE IMPORTED)
+target_include_directories(cppship::test_pack INTERFACE ${CMAKE_SOURCE_DIR}/deps/test_pack/include)
+)");
+}
+
+TEST(package_configurer, CppshipHeaderOnly)
+{
+    const auto package = "test_pack"s;
+    const auto tmpdir = fs::temp_directory_path();
+    const auto deps_dir = tmpdir / "deps";
+    const auto package_dir = deps_dir / package;
+    fs::remove_all(deps_dir);
+
+    fs::create_directory(deps_dir);
+    fs::create_directory(package_dir);
+    fs::create_directory(package_dir / "include");
+    write(package_dir / kRepoConfigFile, R"([package]
+name = "test_pack"
+version = "0.1.0"
+
+[dependencies]
+fmt = "9.1.0"
+)");
+
+    cppship::ResolvedDependencies deps { {
+        package,
+        Dependency {
+            .package = package,
+            .cmake_package = package,
+            .cmake_target = fmt::format("cppship::{}", package),
+        },
+    } };
+    cppship::ResolvedDependencies all_deps = deps;
+    all_deps["fmt"] = {
+        .package = "fmt",
+        .cmake_package = "fmt",
+        .cmake_target = "fmt::fmt",
+    };
+
+    cmake::config_packages(deps, all_deps,
+        {
+            .deps_dir = deps_dir,
+            .post_process
+            = [deps_dir](std::string& str) { boost::replace_all(str, deps_dir.string(), "${CMAKE_BINARY_DIR}/deps"); },
+        });
+
+    const auto package_config_file = deps_dir / fmt::format("{}-config.cmake", package);
+    ASSERT_TRUE(fs::exists(package_config_file));
+    ASSERT_EQ(read_as_string(package_config_file), R"(
+# LIB
+add_library(test_pack_lib INTERFACE)
+
+target_include_directories(test_pack_lib INTERFACE ${CMAKE_BINARY_DIR}/deps/test_pack/include)
+
+target_link_libraries(test_pack_lib INTERFACE fmt::fmt)
+
+add_library(cppship::test_pack ALIAS test_pack_lib)
+)");
+}
+
+TEST(package_configurer, CppshipLib)
+{
+    const auto package = "test_pack"s;
+    const auto tmpdir = fs::temp_directory_path();
+    const auto deps_dir = tmpdir / "deps";
+    const auto package_dir = deps_dir / package;
+    const auto lib_dir = package_dir / kLibPath;
+    fs::remove_all(deps_dir);
+
+    fs::create_directory(deps_dir);
+    fs::create_directory(package_dir);
+    fs::create_directory(package_dir / "include");
+    fs::create_directory(lib_dir);
+
+    write(package_dir / kRepoConfigFile, R"([package]
+name = "test_pack"
+version = "0.1.0"
+
+[dependencies]
+fmt = "9.1.0"
+)");
+    touch(lib_dir / "a.cpp");
+    touch(lib_dir / "b.cpp");
+    touch(lib_dir / "a_test.cpp");
+
+    cppship::ResolvedDependencies deps { {
+        package,
+        Dependency {
+            .package = package,
+            .cmake_package = package,
+            .cmake_target = fmt::format("cppship::{}", package),
+        },
+    } };
+    cppship::ResolvedDependencies all_deps = deps;
+    all_deps["fmt"] = {
+        .package = "fmt",
+        .cmake_package = "fmt",
+        .cmake_target = "fmt::fmt",
+    };
+
+    cmake::config_packages(deps, all_deps,
+        {
+            .deps_dir = deps_dir,
+            .post_process
+            = [deps_dir](std::string& str) { boost::replace_all(str, deps_dir.string(), "${CMAKE_BINARY_DIR}/deps"); },
+        });
+
+    const auto package_config_file = deps_dir / fmt::format("{}-config.cmake", package);
+    ASSERT_TRUE(fs::exists(package_config_file));
+    ASSERT_EQ(read_as_string(package_config_file), R"(
+# LIB
+add_library(test_pack_lib ${CMAKE_BINARY_DIR}/deps/test_pack/lib/a.cpp
+${CMAKE_BINARY_DIR}/deps/test_pack/lib/b.cpp)
+
+target_include_directories(test_pack_lib PUBLIC ${CMAKE_BINARY_DIR}/deps/test_pack/include)
+
+target_link_libraries(test_pack_lib PUBLIC fmt::fmt)
+
+add_library(cppship::test_pack ALIAS test_pack_lib)
+)");
+}
\ No newline at end of file
diff --git a/tests/core/manifest.cpp b/tests/core/manifest.cpp
index c12770d..e7409af 100644
--- a/tests/core/manifest.cpp
+++ b/tests/core/manifest.cpp
@@ -91,13 +91,13 @@ toml11 = "3.7.1"
 
     const auto& dep1 = deps[0];
     EXPECT_EQ(dep1.package, "boost");
-    ASSERT_TRUE(std::holds_alternative<ConanDep>(dep1.desc));
+    ASSERT_TRUE(dep1.is_conan());
     EXPECT_EQ(get<ConanDep>(dep1.desc).version, "1.81.0");
     EXPECT_EQ(dep1.components, std::vector<std::string> { "headers" });
 
     const auto& dep2 = deps[1];
     EXPECT_EQ(dep2.package, "toml11");
-    ASSERT_TRUE(std::holds_alternative<ConanDep>(dep2.desc));
+    ASSERT_TRUE(dep2.is_conan());
     EXPECT_EQ(get<ConanDep>(dep2.desc).version, "3.7.1");
     EXPECT_TRUE(dep2.components.empty());
 }
@@ -117,7 +117,7 @@ boost = { version = "1.81.0", components = ["headers"], options = { without_stac
     const auto& dep = meta.dependencies().front();
 
     EXPECT_EQ(dep.package, "boost");
-    ASSERT_TRUE(std::holds_alternative<ConanDep>(dep.desc));
+    ASSERT_TRUE(dep.is_conan());
 
     const auto& desc = get<ConanDep>(dep.desc);
     EXPECT_EQ(desc.version, "1.81.0");
@@ -157,11 +157,11 @@ fmt = "9.1.0"
     ranges::sort(deps, std::less<> {}, &DeclaredDependency::package);
 
     EXPECT_EQ(deps[0].package, "boost");
-    ASSERT_TRUE(std::holds_alternative<ConanDep>(deps[0].desc));
+    ASSERT_TRUE(deps[0].is_conan());
     EXPECT_EQ(get<ConanDep>(deps[0].desc).version, "1.81.0");
 
     EXPECT_EQ(deps[1].package, "fmt");
-    ASSERT_TRUE(std::holds_alternative<ConanDep>(deps[1].desc));
+    ASSERT_TRUE(deps[1].is_conan());
     EXPECT_EQ(get<ConanDep>(deps[1].desc).version, "9.1.0");
 }
 
@@ -213,9 +213,9 @@ scope_guard = { git = "https://github.com/Neargye/scope_guard.git", commit = "fa
     ASSERT_EQ(meta.dependencies().size(), 1);
 
     const auto& dep = meta.dependencies()[0];
-    ASSERT_TRUE(std::holds_alternative<GitHeaderOnlyDep>(dep.desc));
+    ASSERT_TRUE(dep.is_git());
 
-    const auto& desc = get<GitHeaderOnlyDep>(dep.desc);
+    const auto& desc = get<GitDep>(dep.desc);
     EXPECT_EQ(desc.git, "https://github.com/Neargye/scope_guard.git");
     EXPECT_EQ(desc.commit, "fa60305b5805dcd872b3c60d0bc517c505f99502");