diff --git a/README.md b/README.md
index b04e508..c161acb 100644
--- a/README.md
+++ b/README.md
@@ -112,7 +112,8 @@ If you are working from a checkout, the top-level CMake project also supports
 - Non-intrusive registration of ordinary C++ types
 - Explicit control over lifetime and stored representation
 - Array support for raw arrays and smart-pointer-backed arrays
-- Explicit variant construction and variant storage resolution
+- Explicit variant construction plus whole-variant or held-alternative
+  resolution
 - Constructor deduction with explicit factory overrides when needed
 - Interface bindings and multibindings
 - Indexed and annotated resolution
diff --git a/docs/core-concepts.md b/docs/core-concepts.md
index d2da2ee..ab14876 100644
--- a/docs/core-concepts.md
+++ b/docs/core-concepts.md
@@ -287,14 +287,22 @@ Dingo handles variants in two distinct places:
 - `construct<std::variant<A, B>, constructor_detection<A>>()` constructs the
   variant by selecting `A` as the alternative to build
 - `register_type<..., storage<std::variant<A, B>>, factory<...>>()` lets the
-  container store and later resolve the whole variant value
+  container store the variant and later resolve either the whole variant or its
+  currently held alternative
 
 The current rules are narrow on purpose:
 
 - the selected alternative must appear exactly once in the variant type
-- resolution is for the whole variant, not for `A` or `B` directly
-- unique variant storage resolves as the whole variant value or rvalue
-- shared and external variant storage resolve as references to the whole variant
+- the whole variant remains resolvable
+- uniquely occurring alternatives are also resolvable from variant storage
+- if a requested alternative is published but the current instance holds a
+  different alternative, resolution fails as `type_not_convertible_exception`
+- duplicate alternative types are rejected at compile time for direct resolution
+- unique variant storage resolves the whole variant as a value or rvalue, and a
+  held alternative as a value or rvalue
+- shared and external variant storage resolve the whole variant as values,
+  references, or pointers, and a held alternative as values, references, or
+  pointers
 
 <!-- { include("../examples/container/variant.cpp", scope="////", summary="Variant construction and storage example") -->
 
@@ -324,22 +332,27 @@ construct_container.register_type<scope<external>, storage<float>>(3.5f);
     construct_container
         .construct<std::variant<A, B>, constructor_detection<A>>();
 assert(std::holds_alternative<A>(detected));
-assert(std::get<A>(detected).value == 7);
 
 [[maybe_unused]] auto explicit_ctor =
     construct_container.construct<std::variant<A, B>, constructor<B(float)>>();
 assert(std::holds_alternative<B>(explicit_ctor));
-assert(std::get<B>(explicit_ctor).value == 3.5f);
 
 container<> unique_container;
 unique_container.register_type<scope<unique>, storage<int>>();
 unique_container.register_type<scope<unique>, storage<std::variant<A, B>>,
                                factory<constructor_detection<A>>>();
 
-// Resolve the whole variant value from variant storage.
+// Resolve either the whole variant or its currently held alternative.
 [[maybe_unused]] auto value = unique_container.resolve<std::variant<A, B>>();
 assert(std::holds_alternative<A>(value));
-assert(std::get<A>(value).value == 0);
+
+[[maybe_unused]] auto selected = unique_container.resolve<A>();
+
+try {
+    unique_container.resolve<B>();
+    assert(false);
+} catch (const type_not_convertible_exception&) {
+}
 
 std::variant<A, B> existing(std::in_place_type<A>, 9);
 container<> external_container;
@@ -349,7 +362,9 @@ external_container.register_type<scope<external>, storage<std::variant<A, B>&>>(
 [[maybe_unused]] auto& ref = external_container.resolve<std::variant<A, B>&>();
 assert(&ref == &existing);
 assert(std::holds_alternative<A>(ref));
-assert(std::get<A>(ref).value == 9);
+
+[[maybe_unused]] auto& held = external_container.resolve<A&>();
+assert(&held == &std::get<A>(existing));
 ```
 
 </details>
diff --git a/docs/examples.md b/docs/examples.md
index 0e9374e..501c068 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -35,7 +35,8 @@ the feature you care about and start there.
 - [examples/storage/array.cpp](../examples/storage/array.cpp): register and
   resolve raw arrays plus smart-array forms
 - [examples/container/variant.cpp](../examples/container/variant.cpp): construct
-  variants and store registrations whose storage is itself a variant
+  variants and resolve either the whole variant or its held alternative from
+  variant storage
 
 ## Interfaces, Collections, And Dispatch
 
diff --git a/examples/container/variant.cpp b/examples/container/variant.cpp
index c3882a3..a6fc641 100644
--- a/examples/container/variant.cpp
+++ b/examples/container/variant.cpp
@@ -38,13 +38,11 @@ int main() {
         construct_container.construct<std::variant<A, B>,
                                       constructor_detection<A>>();
     assert(std::holds_alternative<A>(detected));
-    assert(std::get<A>(detected).value == 7);
 
     [[maybe_unused]] auto explicit_ctor =
         construct_container.construct<std::variant<A, B>,
                                       constructor<B(float)>>();
     assert(std::holds_alternative<B>(explicit_ctor));
-    assert(std::get<B>(explicit_ctor).value == 3.5f);
 
     container<> unique_container;
     unique_container.register_type<scope<unique>, storage<int>>();
@@ -52,11 +50,18 @@ int main() {
         scope<unique>, storage<std::variant<A, B>>,
         factory<constructor_detection<A>>>();
 
-    // Resolve the whole variant value from variant storage.
+    // Resolve either the whole variant or its currently held alternative.
     [[maybe_unused]] auto value =
         unique_container.resolve<std::variant<A, B>>();
     assert(std::holds_alternative<A>(value));
-    assert(std::get<A>(value).value == 0);
+
+    [[maybe_unused]] auto selected = unique_container.resolve<A>();
+
+    try {
+        unique_container.resolve<B>();
+        assert(false);
+    } catch (const type_not_convertible_exception&) {
+    }
 
     std::variant<A, B> existing(std::in_place_type<A>, 9);
     container<> external_container;
@@ -67,6 +72,8 @@ int main() {
         external_container.resolve<std::variant<A, B>&>();
     assert(&ref == &existing);
     assert(std::holds_alternative<A>(ref));
-    assert(std::get<A>(ref).value == 9);
+
+    [[maybe_unused]] auto& held = external_container.resolve<A&>();
+    assert(&held == &std::get<A>(existing));
     ////
 }
diff --git a/include/dingo/container.h b/include/dingo/container.h
index 769fbf2..588a5e6 100644
--- a/include/dingo/container.h
+++ b/include/dingo/container.h
@@ -526,6 +526,9 @@ class container : public allocator_base<Allocator> {
     void check_interface_requirements() {
         using normalized_type = normalized_type_t<Type>;
         using normalized_interface_type = normalized_type_t<TypeInterface>;
+        constexpr bool is_alternative_type_interface =
+            is_alternative_type_interface_compatible_v<normalized_type,
+                                                       normalized_interface_type>;
 
         static_assert(!std::is_reference_v<TypeInterface>);
         if constexpr (detail::is_array_like_type_v<Type>) {
@@ -546,7 +549,9 @@ class container : public allocator_base<Allocator> {
             }
         }
         static_assert(
-            std::is_convertible_v<normalized_type*, normalized_interface_type*>);
+            std::is_convertible_v<normalized_type*, normalized_interface_type*> ||
+            is_alternative_type_interface,
+            "registered type must be pointer-convertible to the interface");
         if constexpr (!std::is_same_v<normalized_type,
                                       normalized_interface_type>) {
             static_assert(detail::storage_interface_requirements_v<
diff --git a/include/dingo/memory/arena_allocator.h b/include/dingo/memory/arena_allocator.h
index 68d002d..5c264bd 100644
--- a/include/dingo/memory/arena_allocator.h
+++ b/include/dingo/memory/arena_allocator.h
@@ -114,7 +114,8 @@ template< typename Allocator = std::allocator<uint8_t> > class arena
 
     template< typename T, std::size_t N > arena(T(&buffer)[N], std::size_t block_size = N * sizeof(T))
         : arena(reinterpret_cast<uint8_t*>(buffer), N * sizeof(T), block_size) {
-        static_assert(std::is_trivial_v<T>);
+        static_assert(std::is_trivially_default_constructible_v<T> &&
+                      std::is_trivially_copyable_v<T>);
     }
 
     template< typename T > arena(T& buffer, std::size_t block_size = sizeof(T))
@@ -238,4 +239,3 @@ bool operator != (const arena_allocator<T, Arena, AlignmentT>& x, const arena_al
 }
 
 }
-
diff --git a/include/dingo/registration/type_registration.h b/include/dingo/registration/type_registration.h
index d22d576..d0a60a6 100644
--- a/include/dingo/registration/type_registration.h
+++ b/include/dingo/registration/type_registration.h
@@ -91,6 +91,30 @@ struct deduced_interface_type {
     using type = ::dingo::interfaces<leaf_type_t<StorageType>>;
 };
 
+template <typename StorageType, typename ScopeType>
+struct deduced_interface_type<
+    StorageType, ScopeType,
+    std::void_t<typename ::dingo::detail::alternative_type_interface_types<
+        std::remove_cv_t<std::remove_reference_t<StorageType>>>::type>> {
+    using type = ::dingo::interfaces<
+        typename ::dingo::detail::alternative_type_interface_types<
+            std::remove_cv_t<std::remove_reference_t<StorageType>>>::type>;
+};
+
+template <typename StorageType, typename ScopeType>
+struct deduced_interface_type<
+    StorageType, ScopeType,
+    std::enable_if_t<!std::is_same_v<typename ScopeType::type, unique> &&
+                     type_traits<std::remove_cv_t<
+                         std::remove_reference_t<StorageType>>>::enabled &&
+                     type_traits<std::remove_cv_t<
+                         std::remove_reference_t<StorageType>>>::is_value_borrowable &&
+                     is_alternative_type_v<std::remove_cv_t<leaf_type_t<StorageType>>>>> {
+    using type = ::dingo::interfaces<
+        typename ::dingo::detail::alternative_type_interface_types<
+            std::remove_cv_t<leaf_type_t<StorageType>>>::type>;
+};
+
 template <typename StorageType, typename ScopeType>
 struct deduced_interface_type<
     StorageType, ScopeType,
diff --git a/include/dingo/resolution/instance_resolver.h b/include/dingo/resolution/instance_resolver.h
index 417a9f9..a17d4cd 100644
--- a/include/dingo/resolution/instance_resolver.h
+++ b/include/dingo/resolution/instance_resolver.h
@@ -284,6 +284,10 @@ struct instance_resolver<RTTI, Type, Storage, unique> {
         return storage.resolve(context, container);
     }
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#endif
     template <typename Target, typename Source, typename Context,
               typename Container, typename Factory>
     void* resolve_address(Context& context, Container& container,
@@ -303,6 +307,9 @@ struct instance_resolver<RTTI, Type, Storage, unique> {
         return ::dingo::get_address(
             context, std::forward<decltype(instance)>(instance));
     }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
   private:
     template <typename T, typename Context, typename... Args>
diff --git a/include/dingo/resolution/type_conversion.h b/include/dingo/resolution/type_conversion.h
index 27b77e1..dc77e95 100644
--- a/include/dingo/resolution/type_conversion.h
+++ b/include/dingo/resolution/type_conversion.h
@@ -111,6 +111,84 @@ Target* resolve_handle_or_borrow_pointer(Factory& factory, Context& context,
             factory, context, requested_type, registered_type);
     }
 }
+
+template <typename Target, typename Sum>
+Target extract_alternative_type_value(Sum&& sum, type_descriptor requested_type,
+                                      type_descriptor registered_type) {
+    using selected_type = std::remove_const_t<Target>;
+    using alternative_type = std::remove_cv_t<std::remove_reference_t<Sum>>;
+
+    if (auto* value =
+            alternative_type_traits<alternative_type>::template get<selected_type>(
+                sum)) {
+        return Target(std::move(*value));
+    }
+
+    throw make_type_not_convertible_exception(requested_type, registered_type);
+}
+
+template <typename Target, typename Sum>
+Target& resolve_alternative_type_reference(Sum& sum,
+                                           type_descriptor requested_type,
+                                           type_descriptor registered_type) {
+    using selected_type = std::remove_const_t<Target>;
+    using alternative_type = std::remove_cv_t<std::remove_reference_t<Sum>>;
+
+    if (auto* value =
+            alternative_type_traits<alternative_type>::template get<selected_type>(
+                sum)) {
+        return *value;
+    }
+
+    throw make_type_not_convertible_exception(requested_type, registered_type);
+}
+
+template <typename Target, typename Sum>
+Target* resolve_alternative_type_pointer(Sum& sum,
+                                         type_descriptor requested_type,
+                                         type_descriptor registered_type) {
+    return std::addressof(
+        resolve_alternative_type_reference<Target>(sum, requested_type,
+                                                   registered_type));
+}
+
+template <typename Source>
+using borrowed_value_type_t = std::remove_cv_t<std::remove_reference_t<
+    decltype(type_traits<Source>::borrow(std::declval<Source&>()))>>;
+
+template <typename Source, typename Target, typename = void>
+struct is_borrowed_alternative_type_alternative : std::false_type {};
+
+template <typename Source, typename Target, typename = void>
+struct is_borrowed_alternative_type : std::false_type {};
+
+template <typename Source, typename Target>
+struct is_borrowed_alternative_type<
+    Source, Target,
+    std::enable_if_t<type_traits<Source>::enabled &&
+                     type_traits<Source>::is_value_borrowable &&
+                     is_alternative_type_v<borrowed_value_type_t<Source>>>>
+    : std::bool_constant<
+          std::is_same_v<std::remove_cv_t<Target>, borrowed_value_type_t<Source>>> {};
+
+template <typename Source, typename Target>
+struct is_borrowed_alternative_type_alternative<
+    Source, Target,
+    std::enable_if_t<type_traits<Source>::enabled &&
+                     type_traits<Source>::is_value_borrowable &&
+                     is_alternative_type_v<borrowed_value_type_t<Source>>>>
+    : std::bool_constant<
+          !std::is_same_v<std::remove_cv_t<Target>, borrowed_value_type_t<Source>> &&
+          (alternative_type_count<borrowed_value_type_t<Source>,
+                                  std::remove_cv_t<Target>>::value == 1)> {};
+
+template <typename Source, typename Target>
+inline constexpr bool is_borrowed_alternative_type_v =
+    is_borrowed_alternative_type<Source, Target>::value;
+
+template <typename Source, typename Target>
+inline constexpr bool is_borrowed_alternative_type_alternative_v =
+    is_borrowed_alternative_type_alternative<Source, Target>::value;
 } // namespace detail
 
 // TODO: logic here should not depend on knowledge of storage types,
@@ -130,7 +208,40 @@ struct type_conversion {
 
 template <typename Target, typename Source>
 struct type_conversion<unique, Target, Source,
-                       std::enable_if_t<!std::is_pointer_v<Source>>> {
+                       std::enable_if_t<!std::is_pointer_v<Source> &&
+                                        !is_alternative_type_v<Source>>> {
+    template <typename Factory, typename Context>
+    static Target apply(Factory& factory, Context& context, type_descriptor,
+                        type_descriptor) {
+        return detail::resolve_source(factory, context);
+    }
+};
+
+template <typename Target, typename Source>
+struct type_conversion<
+    unique, Target, Source,
+    std::enable_if_t<
+        is_alternative_type_v<Source> &&
+        !std::is_pointer_v<Target> &&
+        !std::is_same_v<std::remove_cv_t<Target>, std::remove_cv_t<Source>> &&
+        (detail::alternative_type_count<Source,
+                                        std::remove_cv_t<Target>>::value == 1)>> {
+    template <typename Factory, typename Context>
+    static Target apply(Factory& factory, Context& context,
+                        type_descriptor requested_type,
+                        type_descriptor registered_type) {
+        auto&& source = detail::resolve_source(factory, context);
+        return detail::extract_alternative_type_value<Target>(
+            std::move(source), requested_type, registered_type);
+    }
+};
+
+template <typename Target, typename Source>
+struct type_conversion<
+    unique, Target, Source,
+    std::enable_if_t<is_alternative_type_v<Source> &&
+                     std::is_same_v<std::remove_cv_t<Target>,
+                                    std::remove_cv_t<Source>>>> {
     template <typename Factory, typename Context>
     static Target apply(Factory& factory, Context& context, type_descriptor,
                         type_descriptor) {
@@ -190,7 +301,72 @@ struct type_conversion<unique, std::shared_ptr<Array>, Source*,
 template <typename StorageTag, typename Target, typename Source>
 struct type_conversion<
     StorageTag, Target, Source&,
-    std::enable_if_t<!type_traits<Source>::enabled && !std::is_pointer_v<Target>>> {
+    std::enable_if_t<
+        is_alternative_type_v<Source> &&
+        !std::is_pointer_v<Target> &&
+        !std::is_same_v<std::remove_cv_t<Target>, std::remove_cv_t<Source>> &&
+        (detail::alternative_type_count<Source,
+                                        std::remove_cv_t<Target>>::value == 1)>> {
+    template <typename Factory, typename Context>
+    static Target& apply(Factory& factory, Context& context,
+                         type_descriptor requested_type,
+                         type_descriptor registered_type) {
+        return detail::resolve_alternative_type_reference<Target>(
+            detail::resolve_source(factory, context), requested_type,
+            registered_type);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target, Source&,
+    std::enable_if_t<is_alternative_type_v<Source> &&
+                     std::is_same_v<std::remove_cv_t<Target>,
+                                    std::remove_cv_t<Source>>>> {
+    template <typename Factory, typename Context>
+    static Target& apply(Factory& factory, Context& context, type_descriptor,
+                         type_descriptor) {
+        return detail::resolve_source(factory, context);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target, Source*,
+    std::enable_if_t<
+        is_alternative_type_v<Source> &&
+        !std::is_pointer_v<Target> &&
+        !std::is_same_v<std::remove_cv_t<Target>, std::remove_cv_t<Source>> &&
+        (detail::alternative_type_count<Source,
+                                        std::remove_cv_t<Target>>::value == 1)>> {
+    template <typename Factory, typename Context>
+    static Target& apply(Factory& factory, Context& context,
+                         type_descriptor requested_type,
+                         type_descriptor registered_type) {
+        return detail::resolve_alternative_type_reference<Target>(
+            *detail::resolve_source(factory, context), requested_type,
+            registered_type);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target, Source*,
+    std::enable_if_t<is_alternative_type_v<Source> &&
+                     std::is_same_v<std::remove_cv_t<Target>,
+                                    std::remove_cv_t<Source>>>> {
+    template <typename Factory, typename Context>
+    static Target& apply(Factory& factory, Context& context, type_descriptor,
+                         type_descriptor) {
+        return *detail::resolve_source(factory, context);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target, Source&,
+    std::enable_if_t<!type_traits<Source>::enabled && !std::is_pointer_v<Target> &&
+                     !is_alternative_type_v<Source>>> {
     template <typename Factory, typename Context>
     static Target& apply(Factory& factory, Context& context, type_descriptor,
                          type_descriptor) {
@@ -198,6 +374,68 @@ struct type_conversion<
     }
 };
 
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target*, Source&,
+    std::enable_if_t<
+        is_alternative_type_v<Source> &&
+        !std::is_same_v<std::remove_cv_t<Target>, std::remove_cv_t<Source>> &&
+        (detail::alternative_type_count<Source,
+                                        std::remove_cv_t<Target>>::value == 1)>> {
+    template <typename Factory, typename Context>
+    static Target* apply(Factory& factory, Context& context,
+                         type_descriptor requested_type,
+                         type_descriptor registered_type) {
+        return detail::resolve_alternative_type_pointer<Target>(
+            detail::resolve_source(factory, context), requested_type,
+            registered_type);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target*, Source&,
+    std::enable_if_t<is_alternative_type_v<Source> &&
+                     std::is_same_v<std::remove_cv_t<Target>,
+                                    std::remove_cv_t<Source>>>> {
+    template <typename Factory, typename Context>
+    static Target* apply(Factory& factory, Context& context, type_descriptor,
+                         type_descriptor) {
+        return std::addressof(detail::resolve_source(factory, context));
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target*, Source*,
+    std::enable_if_t<
+        is_alternative_type_v<Source> &&
+        !std::is_same_v<std::remove_cv_t<Target>, std::remove_cv_t<Source>> &&
+        (detail::alternative_type_count<Source,
+                                        std::remove_cv_t<Target>>::value == 1)>> {
+    template <typename Factory, typename Context>
+    static Target* apply(Factory& factory, Context& context,
+                         type_descriptor requested_type,
+                         type_descriptor registered_type) {
+        return detail::resolve_alternative_type_pointer<Target>(
+            *detail::resolve_source(factory, context), requested_type,
+            registered_type);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target*, Source*,
+    std::enable_if_t<is_alternative_type_v<Source> &&
+                     std::is_same_v<std::remove_cv_t<Target>,
+                                    std::remove_cv_t<Source>>>> {
+    template <typename Factory, typename Context>
+    static Target* apply(Factory& factory, Context& context, type_descriptor,
+                         type_descriptor) {
+        return detail::resolve_source(factory, context);
+    }
+};
+
 template <typename StorageTag, typename Target, typename Source>
 struct type_conversion<
     StorageTag, Target, Source&,
@@ -239,12 +477,45 @@ struct type_conversion<
     }
 };
 
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target, Source&,
+    std::enable_if_t<!std::is_pointer_v<Target> &&
+                     detail::is_borrowed_alternative_type_v<Source, Target>>> {
+    template <typename Factory, typename Context>
+    static Target& apply(Factory& factory, Context& context, type_descriptor,
+                         type_descriptor) {
+        auto& source = detail::resolve_source(factory, context);
+        return type_traits<Source>::borrow(source);
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target, Source&,
+    std::enable_if_t<
+        !std::is_pointer_v<Target> &&
+        detail::is_borrowed_alternative_type_alternative_v<Source, Target>>> {
+    template <typename Factory, typename Context>
+    static Target& apply(Factory& factory, Context& context,
+                         type_descriptor requested_type,
+                         type_descriptor registered_type) {
+        auto& source = detail::resolve_source(factory, context);
+        return detail::resolve_alternative_type_reference<Target>(
+            type_traits<Source>::borrow(source), requested_type,
+            registered_type);
+    }
+};
+
 template <typename StorageTag, typename Target, typename Source>
 struct type_conversion<
     StorageTag, Target, Source&,
     std::enable_if_t<!type_traits<Target>::enabled && !std::is_pointer_v<Target> &&
                      type_traits<Source>::enabled &&
-                     type_traits<Source>::is_value_borrowable>> {
+                     type_traits<Source>::is_value_borrowable &&
+                     !detail::is_borrowed_alternative_type_v<Source, Target> &&
+                     !detail::is_borrowed_alternative_type_alternative_v<Source,
+                                                                         Target>>> {
     template <typename Factory, typename Context>
     static Target& apply(Factory& factory, Context& context,
                          type_descriptor requested_type,
@@ -267,12 +538,44 @@ struct type_conversion<
     }
 };
 
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target*, Source&,
+    std::enable_if_t<detail::is_borrowed_alternative_type_v<Source, Target>>> {
+    template <typename Factory, typename Context>
+    static Target* apply(Factory& factory, Context& context, type_descriptor,
+                         type_descriptor) {
+        auto& source = detail::resolve_source(factory, context);
+        return std::addressof(
+            static_cast<Target&>(type_traits<Source>::borrow(source)));
+    }
+};
+
+template <typename StorageTag, typename Target, typename Source>
+struct type_conversion<
+    StorageTag, Target*, Source&,
+    std::enable_if_t<
+        detail::is_borrowed_alternative_type_alternative_v<Source, Target>>> {
+    template <typename Factory, typename Context>
+    static Target* apply(Factory& factory, Context& context,
+                         type_descriptor requested_type,
+                         type_descriptor registered_type) {
+        auto& source = detail::resolve_source(factory, context);
+        return detail::resolve_alternative_type_pointer<Target>(
+            type_traits<Source>::borrow(source), requested_type,
+            registered_type);
+    }
+};
+
 template <typename StorageTag, typename Target, typename Source>
 struct type_conversion<
     StorageTag, Target*, Source&,
     std::enable_if_t<!type_traits<Target>::enabled &&
                      type_traits<Source>::enabled &&
-                     type_traits<Source>::is_value_borrowable>> {
+                     type_traits<Source>::is_value_borrowable &&
+                     !detail::is_borrowed_alternative_type_v<Source, Target> &&
+                     !detail::is_borrowed_alternative_type_alternative_v<Source,
+                                                                         Target>>> {
     template <typename Factory, typename Context>
     static Target* apply(Factory& factory, Context& context,
                          type_descriptor requested_type,
@@ -357,7 +660,9 @@ struct type_conversion<
 
 template <typename StorageTag, typename Target, typename Source>
 struct type_conversion<StorageTag, Target*, Source*,
-                       std::enable_if_t<!std::is_array_v<Target>>> {
+                       std::enable_if_t<!std::is_same_v<StorageTag, unique> &&
+                                        !std::is_array_v<Target> &&
+                                        !is_alternative_type_v<Source>>> {
     template <typename Factory, typename Context>
     static Target* apply(Factory& factory, Context& context, type_descriptor,
                          type_descriptor) {
@@ -370,7 +675,7 @@ struct type_conversion<
     StorageTag, Target, Source*,
     std::enable_if_t<!is_pointer_like_type_v<Target> &&
                      !std::is_pointer_v<Target> &&
-                     !std::is_array_v<Target>>> {
+                     !std::is_array_v<Target> && !is_alternative_type_v<Source>>> {
     template <typename Factory, typename Context>
     static Target& apply(Factory& factory, Context& context, type_descriptor,
                          type_descriptor) {
@@ -381,7 +686,9 @@ struct type_conversion<
 template <typename StorageTag, typename Target, typename Source>
 struct type_conversion<
     StorageTag, Target*, Source&,
-    std::enable_if_t<!type_traits<Source>::enabled && !is_pointer_like_type_v<Target>>> {
+    std::enable_if_t<!type_traits<Source>::enabled &&
+                     !is_pointer_like_type_v<Target> &&
+                     !is_alternative_type_v<Source>>> {
     template <typename Factory, typename Context>
     static Target* apply(Factory& factory, Context& context, type_descriptor,
                          type_descriptor) {
diff --git a/include/dingo/storage/type_storage_traits.h b/include/dingo/storage/type_storage_traits.h
index 0e53571..ee04356 100644
--- a/include/dingo/storage/type_storage_traits.h
+++ b/include/dingo/storage/type_storage_traits.h
@@ -82,7 +82,7 @@ template <typename Type, typename U>
 struct storage_traits<
     unique, Type, U,
     std::enable_if_t<!type_traits<Type>::enabled && !std::is_reference_v<Type> &&
-                     !std::is_array_v<Type>>> {
+                     !std::is_array_v<Type> && !is_alternative_type_v<Type>>> {
     static constexpr bool enabled = true;
 
     using value_types = type_list<U>;
@@ -96,7 +96,7 @@ template <typename Type, typename U>
 struct resolution_traits<
     unique, Type, U,
     std::enable_if_t<!type_traits<Type>::enabled && !std::is_reference_v<Type> &&
-                     !std::is_array_v<Type>>> {
+                     !std::is_array_v<Type> && !is_alternative_type_v<Type>>> {
     using value_types = type_list<std::optional<U>>;
     using lvalue_reference_types = type_list<>;
     using rvalue_reference_types = type_list<std::optional<U>&&>;
diff --git a/include/dingo/type/type_traits.h b/include/dingo/type/type_traits.h
index 0b922c3..33351d2 100644
--- a/include/dingo/type/type_traits.h
+++ b/include/dingo/type/type_traits.h
@@ -58,28 +58,131 @@ struct construction_traits {
     static constexpr bool enabled = false;
 };
 
+template <typename T, typename = void> struct alternative_type_traits {
+    static constexpr bool enabled = false;
+};
+
+template <typename T>
+inline constexpr bool is_alternative_type_v =
+    alternative_type_traits<std::remove_cv_t<T>>::enabled;
+
 namespace detail {
-template <typename Variant, typename Selected> struct variant_alternative_count;
+template <typename List, typename Selected> struct type_list_count;
 
 template <typename Selected, typename... Alternatives>
-struct variant_alternative_count<std::variant<Alternatives...>, Selected>
+struct type_list_count<type_list<Alternatives...>, Selected>
     : std::integral_constant<size_t,
                              (0u + ... + (std::is_same_v<Selected, Alternatives> ? 1u
                                                                                  : 0u))> {};
+
+template <typename List> struct type_list_has_duplicates;
+
+template <typename... Alternatives>
+struct type_list_has_duplicates<type_list<Alternatives...>>
+    : std::bool_constant<
+          ((type_list_count<type_list<Alternatives...>, Alternatives>::value > 1) ||
+           ...)> {};
+
+template <typename Type, typename = void>
+struct alternative_type_alternatives {};
+
+template <typename Type>
+struct alternative_type_alternatives<
+    Type,
+    std::enable_if_t<alternative_type_traits<std::remove_cv_t<Type>>::enabled>> {
+    using type = typename alternative_type_traits<std::remove_cv_t<Type>>::alternatives;
+
+    static_assert(
+        !type_list_has_duplicates<type>::value,
+        "alternative_type_traits<T>::alternatives must not contain duplicate types");
+};
+
+template <typename Type>
+using alternative_type_alternatives_t =
+    typename alternative_type_alternatives<Type>::type;
+
+template <typename Type, typename Selected, typename = void>
+struct alternative_type_count : std::integral_constant<size_t, 0> {};
+
+template <typename Type, typename Selected>
+struct alternative_type_count<
+    Type, Selected,
+    std::enable_if_t<alternative_type_traits<std::remove_cv_t<Type>>::enabled>>
+    : type_list_count<alternative_type_alternatives_t<Type>,
+                      std::remove_cv_t<Selected>> {};
+
+template <typename Type, typename = void>
+struct alternative_type_interface_types {};
+
+template <typename Type>
+struct alternative_type_interface_types<
+    Type,
+    std::enable_if_t<alternative_type_traits<std::remove_cv_t<Type>>::enabled>> {
+    using type =
+        type_list_cat_t<type_list<std::remove_cv_t<Type>>,
+                        alternative_type_alternatives_t<Type>>;
+};
 } // namespace detail
 
-template <typename... Alternatives, typename Selected>
+template <typename... Alternatives>
+struct alternative_type_traits<std::variant<Alternatives...>> {
+    static constexpr bool enabled = true;
+
+    using alternatives = type_list<Alternatives...>;
+
+    template <typename Selected, typename Value>
+    static std::variant<Alternatives...> wrap(Value&& value) {
+        return std::variant<Alternatives...>(std::in_place_type<Selected>,
+                                             std::forward<Value>(value));
+    }
+
+    template <typename Selected>
+    static Selected* get(std::variant<Alternatives...>& value) {
+        return std::get_if<Selected>(&value);
+    }
+
+    template <typename Selected>
+    static const Selected* get(const std::variant<Alternatives...>& value) {
+        return std::get_if<Selected>(&value);
+    }
+};
+
+template <typename Type, typename Interface>
+inline constexpr bool is_alternative_type_interface_compatible_v =
+    detail::alternative_type_count<std::remove_cv_t<Type>,
+                                   std::remove_cv_t<Interface>>::value == 1;
+
+template <typename Type, typename Selected>
+struct construction_traits<
+    Type, Selected,
+    std::enable_if_t<is_alternative_type_v<Type> &&
+                     (detail::alternative_type_count<Type, Selected>::value ==
+                      1)>> {
+    static constexpr bool enabled = true;
+
+    using type = std::remove_cv_t<Type>;
+
+    template <typename Value> static type wrap(Value&& value) {
+        return alternative_type_traits<type>::template wrap<Selected>(
+            std::forward<Value>(value));
+    }
+};
+
+template <typename Type, typename Selected>
 struct construction_traits<
-    std::variant<Alternatives...>, Selected,
-    std::enable_if_t<
-        detail::variant_alternative_count<std::variant<Alternatives...>,
-                                          Selected>::value == 1>> {
+    Type, Selected,
+    std::enable_if_t<type_traits<Type>::enabled && !std::is_pointer_v<Type> &&
+                     construction_traits<typename type_traits<Type>::value_type,
+                                         Selected>::enabled>> {
     static constexpr bool enabled = true;
 
-    using type = std::variant<Alternatives...>;
+    using value_type = typename type_traits<Type>::value_type;
+    using type = Type;
 
     template <typename Value> static type wrap(Value&& value) {
-        return type(std::in_place_type<Selected>, std::forward<Value>(value));
+        return type_traits<Type>::make(
+            construction_traits<value_type, Selected>::wrap(
+                std::forward<Value>(value)));
     }
 };
 
@@ -573,6 +676,10 @@ struct type_traits<std::unique_ptr<T, Deleter>,
         if constexpr (type_traits<T>::enabled && !std::is_pointer_v<T>)
             return std::unique_ptr<T, Deleter>(
                 new T(detail::make_nested<T>(std::forward<Args>(args)...)));
+        // Work around direct-initialization in smart-pointer-backed factories.
+        else if constexpr (std::is_constructible_v<T, Args...>)
+            return std::unique_ptr<T, Deleter>(
+                new T(std::forward<Args>(args)...));
         else
             return std::unique_ptr<T, Deleter>(
                 new T{std::forward<Args>(args)...});
@@ -982,15 +1089,18 @@ struct storage_traits<external, std::optional<T>, U> {
     using conversion_types = type_list<>;
 };
 
-template <typename... Ts>
-struct storage_traits<unique, std::variant<Ts...>, std::variant<Ts...>> {
+template <typename Type, typename U>
+struct storage_traits<
+    unique, Type, U,
+    std::enable_if_t<!type_traits<Type>::enabled && !std::is_reference_v<Type> &&
+                     !std::is_array_v<Type> && is_alternative_type_v<Type>>> {
     static constexpr bool enabled = true;
 
-    using value_types = type_list<std::variant<Ts...>>;
+    using value_types = type_list<U>;
     using lvalue_reference_types = type_list<>;
-    using rvalue_reference_types = type_list<std::variant<Ts...>&&>;
+    using rvalue_reference_types = type_list<U&&>;
     using pointer_types = type_list<>;
-    using conversion_types = type_list<std::variant<Ts...>>;
+    using conversion_types = type_list<>;
 };
 
 namespace detail {
diff --git a/test/storage/external.cpp b/test/storage/external.cpp
index ec6a9be..7ab4e2b 100644
--- a/test/storage/external.cpp
+++ b/test/storage/external.cpp
@@ -11,6 +11,7 @@
 
 #include <gtest/gtest.h>
 
+#include <memory>
 #include <string>
 #include <variant>
 
@@ -20,6 +21,21 @@
 #include "support/test.h"
 
 namespace dingo {
+namespace {
+struct shared_ptr_variant_a {
+    explicit shared_ptr_variant_a(int init) : value(init) {}
+    int value;
+};
+
+struct shared_ptr_variant_b {
+    explicit shared_ptr_variant_b(float init) : value(init) {}
+    float value;
+};
+
+using shared_ptr_variant =
+    std::variant<shared_ptr_variant_a, shared_ptr_variant_b>;
+} // namespace
+
 template <typename T> struct external_test : public test<T> {};
 TYPED_TEST_SUITE(external_test, container_types, );
 
@@ -402,11 +418,199 @@ TYPED_TEST(external_test, variant_ref) {
         .template register_type<scope<external>, storage<std::variant<A, B>&>>(
             c);
 
+    auto whole = container.template resolve<std::variant<A, B>>();
+    ASSERT_TRUE(std::holds_alternative<A>(whole));
+    EXPECT_EQ(std::get<A>(whole).value, 7);
+
     auto& value = container.template resolve<std::variant<A, B>&>();
 
     ASSERT_EQ(&value, &c);
     ASSERT_TRUE(std::holds_alternative<A>(value));
     EXPECT_EQ(std::get<A>(value).value, 7);
+
+    auto copy = container.template resolve<A>();
+    EXPECT_EQ(copy.value, 7);
+
+    auto& selected = container.template resolve<A&>();
+    EXPECT_EQ(selected.value, 7);
+    EXPECT_EQ(&selected, &std::get<A>(c));
+
+    auto& selected_const = container.template resolve<const A&>();
+    EXPECT_EQ(selected_const.value, 7);
+    EXPECT_EQ(&selected_const, &std::get<A>(c));
+
+    auto* selected_ptr = container.template resolve<A*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<A>(c));
+
+    auto* selected_const_ptr = container.template resolve<const A*>();
+    ASSERT_NE(selected_const_ptr, nullptr);
+    EXPECT_EQ(selected_const_ptr, &std::get<A>(c));
+
+    ASSERT_THROW(container.template resolve<B>(), type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<B&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<B*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(external_test, variant_explicit_interfaces_override_defaults) {
+    using container_type = TypeParam;
+
+    struct A {
+        explicit A(int init) : value(init) {}
+        int value;
+    };
+    struct B {
+        explicit B(float init) : value(init) {}
+        float value;
+    };
+
+    std::variant<A, B> c(std::in_place_type<A>, 11);
+
+    container_type container;
+    container
+        .template register_type<scope<external>, storage<std::variant<A, B>&>,
+                                interfaces<A>>(c);
+
+    auto copy = container.template resolve<A>();
+    EXPECT_EQ(copy.value, 11);
+
+    auto& selected = container.template resolve<A&>();
+    EXPECT_EQ(selected.value, 11);
+    EXPECT_EQ(&selected, &std::get<A>(c));
+
+    auto* selected_ptr = container.template resolve<A*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<A>(c));
+
+    ASSERT_THROW((container.template resolve<std::variant<A, B>>()),
+                 type_not_found_exception);
+    ASSERT_THROW((container.template resolve<std::variant<A, B>&>()),
+                 type_not_found_exception);
+    ASSERT_THROW((container.template resolve<std::variant<A, B>*>()),
+                 type_not_found_exception);
+    ASSERT_THROW(container.template resolve<B>(), type_not_found_exception);
+}
+
+TYPED_TEST(external_test, shared_ptr_variant_ref) {
+    using container_type = TypeParam;
+
+    auto handle = std::make_shared<shared_ptr_variant>(
+        std::in_place_type<shared_ptr_variant_a>, 13);
+
+    container_type container;
+    container
+        .template register_type<scope<external>,
+                                storage<std::shared_ptr<shared_ptr_variant>>>(handle);
+
+    auto whole = container.template resolve<shared_ptr_variant>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(whole));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(whole).value, 13);
+
+    auto& value = container.template resolve<shared_ptr_variant&>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(value));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(value).value, 13);
+
+    auto copy = container.template resolve<shared_ptr_variant_a>();
+    EXPECT_EQ(copy.value, 13);
+
+    auto& selected = container.template resolve<shared_ptr_variant_a&>();
+    EXPECT_EQ(selected.value, 13);
+    EXPECT_EQ(&selected, &std::get<shared_ptr_variant_a>(*handle));
+
+    auto* selected_ptr = container.template resolve<shared_ptr_variant_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<shared_ptr_variant_a>(*handle));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(external_test, unique_ptr_variant_ref) {
+    using container_type = TypeParam;
+
+    auto handle = std::make_unique<shared_ptr_variant>(
+        std::in_place_type<shared_ptr_variant_a>, 13);
+
+    container_type container;
+    container
+        .template register_type<scope<external>,
+                                storage<std::unique_ptr<shared_ptr_variant>&>>(
+            handle);
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_a>(),
+                 type_not_convertible_exception);
+
+    auto& value = container.template resolve<shared_ptr_variant&>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(value));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(value).value, 13);
+
+    auto* value_ptr = container.template resolve<shared_ptr_variant*>();
+    ASSERT_NE(value_ptr, nullptr);
+    EXPECT_EQ(value_ptr, &*handle);
+
+    auto& selected = container.template resolve<shared_ptr_variant_a&>();
+    EXPECT_EQ(selected.value, 13);
+    EXPECT_EQ(&selected, &std::get<shared_ptr_variant_a>(*handle));
+
+    auto* selected_ptr = container.template resolve<shared_ptr_variant_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<shared_ptr_variant_a>(*handle));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(external_test, unique_ptr_variant_move) {
+    using container_type = TypeParam;
+
+    auto handle = std::make_unique<shared_ptr_variant>(
+        std::in_place_type<shared_ptr_variant_a>, 17);
+
+    container_type container;
+    container
+        .template register_type<scope<external>,
+                                storage<std::unique_ptr<shared_ptr_variant>>>(
+            std::move(handle));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_a>(),
+                 type_not_convertible_exception);
+
+    auto& value = container.template resolve<shared_ptr_variant&>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(value));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(value).value, 17);
+
+    auto* value_ptr = container.template resolve<shared_ptr_variant*>();
+    ASSERT_NE(value_ptr, nullptr);
+    EXPECT_EQ(value_ptr, &value);
+
+    auto& selected = container.template resolve<shared_ptr_variant_a&>();
+    EXPECT_EQ(selected.value, 17);
+    EXPECT_EQ(&selected, &std::get<shared_ptr_variant_a>(value));
+
+    auto* selected_ptr = container.template resolve<shared_ptr_variant_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<shared_ptr_variant_a>(value));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b*>(),
+                 type_not_convertible_exception);
 }
 
 TYPED_TEST(external_test, shared_multiple) {
diff --git a/test/storage/shared.cpp b/test/storage/shared.cpp
index eb282b7..c2b2d73 100644
--- a/test/storage/shared.cpp
+++ b/test/storage/shared.cpp
@@ -7,6 +7,7 @@
 
 #include <dingo/container.h>
 #include <dingo/factory/constructor.h>
+#include <dingo/factory/function.h>
 #include <dingo/type/type_conversion_traits.h>
 #include <dingo/storage/shared.h>
 #include <dingo/storage/unique.h>
@@ -38,8 +39,73 @@ struct pointer_conversion_owner : pointer_conversion_view {
 
     pointer_conversion_view* view_;
 };
+
+struct shared_ptr_variant_a {
+    explicit shared_ptr_variant_a(int init) : value(init) {}
+    int value;
+};
+
+struct shared_ptr_variant_b {
+    explicit shared_ptr_variant_b(float init) : value(init) {}
+    float value;
+};
+
+struct custom_sum_a {
+    explicit custom_sum_a(int init) : value(init) {}
+    int value;
+};
+
+struct custom_sum_b {
+    explicit custom_sum_b(float init) : value(init) {}
+    float value;
+};
+
+using shared_ptr_variant =
+    std::variant<shared_ptr_variant_a, shared_ptr_variant_b>;
+
+struct custom_sum {
+    std::variant<custom_sum_a, custom_sum_b> value;
+};
+
+inline std::shared_ptr<shared_ptr_variant> make_shared_ptr_variant(int value) {
+    return std::make_shared<shared_ptr_variant>(
+        std::in_place_type<shared_ptr_variant_a>, value);
+}
+
+inline std::unique_ptr<shared_ptr_variant> make_unique_ptr_variant(int value) {
+    return std::make_unique<shared_ptr_variant>(
+        std::in_place_type<shared_ptr_variant_a>, value);
+}
+
+inline std::shared_ptr<custom_sum> make_shared_custom_sum(int value) {
+    return std::make_shared<custom_sum>(
+        custom_sum{std::variant<custom_sum_a, custom_sum_b>(
+            std::in_place_type<custom_sum_a>, value)});
+}
 } // namespace
 
+template <> struct alternative_type_traits<custom_sum> {
+    static constexpr bool enabled = true;
+
+    using alternatives = type_list<custom_sum_a, custom_sum_b>;
+
+    template <typename Selected, typename Value>
+    static custom_sum wrap(Value&& value) {
+        return custom_sum{
+            std::variant<custom_sum_a, custom_sum_b>(
+                std::in_place_type<Selected>, std::forward<Value>(value))};
+    }
+
+    template <typename Selected> static Selected* get(custom_sum& value) {
+        return std::get_if<Selected>(&value.value);
+    }
+
+    template <typename Selected>
+    static const Selected* get(const custom_sum& value) {
+        return std::get_if<Selected>(&value.value);
+    }
+};
+
 template <>
 struct type_conversion_traits<pointer_conversion_view*,
                               pointer_conversion_owner*> {
@@ -360,9 +426,253 @@ TYPED_TEST(shared_test, variant_factory_selects_alternative) {
         scope<shared>, storage<std::variant<A, B>>,
         factory<constructor_detection<A>>>();
 
+    auto whole = container.template resolve<std::variant<A, B>>();
+    ASSERT_TRUE(std::holds_alternative<A>(whole));
+    EXPECT_EQ(std::get<A>(whole).value, 0);
+
     auto& value = container.template resolve<std::variant<A, B>&>();
     ASSERT_TRUE(std::holds_alternative<A>(value));
     EXPECT_EQ(std::get<A>(value).value, 0);
+
+    auto copy = container.template resolve<A>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<A&>();
+    EXPECT_EQ(selected.value, 0);
+    EXPECT_EQ(&selected, &std::get<A>(value));
+
+    auto& selected_const = container.template resolve<const A&>();
+    EXPECT_EQ(selected_const.value, 0);
+    EXPECT_EQ(&selected_const, &std::get<A>(value));
+
+    auto* selected_ptr = container.template resolve<A*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<A>(value));
+
+    auto* selected_const_ptr = container.template resolve<const A*>();
+    ASSERT_NE(selected_const_ptr, nullptr);
+    EXPECT_EQ(selected_const_ptr, &std::get<A>(value));
+
+    ASSERT_THROW(container.template resolve<B>(), type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<B&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<B*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(shared_test, variant_explicit_interfaces_override_defaults) {
+    using container_type = TypeParam;
+
+    struct A {
+        explicit A(int init) : value(init) {}
+        int value;
+    };
+    struct B {
+        explicit B(float init) : value(init) {}
+        float value;
+    };
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<
+        scope<shared>, storage<std::variant<A, B>>,
+        factory<constructor_detection<A>>, interfaces<A>>();
+
+    auto copy = container.template resolve<A>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<A&>();
+    EXPECT_EQ(selected.value, 0);
+
+    auto* selected_ptr = container.template resolve<A*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr->value, 0);
+
+    ASSERT_THROW((container.template resolve<std::variant<A, B>>()),
+                 type_not_found_exception);
+    ASSERT_THROW((container.template resolve<std::variant<A, B>&>()),
+                 type_not_found_exception);
+    ASSERT_THROW((container.template resolve<std::variant<A, B>*>()),
+                 type_not_found_exception);
+    ASSERT_THROW(container.template resolve<B>(), type_not_found_exception);
+}
+
+TYPED_TEST(shared_test, custom_alternative_type_factory_selects_alternative) {
+    using container_type = TypeParam;
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<scope<shared>, storage<custom_sum>,
+                                     factory<constructor_detection<custom_sum_a>>>();
+
+    auto whole = container.template resolve<custom_sum>();
+    ASSERT_TRUE(std::holds_alternative<custom_sum_a>(whole.value));
+    EXPECT_EQ(std::get<custom_sum_a>(whole.value).value, 0);
+
+    auto& value = container.template resolve<custom_sum&>();
+    ASSERT_TRUE(std::holds_alternative<custom_sum_a>(value.value));
+    EXPECT_EQ(std::get<custom_sum_a>(value.value).value, 0);
+
+    auto copy = container.template resolve<custom_sum_a>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<custom_sum_a&>();
+    EXPECT_EQ(selected.value, 0);
+    EXPECT_EQ(&selected, &std::get<custom_sum_a>(value.value));
+
+    auto* selected_ptr = container.template resolve<custom_sum_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<custom_sum_a>(value.value));
+
+    ASSERT_THROW(container.template resolve<custom_sum_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<custom_sum_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<custom_sum_b*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(shared_test, shared_ptr_variant_factory_selects_alternative) {
+    using container_type = TypeParam;
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<
+        scope<shared>, storage<std::shared_ptr<shared_ptr_variant>>,
+        factory<function<&make_shared_ptr_variant>>>();
+
+    auto whole = container.template resolve<shared_ptr_variant>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(whole));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(whole).value, 0);
+
+    auto& value = container.template resolve<shared_ptr_variant&>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(value));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(value).value, 0);
+
+    auto copy = container.template resolve<shared_ptr_variant_a>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<shared_ptr_variant_a&>();
+    EXPECT_EQ(selected.value, 0);
+    EXPECT_EQ(&selected, &std::get<shared_ptr_variant_a>(value));
+
+    auto* selected_ptr = container.template resolve<shared_ptr_variant_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<shared_ptr_variant_a>(value));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(shared_test, shared_ptr_custom_sum_factory_selects_alternative) {
+    using container_type = TypeParam;
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<scope<shared>, storage<std::shared_ptr<custom_sum>>,
+                                     factory<function<&make_shared_custom_sum>>>();
+
+    auto whole = container.template resolve<custom_sum>();
+    ASSERT_TRUE(std::holds_alternative<custom_sum_a>(whole.value));
+    EXPECT_EQ(std::get<custom_sum_a>(whole.value).value, 0);
+
+    auto& value = container.template resolve<custom_sum&>();
+    ASSERT_TRUE(std::holds_alternative<custom_sum_a>(value.value));
+    EXPECT_EQ(std::get<custom_sum_a>(value.value).value, 0);
+
+    auto copy = container.template resolve<custom_sum_a>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<custom_sum_a&>();
+    EXPECT_EQ(selected.value, 0);
+    EXPECT_EQ(&selected, &std::get<custom_sum_a>(value.value));
+
+    auto* selected_ptr = container.template resolve<custom_sum_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<custom_sum_a>(value.value));
+
+    ASSERT_THROW(container.template resolve<custom_sum_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<custom_sum_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<custom_sum_b*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(shared_test, unique_ptr_variant_factory_selects_alternative) {
+    using container_type = TypeParam;
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<
+        scope<shared>, storage<std::unique_ptr<shared_ptr_variant>>,
+        factory<function<&make_unique_ptr_variant>>>();
+
+    auto whole = container.template resolve<shared_ptr_variant>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(whole));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(whole).value, 0);
+
+    auto& value = container.template resolve<shared_ptr_variant&>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(value));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(value).value, 0);
+
+    auto copy = container.template resolve<shared_ptr_variant_a>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<shared_ptr_variant_a&>();
+    EXPECT_EQ(selected.value, 0);
+    EXPECT_EQ(&selected, &std::get<shared_ptr_variant_a>(value));
+
+    auto* selected_ptr = container.template resolve<shared_ptr_variant_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<shared_ptr_variant_a>(value));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b*>(),
+                 type_not_convertible_exception);
+}
+
+TYPED_TEST(shared_test, unique_ptr_variant_direct_construction_selects_alternative) {
+    using container_type = TypeParam;
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<
+        scope<shared>, storage<std::unique_ptr<shared_ptr_variant>>,
+        factory<constructor_detection<shared_ptr_variant_a>>>();
+
+    auto whole = container.template resolve<shared_ptr_variant>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(whole));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(whole).value, 0);
+
+    auto& value = container.template resolve<shared_ptr_variant&>();
+    ASSERT_TRUE(std::holds_alternative<shared_ptr_variant_a>(value));
+    EXPECT_EQ(std::get<shared_ptr_variant_a>(value).value, 0);
+
+    auto copy = container.template resolve<shared_ptr_variant_a>();
+    EXPECT_EQ(copy.value, 0);
+
+    auto& selected = container.template resolve<shared_ptr_variant_a&>();
+    EXPECT_EQ(selected.value, 0);
+    EXPECT_EQ(&selected, &std::get<shared_ptr_variant_a>(value));
+
+    auto* selected_ptr = container.template resolve<shared_ptr_variant_a*>();
+    ASSERT_NE(selected_ptr, nullptr);
+    EXPECT_EQ(selected_ptr, &std::get<shared_ptr_variant_a>(value));
+
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<shared_ptr_variant_b*>(),
+                 type_not_convertible_exception);
 }
 
 TYPED_TEST(shared_test, shared_multiple) {
diff --git a/test/storage/unique.cpp b/test/storage/unique.cpp
index 24e992f..8b4ae2a 100644
--- a/test/storage/unique.cpp
+++ b/test/storage/unique.cpp
@@ -19,6 +19,44 @@
 #include "support/test.h"
 
 namespace dingo {
+namespace {
+struct custom_sum_a {
+    explicit custom_sum_a(int init) : value(init) {}
+    int value;
+};
+
+struct custom_sum_b {
+    explicit custom_sum_b(float init) : value(init) {}
+    float value;
+};
+
+struct custom_sum {
+    std::variant<custom_sum_a, custom_sum_b> value;
+};
+} // namespace
+
+template <> struct alternative_type_traits<custom_sum> {
+    static constexpr bool enabled = true;
+
+    using alternatives = type_list<custom_sum_a, custom_sum_b>;
+
+    template <typename Selected, typename Value>
+    static custom_sum wrap(Value&& value) {
+        return custom_sum{
+            std::variant<custom_sum_a, custom_sum_b>(
+                std::in_place_type<Selected>, std::forward<Value>(value))};
+    }
+
+    template <typename Selected> static Selected* get(custom_sum& value) {
+        return std::get_if<Selected>(&value.value);
+    }
+
+    template <typename Selected>
+    static const Selected* get(const custom_sum& value) {
+        return std::get_if<Selected>(&value.value);
+    }
+};
+
 template <typename T> struct unique_test : public test<T> {};
 TYPED_TEST_SUITE(unique_test, container_types, );
 
@@ -240,10 +278,79 @@ TYPED_TEST(unique_test, variant_factory_selects_alternative) {
     ASSERT_TRUE(std::holds_alternative<A>(moved));
     EXPECT_EQ(std::get<A>(moved).value, 0);
 
-    AssertTypeNotFound<
-        std::variant<A, B>,
-        type_list<A, A&&, A*, B, B&&, B*>>(
-        container);
+    auto selected = container.template resolve<A>();
+    EXPECT_EQ(selected.value, 0);
+
+    auto selected_const = container.template resolve<const A>();
+    EXPECT_EQ(selected_const.value, 0);
+
+    auto selected_moved = container.template resolve<A&&>();
+    EXPECT_EQ(selected_moved.value, 0);
+
+    auto selected_const_moved = container.template resolve<const A&&>();
+    EXPECT_EQ(selected_const_moved.value, 0);
+
+    ASSERT_THROW(container.template resolve<B>(), type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<B&&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<A*>(), type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<B*>(), type_not_convertible_exception);
+}
+
+TYPED_TEST(unique_test, variant_explicit_interfaces_override_defaults) {
+    using container_type = TypeParam;
+
+    struct A {
+        explicit A(int init) : value(init) {}
+        int value;
+    };
+    struct B {
+        explicit B(float init) : value(init) {}
+        float value;
+    };
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<
+        scope<unique>, storage<std::variant<A, B>>,
+        factory<constructor_detection<A>>, interfaces<A>>();
+
+    auto selected = container.template resolve<A>();
+    EXPECT_EQ(selected.value, 0);
+
+    ASSERT_THROW((container.template resolve<std::variant<A, B>>()),
+                 type_not_found_exception);
+    ASSERT_THROW(container.template resolve<B>(), type_not_found_exception);
+}
+
+TYPED_TEST(unique_test, custom_alternative_type_factory_selects_alternative) {
+    using container_type = TypeParam;
+
+    container_type container;
+    container.template register_type<scope<unique>, storage<int>>();
+    container.template register_type<scope<unique>, storage<custom_sum>,
+                                     factory<constructor_detection<custom_sum_a>>>();
+
+    auto whole = container.template resolve<custom_sum>();
+    ASSERT_TRUE(std::holds_alternative<custom_sum_a>(whole.value));
+    EXPECT_EQ(std::get<custom_sum_a>(whole.value).value, 0);
+
+    auto moved = container.template resolve<custom_sum&&>();
+    ASSERT_TRUE(std::holds_alternative<custom_sum_a>(moved.value));
+    EXPECT_EQ(std::get<custom_sum_a>(moved.value).value, 0);
+
+    auto selected = container.template resolve<custom_sum_a>();
+    EXPECT_EQ(selected.value, 0);
+
+    auto selected_moved = container.template resolve<custom_sum_a&&>();
+    EXPECT_EQ(selected_moved.value, 0);
+
+    ASSERT_THROW(container.template resolve<custom_sum_b>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<custom_sum_b&&>(),
+                 type_not_convertible_exception);
+    ASSERT_THROW(container.template resolve<custom_sum_a*>(),
+                 type_not_convertible_exception);
 }
 
 // TODO: shared_ptr needs to be passed as &&