diff --git a/packages/builder/src/client_config_builder.rs b/packages/builder/src/client_config_builder.rs
index 727553fdd..2a8c751f4 100644
--- a/packages/builder/src/client_config_builder.rs
+++ b/packages/builder/src/client_config_builder.rs
@@ -3,7 +3,7 @@ use std::{collections::HashMap, sync::{Arc}};
 use polywrap_core::{
     client::{ClientConfig, UriRedirect},
     env::{Env,Envs},
-    resolvers::{uri_resolver_like::UriResolverLike}, 
+    resolution::uri_resolver::UriResolver, 
     uri::Uri, wrapper::Wrapper, package::WrapPackage
 };
 
@@ -298,7 +298,7 @@ impl ClientBuilder for BuilderConfig {
         self
     }
 
-    fn add_resolver(&mut self, resolver: UriResolverLike) -> &mut Self {
+    fn add_resolver(&mut self, resolver: Arc<dyn UriResolver>) -> &mut Self {
         match self.resolvers.as_mut() {
             Some(resolvers) => {
                 resolvers.push(resolver);
@@ -311,7 +311,7 @@ impl ClientBuilder for BuilderConfig {
         self
     }
 
-    fn add_resolvers(&mut self, resolvers: Vec<UriResolverLike>) -> &mut Self {
+    fn add_resolvers(&mut self, resolvers: Vec<Arc<dyn UriResolver>>) -> &mut Self {
         for resolver in resolvers.into_iter() {
             self.add_resolver(resolver);
         }
diff --git a/packages/builder/src/helpers.rs b/packages/builder/src/helpers.rs
index 61ebb44c7..d0450e40c 100644
--- a/packages/builder/src/helpers.rs
+++ b/packages/builder/src/helpers.rs
@@ -2,14 +2,14 @@ use std::sync::Arc;
 
 use polywrap_core::{
     client::ClientConfig,
-    resolvers::{
-        recursive_resolver::RecursiveResolver,
-        static_resolver::{StaticResolver, StaticResolverLike},
+    resolution::{
         uri_resolver::UriResolver,
-        uri_resolver_like::UriResolverLike,
     },
 };
-use polywrap_resolvers::extendable_uri_resolver::ExtendableUriResolver;
+use polywrap_resolvers::{
+    extendable_uri_resolver::ExtendableUriResolver, 
+    static_resolver::{StaticResolverLike, StaticResolver}, recursive_resolver::RecursiveResolver, resolver_vec
+};
 use serde_json::Value;
 
 use crate::types::BuilderConfig;
@@ -47,17 +47,13 @@ pub fn build_resolver(builder: BuilderConfig) -> ClientConfig {
             static_resolvers.push(StaticResolverLike::Redirect(r));
         }
     }
-    let static_resolver = StaticResolver::from(static_resolvers);
-    let extendable_resolver = ExtendableUriResolver::new(None);
-
-    let resolvers = vec![
-        UriResolverLike::Resolver(Arc::new(static_resolver)),
-        UriResolverLike::Resolver(Arc::new(extendable_resolver)),
-    ];
 
     ClientConfig {
         envs: builder.envs.clone(),
         interfaces: builder.interfaces.clone(),
-        resolver: Arc::new(RecursiveResolver::from(resolvers)) as Arc<dyn UriResolver>,
+        resolver: Arc::new(RecursiveResolver::from(resolver_vec![
+            StaticResolver::from(static_resolvers),
+            ExtendableUriResolver::new(None),
+        ])),
     }
 }
diff --git a/packages/builder/src/types.rs b/packages/builder/src/types.rs
index 953e74e72..60fbd10bc 100644
--- a/packages/builder/src/types.rs
+++ b/packages/builder/src/types.rs
@@ -3,9 +3,8 @@ use std::sync::{Arc};
 use polywrap_core::{
     interface_implementation::InterfaceImplementations,
     env::{Envs,Env}, 
-    resolvers::{uri_resolver_like::UriResolverLike},
     uri::Uri, 
-    client::{UriRedirect, ClientConfig}, package::WrapPackage, wrapper::Wrapper
+    client::{UriRedirect, ClientConfig}, package::WrapPackage, wrapper::Wrapper, resolution::uri_resolver::UriResolver
 };
 
 #[derive(Clone)]
@@ -15,7 +14,7 @@ pub struct BuilderConfig {
     pub wrappers: Option<Vec<(Uri, Arc<dyn Wrapper>)>>,
     pub packages: Option<Vec<(Uri, Arc<dyn WrapPackage>)>>,
     pub redirects: Option<Vec<UriRedirect>>,
-    pub resolvers: Option<Vec<UriResolverLike>>,
+    pub resolvers: Option<Vec<Arc<dyn UriResolver>>>,
 }
 
 pub trait ClientBuilder {
@@ -48,8 +47,8 @@ pub trait ClientBuilder {
     fn add_redirect(&mut self, from: Uri, to: Uri) -> &mut Self;
     fn add_redirects(&mut self, redirects: Vec<UriRedirect>) -> &mut Self;
     fn remove_redirect(&mut self, from: &Uri) -> &mut Self;
-    fn add_resolver(&mut self, resolver: UriResolverLike) -> &mut Self;
-    fn add_resolvers(&mut self, resolver: Vec<UriResolverLike>) -> &mut Self;
+    fn add_resolver(&mut self, resolver: Arc<dyn UriResolver>) -> &mut Self;
+    fn add_resolvers(&mut self, resolver: Vec<Arc<dyn UriResolver>>) -> &mut Self;
 }
 
 pub trait ClientConfigHandler {
diff --git a/packages/builder/tests/test_builder.rs b/packages/builder/tests/test_builder.rs
index d6c0c5474..41e991954 100644
--- a/packages/builder/tests/test_builder.rs
+++ b/packages/builder/tests/test_builder.rs
@@ -1,6 +1,6 @@
 #![feature(closure_lifetime_binder)]
 #![feature(trait_upcasting)]
-use std::{collections::HashMap};
+use std::collections::HashMap;
 
 use polywrap_client_builder::types::{BuilderConfig, ClientBuilder};
 use polywrap_core::{
@@ -241,4 +241,4 @@ fn test_wrappers() {
     let mock_wrapper_as_any = &*(mock_wrapper) as &dyn std::any::Any;
     let expected_wrapper = mock_wrapper_as_any.downcast_ref::<MockWrapper>().unwrap();
     assert_eq!(received_wrapper.name, expected_wrapper.name);
-}
\ No newline at end of file
+}
diff --git a/packages/client/src/client.rs b/packages/client/src/client.rs
index 67c5a09ec..52d9d2884 100644
--- a/packages/client/src/client.rs
+++ b/packages/client/src/client.rs
@@ -6,13 +6,13 @@ use polywrap_core::{
     error::Error,
     interface_implementation::InterfaceImplementations,
     invoker::Invoker,
-    resolvers::uri_resolution_context::UriResolutionContext,
-    resolvers::{
+    resolution::uri_resolution_context::UriResolutionContext,
+    resolution::{
         uri_resolution_context::{UriPackageOrWrapper, UriResolutionStep},
-        uri_resolver::{UriResolver, UriResolverHandler}, helpers::get_env_from_resolution_path,
+        uri_resolver::UriResolver, helpers::get_env_from_resolution_path,
     },
     uri::Uri,
-    wrapper::Wrapper, wrap_loader::WrapLoader, wrap_invoker::WrapInvoker,
+    wrapper::Wrapper, wrap_loader::WrapLoader, wrap_invoker::WrapInvoker, uri_resolver_handler::UriResolverHandler,
 };
 use polywrap_msgpack::decode;
 use serde::de::DeserializeOwned;
@@ -138,7 +138,7 @@ impl Invoker for PolywrapClient {
     }
 
     fn get_implementations(&self, uri: &Uri) -> Result<Vec<Uri>, Error> {
-        polywrap_core::resolvers::helpers::get_implementations(uri, self.get_interfaces(), self)
+        polywrap_core::resolution::helpers::get_implementations(uri, self.get_interfaces(), self)
     }
 
     fn get_interfaces(&self) -> Option<InterfaceImplementations> {
@@ -264,12 +264,12 @@ mod client_tests {
         client::ClientConfig,
         error::Error,
         invoker::Invoker,
-        resolvers::{
+        resolution::{
             uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-            uri_resolver::{UriResolver, UriResolverHandler},
+            uri_resolver::UriResolver,
         },
         uri::Uri,
-        wrapper::{GetFileOptions, Wrapper}, wrap_loader::WrapLoader,
+        wrapper::{GetFileOptions, Wrapper}, wrap_loader::WrapLoader, uri_resolver_handler::UriResolverHandler,
     };
     use std::sync::Arc;
 
diff --git a/packages/client/src/subinvoker.rs b/packages/client/src/subinvoker.rs
index 75369a535..f61fa5f45 100644
--- a/packages/client/src/subinvoker.rs
+++ b/packages/client/src/subinvoker.rs
@@ -1,7 +1,7 @@
 use std::sync::{Mutex, Arc};
 
 use polywrap_core::{
-    resolvers::uri_resolution_context::UriResolutionContext, 
+    resolution::uri_resolution_context::UriResolutionContext, 
     invoker::Invoker, env::Env, error::Error, uri::Uri, interface_implementation::InterfaceImplementations
 };
 
diff --git a/packages/client/tests/test_env_with_invoke.rs b/packages/client/tests/test_env_with_invoke.rs
index bf30a6222..94ff55180 100644
--- a/packages/client/tests/test_env_with_invoke.rs
+++ b/packages/client/tests/test_env_with_invoke.rs
@@ -4,12 +4,13 @@ use polywrap_client::msgpack::msgpack;
 
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::recursive_resolver::RecursiveResolver;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolution_context::UriPackageOrWrapper;
-use polywrap_core::resolvers::uri_resolver_like::UriResolverLike;
+use polywrap_core::resolution::uri_resolution_context::UriPackageOrWrapper;
+use polywrap_core::resolution::uri_resolver::UriResolver;
 use polywrap_resolvers::base_resolver::BaseResolver;
+use polywrap_resolvers::recursive_resolver::RecursiveResolver;
+use polywrap_resolvers::resolver_vec;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -278,14 +279,13 @@ fn env_can_be_registered_for_any_uri_in_resolution_path() {
             let file_reader = SimpleFileReader::new();
             let fs_resolver = FilesystemResolver::new(Arc::new(file_reader));
         
-            // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
-            let base_resolver = RecursiveResolver::from(vec![
-                UriResolverLike::Resolver(Arc::new(StaticResolver::new(resolvers))),
-                UriResolverLike::Resolver(Arc::new(fs_resolver)),
-            ]);
             let config = ClientConfig {
                 envs: Some(envs),
-                resolver: Arc::new(base_resolver),
+                // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
+                resolver: Arc::new(RecursiveResolver::from(resolver_vec![
+                    StaticResolver::new(resolvers),
+                    fs_resolver,
+                ])),
                 interfaces: None,
             };
             
@@ -322,14 +322,13 @@ fn env_can_be_registered_for_any_uri_in_resolution_path() {
             let file_reader = SimpleFileReader::new();
             let fs_resolver = FilesystemResolver::new(Arc::new(file_reader));
         
-            // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
-            let base_resolver = RecursiveResolver::from(vec![
-                UriResolverLike::Resolver(Arc::new(StaticResolver::new(resolvers))),
-                UriResolverLike::Resolver(Arc::new(fs_resolver)),
-            ]);
             let config = ClientConfig {
                 envs: Some(envs),
-                resolver: Arc::new(base_resolver),
+                // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
+                resolver: Arc::new(RecursiveResolver::from(resolver_vec![
+                    StaticResolver::new(resolvers),
+                    fs_resolver,
+                ])),
                 interfaces: None,
             };
             
diff --git a/packages/client/tests/test_env_with_subinvoke.rs b/packages/client/tests/test_env_with_subinvoke.rs
index 5bf65b5ab..dfac40062 100644
--- a/packages/client/tests/test_env_with_subinvoke.rs
+++ b/packages/client/tests/test_env_with_subinvoke.rs
@@ -4,10 +4,10 @@ use polywrap_client::msgpack::msgpack;
 
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolution_context::UriPackageOrWrapper;
+use polywrap_core::resolution::uri_resolution_context::UriPackageOrWrapper;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/packages/client/tests/test_interface_implementation.rs b/packages/client/tests/test_interface_implementation.rs
index bfb99e640..f7a671306 100644
--- a/packages/client/tests/test_interface_implementation.rs
+++ b/packages/client/tests/test_interface_implementation.rs
@@ -4,9 +4,9 @@ use polywrap_client::msgpack::msgpack;
 
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::Deserialize;
 use std::collections::HashMap;
diff --git a/packages/client/tests/test_map_type.rs b/packages/client/tests/test_map_type.rs
index e047a6c49..e2cad2b4d 100644
--- a/packages/client/tests/test_map_type.rs
+++ b/packages/client/tests/test_map_type.rs
@@ -7,9 +7,9 @@ use polywrap_client::core::uri::Uri;
 use polywrap_client::plugin::Map;
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::{Deserialize, Serialize};
 
diff --git a/packages/client/tests/test_plugin_invocation.rs b/packages/client/tests/test_plugin_invocation.rs
index 616c7dee7..2796da1bb 100644
--- a/packages/client/tests/test_plugin_invocation.rs
+++ b/packages/client/tests/test_plugin_invocation.rs
@@ -1,8 +1,9 @@
 
 use JSON::{json, from_value, Value};
 use polywrap_client::client::PolywrapClient;
-use polywrap_core::{invoker::{Invoker}, env::Env, resolvers::static_resolver::{StaticResolverLike, StaticResolver}, package::WrapPackage, uri::Uri, client::ClientConfig};
+use polywrap_core::{invoker::{Invoker}, env::Env, package::WrapPackage, uri::Uri, client::ClientConfig};
 use polywrap_msgpack::msgpack;
+use polywrap_resolvers::static_resolver::{StaticResolver, StaticResolverLike};
 use wrap_manifest_schemas::versions::{WrapManifest, WrapManifestAbi};
 use std::{sync::Arc, collections::HashMap};
 use serde_json as JSON;
diff --git a/packages/client/tests/test_uri_resolvers.rs b/packages/client/tests/test_uri_resolvers.rs
index 4055eefad..459c04c0d 100644
--- a/packages/client/tests/test_uri_resolvers.rs
+++ b/packages/client/tests/test_uri_resolvers.rs
@@ -6,19 +6,15 @@ use std::sync::Arc;
 use polywrap_client::client::PolywrapClient;
 use polywrap_client::resolvers::uri_resolver_wrapper::UriResolverWrapper;
 
-use polywrap_client::core::{
-    resolvers::{
-        uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-    },
-    uri::Uri,
-};
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
 use polywrap_core::interface_implementation::InterfaceImplementations;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolver::UriResolver;
+use polywrap_core::resolution::uri_resolution_context::{UriResolutionContext, UriPackageOrWrapper};
+use polywrap_core::resolution::uri_resolver::UriResolver;
+use polywrap_core::uri::Uri;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use polywrap_wasm::wasm_wrapper::WasmWrapper;
 
diff --git a/packages/client/tests/tests_subinvoke.rs b/packages/client/tests/tests_subinvoke.rs
index ffa7c29c5..4fedeb420 100644
--- a/packages/client/tests/tests_subinvoke.rs
+++ b/packages/client/tests/tests_subinvoke.rs
@@ -5,11 +5,11 @@ use polywrap_client::client::PolywrapClient;
 use polywrap_client::core::uri::Uri;
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolution_context::UriPackageOrWrapper;
+use polywrap_core::resolution::uri_resolution_context::UriPackageOrWrapper;
 use polywrap_msgpack::msgpack;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 
 #[test]
diff --git a/packages/core/src/client.rs b/packages/core/src/client.rs
index 1645ba03a..bf7dd598c 100644
--- a/packages/core/src/client.rs
+++ b/packages/core/src/client.rs
@@ -2,9 +2,10 @@ use std::sync::Arc;
 
 use crate::uri::Uri;
 use crate::interface_implementation::InterfaceImplementations;
-use crate::resolvers::uri_resolver::{UriResolverHandler, UriResolver};
+use crate::resolution::uri_resolver::UriResolver;
 use crate::env::Envs;
 use crate::invoker::Invoker;
+use crate::uri_resolver_handler::UriResolverHandler;
 use crate::wrap_invoker::WrapInvoker;
 use crate::wrap_loader::WrapLoader;
 
diff --git a/packages/core/src/invoker.rs b/packages/core/src/invoker.rs
index 00707de41..acca959ff 100644
--- a/packages/core/src/invoker.rs
+++ b/packages/core/src/invoker.rs
@@ -1,5 +1,5 @@
 use crate::{
-    error::Error, uri::Uri, resolvers::uri_resolution_context::UriResolutionContext, env::Env, 
+    error::Error, uri::Uri, resolution::uri_resolution_context::UriResolutionContext, env::Env, 
     interface_implementation::InterfaceImplementations,
 };
 pub trait Invoker: Send + Sync {
diff --git a/packages/core/src/lib.rs b/packages/core/src/lib.rs
index 7a572be88..6e33cf1c7 100644
--- a/packages/core/src/lib.rs
+++ b/packages/core/src/lib.rs
@@ -10,4 +10,5 @@ pub mod package;
 pub mod file_reader;
 pub mod env;
 pub mod interface_implementation;
-pub mod resolvers;
+pub mod uri_resolver_handler;
+pub mod resolution;
diff --git a/packages/core/src/resolvers/get_uri_resolution_path.rs b/packages/core/src/resolution/get_uri_resolution_path.rs
similarity index 100%
rename from packages/core/src/resolvers/get_uri_resolution_path.rs
rename to packages/core/src/resolution/get_uri_resolution_path.rs
diff --git a/packages/core/src/resolvers/helpers.rs b/packages/core/src/resolution/helpers.rs
similarity index 100%
rename from packages/core/src/resolvers/helpers.rs
rename to packages/core/src/resolution/helpers.rs
diff --git a/packages/core/src/resolution/mod.rs b/packages/core/src/resolution/mod.rs
new file mode 100644
index 000000000..281e32f26
--- /dev/null
+++ b/packages/core/src/resolution/mod.rs
@@ -0,0 +1,4 @@
+pub mod uri_resolver;
+pub mod uri_resolution_context;
+pub mod helpers;
+pub mod get_uri_resolution_path;
diff --git a/packages/core/src/resolvers/uri_resolution_context.rs b/packages/core/src/resolution/uri_resolution_context.rs
similarity index 99%
rename from packages/core/src/resolvers/uri_resolution_context.rs
rename to packages/core/src/resolution/uri_resolution_context.rs
index f03692fa0..d5eef9b46 100644
--- a/packages/core/src/resolvers/uri_resolution_context.rs
+++ b/packages/core/src/resolution/uri_resolution_context.rs
@@ -1,7 +1,7 @@
 use crate::{package::WrapPackage, wrapper::Wrapper, error::Error};
 use std::{collections::HashMap, sync::Arc, vec};
 
-use crate::{uri::Uri};
+use crate::uri::Uri;
 
 #[derive(Clone)]
 pub enum UriPackageOrWrapper {
diff --git a/packages/core/src/resolution/uri_resolver.rs b/packages/core/src/resolution/uri_resolver.rs
new file mode 100644
index 000000000..ea94a6eb7
--- /dev/null
+++ b/packages/core/src/resolution/uri_resolver.rs
@@ -0,0 +1,16 @@
+use std::fmt::Debug;
+use std::sync::Arc;
+
+use crate::error::Error;
+use crate::invoker::Invoker;
+use crate::uri::Uri;
+use super::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext};
+
+pub trait UriResolver: Send + Sync + Debug {
+    fn try_resolve_uri(
+        &self,
+        uri: &Uri,
+        client: Arc<dyn Invoker>,
+        resolution_context: &mut UriResolutionContext,
+    ) -> Result<UriPackageOrWrapper, Error>;
+}
diff --git a/packages/core/src/resolvers/mod.rs b/packages/core/src/resolvers/mod.rs
deleted file mode 100644
index e572df884..000000000
--- a/packages/core/src/resolvers/mod.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-pub mod uri_resolver_aggregator_base;
-pub mod uri_resolver_like;
-pub mod uri_resolver;
-pub mod uri_resolution_context;
-pub mod static_resolver;
-pub mod uri_resolver_aggregator;
-pub mod wrapper_resolver;
-pub mod resolver_with_history;
-pub mod helpers;
-pub mod get_uri_resolution_path;
-pub mod package_resolver;
-pub mod redirect_resolver;
-pub mod recursive_resolver;
-pub mod with_loop_guard_resolver;
\ No newline at end of file
diff --git a/packages/core/src/resolvers/package_resolver.rs b/packages/core/src/resolvers/package_resolver.rs
deleted file mode 100644
index 6214f960f..000000000
--- a/packages/core/src/resolvers/package_resolver.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use core::fmt;
-use std::sync::{Arc};
-
-use crate::{uri::Uri, package::WrapPackage, invoker::Invoker};
-
-use super::{resolver_with_history::ResolverWithHistory, uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext}};
-
-pub struct PackageResolver {
-  pub uri: Uri,
-  pub package: Arc<dyn WrapPackage>
-}
-
-impl PackageResolver {}
-
-impl ResolverWithHistory for PackageResolver {
-  fn get_step_description(&self, _: &crate::uri::Uri) -> String {
-      format!("Package ({})", self.uri)
-  }
-
-  fn _try_resolve_uri(&self, uri: &Uri, _: Arc<dyn Invoker>, _: &mut UriResolutionContext) -> Result<UriPackageOrWrapper, crate::error::Error> {
-    if uri.to_string() != self.uri.to_string() {
-      Ok(UriPackageOrWrapper::Uri(uri.clone()))
-    } else {
-      Ok(UriPackageOrWrapper::Package(uri.clone(), self.package.clone()))
-    }
-  }
-}
-
-impl fmt::Debug for PackageResolver {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-      write!(f, "PackageResolver: {}", self.uri)
-  }
-}
\ No newline at end of file
diff --git a/packages/core/src/resolvers/redirect_resolver.rs b/packages/core/src/resolvers/redirect_resolver.rs
deleted file mode 100644
index 828d7da17..000000000
--- a/packages/core/src/resolvers/redirect_resolver.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use core::fmt;
-use std::sync::Arc;
-use crate::{uri::Uri, invoker::Invoker};
-
-use super::{
-    resolver_with_history::ResolverWithHistory,
-    uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-};
-
-pub struct RedirectResolver {
-    pub from: Uri,
-    pub to: Uri,
-}
-
-impl RedirectResolver {}
-
-impl ResolverWithHistory for RedirectResolver {
-    fn get_step_description(&self, _: &crate::uri::Uri) -> String {
-        format!(
-            "Redirect ({} - {})",
-            self.from,
-            self.to
-        )
-    }
-
-    fn _try_resolve_uri(
-        &self,
-        uri: &Uri,
-        _: Arc<dyn Invoker>,
-        _: &mut UriResolutionContext,
-    ) -> Result<UriPackageOrWrapper, crate::error::Error> {
-        if uri.to_string() != self.from.to_string() {
-            Ok(UriPackageOrWrapper::Uri(uri.clone()))
-        } else {
-            Ok(UriPackageOrWrapper::Uri(self.to.clone()))
-        }
-    }
-}
-
-impl fmt::Debug for RedirectResolver {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-      write!(f, "RedirectResolver: {} - {}", self.from, self.to)
-  }
-}
\ No newline at end of file
diff --git a/packages/core/src/resolvers/resolver_with_history.rs b/packages/core/src/resolvers/resolver_with_history.rs
deleted file mode 100644
index 0af63091a..000000000
--- a/packages/core/src/resolvers/resolver_with_history.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use std::{fmt::Debug, sync::Arc};
-
-use crate::{
-    error::Error,
-    uri::Uri,
-    resolvers::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext, UriResolutionStep},
-    resolvers::uri_resolver::UriResolver, invoker::Invoker
-};
-
-pub trait ResolverWithHistory: Send + Sync {
-  fn get_step_description(&self, uri: &Uri) -> String;
-  fn _try_resolve_uri(&self, uri: &Uri, invoker: Arc<dyn Invoker>, resolution_ctx: &mut UriResolutionContext) -> Result<UriPackageOrWrapper, Error>;
-}
-
-impl<T: ResolverWithHistory + Debug> UriResolver for T {
-  fn try_resolve_uri(&self, uri: &Uri, invoker: Arc<dyn Invoker>, resolution_ctx: &mut UriResolutionContext) -> Result<UriPackageOrWrapper, Error> {
-    let result = self._try_resolve_uri(uri, invoker, resolution_ctx);
-
-    let resolution_step = UriResolutionStep {
-      source_uri: uri.clone(),
-      description: Some(self.get_step_description(uri)),
-      sub_history: None,
-      result: match &result {
-          Ok(r) => Ok(r.clone()),
-          Err(e) => Err(Error::ResolutionError(e.to_string()))
-      }
-    };
-
-    resolution_ctx.track_step(resolution_step);
-
-    result
-  }
-}
diff --git a/packages/core/src/resolvers/uri_resolver.rs b/packages/core/src/resolvers/uri_resolver.rs
deleted file mode 100644
index b966066e8..000000000
--- a/packages/core/src/resolvers/uri_resolver.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use std::fmt::Debug;
-use std::sync::Arc;
-
-use crate::error::Error;
-use crate::invoker::Invoker;
-use crate::uri::Uri;
-use super::package_resolver::PackageResolver;
-use super::redirect_resolver::RedirectResolver;
-use super::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext};
-use super::uri_resolver_aggregator::UriResolverAggregator;
-use super::uri_resolver_like::UriResolverLike;
-use super::wrapper_resolver::WrapperResolver;
-
-pub trait UriResolverHandler {
-    fn try_resolve_uri(
-        &self,
-        uri: &Uri,
-        resolution_context: Option<&mut UriResolutionContext>,
-    ) -> Result<UriPackageOrWrapper, Error>;
-}
-
-pub trait UriResolver: Send + Sync + Debug {
-    fn try_resolve_uri(
-        &self,
-        uri: &Uri,
-        client: Arc<dyn Invoker>,
-        resolution_context: &mut UriResolutionContext,
-    ) -> Result<UriPackageOrWrapper, Error>;
-}
-
-impl From<UriResolverLike> for Arc<dyn UriResolver> {
-    fn from(resolver_like: UriResolverLike) -> Self {
-        match resolver_like {
-          UriResolverLike::ResolverLike(arr) => {
-            let resolvers = arr.into_iter().map(|r| {
-              let resolver: Arc<dyn UriResolver> = r.into();
-              resolver
-            }).collect();
-
-            Arc::new(UriResolverAggregator::new(
-              resolvers
-            ))
-          },
-          UriResolverLike::Resolver(resolver) => resolver,
-          UriResolverLike::Redirect(redirect) => {
-            Arc::new(RedirectResolver {
-              from: redirect.from,
-              to: redirect.to
-            })
-          },
-          UriResolverLike::Package(uri, package) => {
-            Arc::new(PackageResolver {
-              uri,
-              package,
-            })
-          },
-          UriResolverLike::Wrapper(uri, wrapper) => {
-            Arc::new(WrapperResolver {
-              uri,
-              wrapper,
-            })
-          },
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/core/src/resolvers/uri_resolver_like.rs b/packages/core/src/resolvers/uri_resolver_like.rs
deleted file mode 100644
index df44874d1..000000000
--- a/packages/core/src/resolvers/uri_resolver_like.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use std::sync::{Arc};
-
-use crate::{client::UriRedirect, wrapper::Wrapper, package::WrapPackage, uri::Uri};
-
-use super::{uri_resolver::UriResolver};
-
-#[derive(Clone)]
-pub enum UriResolverLike {
-  Resolver(Arc<dyn UriResolver>),
-  Redirect(UriRedirect),
-  Package(Uri, Arc<dyn WrapPackage>),
-  Wrapper(Uri, Arc<dyn Wrapper>),
-  ResolverLike(Vec<UriResolverLike>),
-}
\ No newline at end of file
diff --git a/packages/core/src/resolvers/wrapper_resolver.rs b/packages/core/src/resolvers/wrapper_resolver.rs
deleted file mode 100644
index 2c6d5acc6..000000000
--- a/packages/core/src/resolvers/wrapper_resolver.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use core::fmt;
-use std::sync::{Arc};
-
-use crate::{uri::Uri, wrapper::Wrapper, invoker::Invoker};
-
-use super::{
-    resolver_with_history::ResolverWithHistory,
-    uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-};
-
-pub struct WrapperResolver {
-    pub uri: Uri,
-    pub wrapper: Arc<dyn Wrapper>,
-}
-
-impl WrapperResolver {}
-
-impl ResolverWithHistory for WrapperResolver {
-    fn get_step_description(&self, _: &crate::uri::Uri) -> String {
-        format!("Wrapper ({})", self.uri)
-    }
-
-    fn _try_resolve_uri(
-        &self,
-        uri: &Uri,
-        _: Arc<dyn Invoker>,
-        _: &mut UriResolutionContext,
-    ) -> Result<UriPackageOrWrapper, crate::error::Error> {
-        if uri.to_string() != self.uri.to_string() {
-            Ok(UriPackageOrWrapper::Uri(uri.clone()))
-        } else {
-            Ok(UriPackageOrWrapper::Wrapper(
-                uri.clone(),
-                self.wrapper.clone(),
-            ))
-        }
-    }
-}
-
-impl fmt::Debug for WrapperResolver {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-      write!(f, "WrapperResolver: {}", self.uri)
-  }
-}
\ No newline at end of file
diff --git a/packages/core/src/uri.rs b/packages/core/src/uri.rs
index 34831ad9a..8460edb67 100644
--- a/packages/core/src/uri.rs
+++ b/packages/core/src/uri.rs
@@ -1,7 +1,8 @@
-use crate::error::Error;
 use serde::Serialize;
 use regex::Regex;
 
+use crate::error::Error;
+
 #[derive(Clone,Serialize,Debug)]
 pub struct Uri {
     pub authority: String,
diff --git a/packages/core/src/uri_resolver_handler.rs b/packages/core/src/uri_resolver_handler.rs
new file mode 100644
index 000000000..fdba11d37
--- /dev/null
+++ b/packages/core/src/uri_resolver_handler.rs
@@ -0,0 +1,9 @@
+use crate::{error::Error, uri::Uri, resolution::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext}};
+
+pub trait UriResolverHandler {
+  fn try_resolve_uri(
+      &self,
+      uri: &Uri,
+      resolution_context: Option<&mut UriResolutionContext>,
+  ) -> Result<UriPackageOrWrapper, Error>;
+}
diff --git a/packages/core/src/wrap_invoker.rs b/packages/core/src/wrap_invoker.rs
index 22270bc01..270e956d6 100644
--- a/packages/core/src/wrap_invoker.rs
+++ b/packages/core/src/wrap_invoker.rs
@@ -1,4 +1,4 @@
-use crate::{resolvers::uri_resolution_context::UriResolutionContext, error::Error, wrapper::Wrapper, uri::Uri, env::Env};
+use crate::{resolution::uri_resolution_context::UriResolutionContext, error::Error, wrapper::Wrapper, uri::Uri, env::Env};
 
 pub trait WrapInvoker: Send + Sync {
   fn invoke_wrapper_raw(
diff --git a/packages/core/src/wrap_loader.rs b/packages/core/src/wrap_loader.rs
index 2026d0244..fc6d0bdea 100644
--- a/packages/core/src/wrap_loader.rs
+++ b/packages/core/src/wrap_loader.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::{resolvers::uri_resolution_context::UriResolutionContext, error::Error, wrapper::Wrapper, uri::Uri};
+use crate::{resolution::uri_resolution_context::UriResolutionContext, error::Error, wrapper::Wrapper, uri::Uri};
 
 pub trait WrapLoader: Send + Sync {
   fn load_wrapper(
diff --git a/packages/resolvers/src/base_resolver.rs b/packages/resolvers/src/base_resolver.rs
index 2efa3e183..80e2df6c2 100644
--- a/packages/resolvers/src/base_resolver.rs
+++ b/packages/resolvers/src/base_resolver.rs
@@ -3,8 +3,8 @@ use std::sync::Arc;
 use polywrap_core::{
     error::Error,
     uri::Uri,
-    resolvers::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-    resolvers::uri_resolver::UriResolver, invoker::Invoker,
+    resolution::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
+    resolution::uri_resolver::UriResolver, invoker::Invoker,
 };
 
 pub struct BaseResolver {
diff --git a/packages/resolvers/src/extendable_uri_resolver.rs b/packages/resolvers/src/extendable_uri_resolver.rs
index 9bec8704a..4172e3710 100644
--- a/packages/resolvers/src/extendable_uri_resolver.rs
+++ b/packages/resolvers/src/extendable_uri_resolver.rs
@@ -1,19 +1,18 @@
 use core::fmt;
 use std::sync::Arc;
 use polywrap_core::{
-    resolvers::{
+    resolution::{
         uri_resolution_context::{
             UriResolutionContext,
             UriPackageOrWrapper
         },
-        uri_resolver_aggregator_base::UriResolverAggregatorBase,
         uri_resolver::UriResolver
     },
     uri::Uri,
     error::Error, invoker::Invoker
 };
 
-use crate::uri_resolver_wrapper::UriResolverWrapper;
+use crate::{uri_resolver_wrapper::UriResolverWrapper, uri_resolver_aggregator_base::UriResolverAggregatorBase};
 
 pub struct ExtendableUriResolver {
     name: Option<String>
diff --git a/packages/resolvers/src/lib.rs b/packages/resolvers/src/lib.rs
index 8a0822457..c7a6752d7 100644
--- a/packages/resolvers/src/lib.rs
+++ b/packages/resolvers/src/lib.rs
@@ -1,4 +1,13 @@
 pub mod uri_resolver_wrapper;
 pub mod extendable_uri_resolver;
 pub mod simple_file_resolver;
-pub mod base_resolver;
\ No newline at end of file
+pub mod base_resolver;
+pub mod redirect_resolver;
+pub mod wrapper_resolver;
+pub mod package_resolver;
+pub mod static_resolver;
+pub mod recursive_resolver;
+pub mod uri_resolver_aggregator;
+pub mod uri_resolver_aggregator_base;
+pub mod resolver_with_loop_guard;
+pub mod resolver_vec;
\ No newline at end of file
diff --git a/packages/resolvers/src/package_resolver.rs b/packages/resolvers/src/package_resolver.rs
new file mode 100644
index 000000000..6bf983b41
--- /dev/null
+++ b/packages/resolvers/src/package_resolver.rs
@@ -0,0 +1,42 @@
+use core::fmt;
+use std::sync::{Arc};
+
+use polywrap_core::{uri::Uri, package::WrapPackage, invoker::Invoker, resolution::{uri_resolution_context::{UriResolutionContext, UriPackageOrWrapper, UriResolutionStep}, uri_resolver::UriResolver}, error::Error};
+
+pub struct PackageResolver {
+    pub uri: Uri,
+    pub package: Arc<dyn WrapPackage>
+}
+
+impl PackageResolver {
+}
+
+impl UriResolver for PackageResolver {
+    fn try_resolve_uri(&self, uri: &Uri, _: Arc<dyn Invoker>, resolution_context: &mut UriResolutionContext) -> Result<UriPackageOrWrapper, Error> {
+        let result: Result<UriPackageOrWrapper, Error> = { 
+          if uri.to_string() != self.uri.to_string() {
+            Ok(UriPackageOrWrapper::Uri(uri.clone()))
+          } else {
+            Ok(UriPackageOrWrapper::Package(uri.clone(), self.package.clone()))
+          }
+        };
+
+        resolution_context.track_step(UriResolutionStep {
+            source_uri: uri.clone(),
+            description: Some(format!("Package ({})", self.uri)),
+            result: match &result {
+                Ok(r) => Ok(r.clone()),
+                Err(e) => Err(Error::ResolutionError(e.to_string()))
+            },
+            sub_history: None,
+        });
+
+        result
+    }
+}
+
+impl fmt::Debug for PackageResolver {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "PackageResolver: {}", self.uri)
+    }
+}
diff --git a/packages/core/src/resolvers/recursive_resolver.rs b/packages/resolvers/src/recursive_resolver.rs
similarity index 68%
rename from packages/core/src/resolvers/recursive_resolver.rs
rename to packages/resolvers/src/recursive_resolver.rs
index 8f9e077a7..01106a8e2 100644
--- a/packages/core/src/resolvers/recursive_resolver.rs
+++ b/packages/resolvers/src/recursive_resolver.rs
@@ -1,44 +1,38 @@
 use core::fmt;
 use std::sync::Arc;
 
-use crate::{
+use polywrap_core::{
     error::Error,
-    resolvers::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-    resolvers::uri_resolver::UriResolver,
+    resolution::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
+    resolution::uri_resolver::UriResolver,
     uri::Uri, invoker::Invoker,
 };
 
-use super::{uri_resolver_like::UriResolverLike, uri_resolver_aggregator::UriResolverAggregator};
+use crate::uri_resolver_aggregator::UriResolverAggregator;
 
 pub struct RecursiveResolver {
     resolver: Arc<dyn UriResolver>,
 }
 
-impl From<Vec<UriResolverLike>> for RecursiveResolver {
-    fn from(resolver_likes: Vec<UriResolverLike>) -> Self {
-        let resolvers = resolver_likes
-            .into_iter()
-            .map(|resolver_like| {
-                let resolver: Arc<dyn UriResolver> = resolver_like.into();
-
-                resolver
-            })
-            .collect();
+impl From<Vec<Box<dyn UriResolver>>> for RecursiveResolver {
+    fn from(resolvers: Vec<Box<dyn UriResolver>>) -> Self {
+        RecursiveResolver::from(
+            UriResolverAggregator::from(resolvers)
+        )
+    }
+}
 
+impl From<UriResolverAggregator> for RecursiveResolver {
+    fn from(resolver: UriResolverAggregator) -> Self {
         RecursiveResolver::new(
-            Arc::new(
-                UriResolverAggregator::new(
-                    resolvers
-                )
-            )
+            Arc::new(resolver)
         )
     }
 }
 
-impl From<UriResolverLike> for RecursiveResolver {
-    fn from(resolver_like: UriResolverLike) -> Self {
-        let resolver: Arc<dyn UriResolver> = resolver_like.into();
-        RecursiveResolver::new(resolver)
+impl From<Box<dyn UriResolver>> for RecursiveResolver {
+    fn from(resolver: Box<dyn UriResolver>) -> Self {
+        RecursiveResolver::new(Arc::from(resolver))
     }
 }
 
diff --git a/packages/resolvers/src/redirect_resolver.rs b/packages/resolvers/src/redirect_resolver.rs
new file mode 100644
index 000000000..5504a1a64
--- /dev/null
+++ b/packages/resolvers/src/redirect_resolver.rs
@@ -0,0 +1,55 @@
+use core::fmt;
+use std::sync::Arc;
+use polywrap_core::resolution::uri_resolution_context::UriResolutionStep;
+use polywrap_core::resolution::uri_resolver::UriResolver;
+use polywrap_core::{error::Error, uri::Uri, invoker::Invoker};
+
+use polywrap_core::resolution::{
+    uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
+};
+
+pub struct RedirectResolver {
+    pub from: Uri,
+    pub to: Uri,
+}
+
+impl RedirectResolver {}
+
+impl UriResolver for RedirectResolver {
+    fn try_resolve_uri(
+        &self,
+        uri: &Uri,
+        _: Arc<dyn Invoker>,
+        resolution_context: &mut UriResolutionContext,
+    ) -> Result<UriPackageOrWrapper, Error> {
+        let result: Result<UriPackageOrWrapper, Error> = { 
+            if uri.to_string() != self.from.to_string() {
+                Ok(UriPackageOrWrapper::Uri(uri.clone()))
+            } else {
+                Ok(UriPackageOrWrapper::Uri(self.to.clone()))
+            }
+        };
+
+        resolution_context.track_step(UriResolutionStep {
+            source_uri: uri.clone(),
+            description: Some(  format!(
+                "Redirect ({} - {})",
+                self.from,
+                self.to
+            )),
+            result: match &result {
+                Ok(r) => Ok(r.clone()),
+                Err(e) => Err(Error::ResolutionError(e.to_string()))
+            },
+            sub_history: None,
+        });
+
+        result
+    }
+}
+
+impl fmt::Debug for RedirectResolver {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+      write!(f, "RedirectResolver: {} - {}", self.from, self.to)
+  }
+}
diff --git a/packages/resolvers/src/resolver_vec.rs b/packages/resolvers/src/resolver_vec.rs
new file mode 100644
index 000000000..4b226d9f6
--- /dev/null
+++ b/packages/resolvers/src/resolver_vec.rs
@@ -0,0 +1,6 @@
+#[macro_export]
+macro_rules! resolver_vec {
+  ($($resolver:expr),* $(,)?) => {
+      vec![$(Box::from($resolver) as Box<dyn UriResolver>),*] as Vec<Box<dyn UriResolver>>
+  };
+}
diff --git a/packages/core/src/resolvers/with_loop_guard_resolver.rs b/packages/resolvers/src/resolver_with_loop_guard.rs
similarity index 50%
rename from packages/core/src/resolvers/with_loop_guard_resolver.rs
rename to packages/resolvers/src/resolver_with_loop_guard.rs
index 71f64a6b6..1c3d034f3 100644
--- a/packages/core/src/resolvers/with_loop_guard_resolver.rs
+++ b/packages/resolvers/src/resolver_with_loop_guard.rs
@@ -1,24 +1,17 @@
 use core::fmt;
-use std::{sync::Arc};
+use std::sync::Arc;
 
-use crate::{error::Error, invoker::Invoker};
-
-use super::{uri_resolver_like::UriResolverLike, uri_resolver::UriResolver, uri_resolution_context::{UriResolutionContext, UriPackageOrWrapper}};
+use polywrap_core::{
+  error::Error, invoker::Invoker, uri::Uri, 
+  resolution::{uri_resolver::UriResolver, uri_resolution_context::{UriResolutionContext, UriPackageOrWrapper}}
+};
 
 pub struct ResolverWithLoopGuard {
-  pub resolver: Arc<dyn UriResolver>,
-}
-
-impl From<UriResolverLike> for ResolverWithLoopGuard {
-    fn from(resolver_like: UriResolverLike) -> Self {
-        let resolver: Arc<dyn UriResolver> = resolver_like.into();
-
-        Self { resolver }
-    }
+    pub resolver: Arc<dyn UriResolver>,
 }
 
 impl UriResolver for ResolverWithLoopGuard {
-    fn try_resolve_uri(&self, uri: &crate::uri::Uri, invoker: Arc<dyn Invoker>, resolution_context: &mut UriResolutionContext) -> Result<UriPackageOrWrapper, Error> {
+    fn try_resolve_uri(&self, uri: &Uri, invoker: Arc<dyn Invoker>, resolution_context: &mut UriResolutionContext) -> Result<UriPackageOrWrapper, Error> {
         if resolution_context.is_resolving(uri) {
           //TODO handle this error
           Err(Error::ResolverError("Infinite Loop".to_string()))
diff --git a/packages/resolvers/src/simple_file_resolver.rs b/packages/resolvers/src/simple_file_resolver.rs
index 0fb83ce50..c7d245d65 100644
--- a/packages/resolvers/src/simple_file_resolver.rs
+++ b/packages/resolvers/src/simple_file_resolver.rs
@@ -4,8 +4,7 @@ use polywrap_core::{
     error::Error,
     file_reader::FileReader,
     uri::Uri,
-    resolvers::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-    resolvers::uri_resolver::UriResolver, invoker::Invoker,
+    resolution::{uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext}, uri_resolver::UriResolver}, invoker::Invoker,
 };
 use polywrap_wasm::{
     wasm_package::WasmPackage,
diff --git a/packages/core/src/resolvers/static_resolver.rs b/packages/resolvers/src/static_resolver.rs
similarity index 94%
rename from packages/core/src/resolvers/static_resolver.rs
rename to packages/resolvers/src/static_resolver.rs
index 4d7818738..e784ab125 100644
--- a/packages/core/src/resolvers/static_resolver.rs
+++ b/packages/resolvers/src/static_resolver.rs
@@ -1,13 +1,13 @@
 use core::fmt;
 use std::{collections::HashMap, sync::{Arc}};
-use crate::{
-    client::{UriRedirect},
+use polywrap_core::{
+    client::UriRedirect,
     error::Error,
     uri::Uri,
-    resolvers::uri_resolution_context::{
+    resolution::uri_resolution_context::{
       UriPackageOrWrapper, UriResolutionContext, UriResolutionStep,
     },
-    resolvers::uri_resolver::UriResolver, package::WrapPackage, wrapper::Wrapper, invoker::Invoker,
+    resolution::uri_resolver::UriResolver, package::WrapPackage, wrapper::Wrapper, invoker::Invoker,
 };
 
 pub enum StaticResolverLike {
@@ -105,4 +105,4 @@ impl fmt::Debug for StaticResolver {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
       write!(f, "StaticResolver")
   }
-}
\ No newline at end of file
+}
diff --git a/packages/core/src/resolvers/uri_resolver_aggregator.rs b/packages/resolvers/src/uri_resolver_aggregator.rs
similarity index 77%
rename from packages/core/src/resolvers/uri_resolver_aggregator.rs
rename to packages/resolvers/src/uri_resolver_aggregator.rs
index 7af5e2e1d..c218f2f44 100644
--- a/packages/core/src/resolvers/uri_resolver_aggregator.rs
+++ b/packages/resolvers/src/uri_resolver_aggregator.rs
@@ -1,14 +1,14 @@
 use core::fmt;
-use std::{sync::Arc};
-use crate::{error::Error, uri::Uri, invoker::Invoker};
+use std::sync::Arc;
+use polywrap_core::{error::Error, uri::Uri, invoker::Invoker};
 
-use super::{
+use polywrap_core::resolution::{
     uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
     uri_resolver::UriResolver,
-    uri_resolver_aggregator_base::UriResolverAggregatorBase,
-    uri_resolver_like::UriResolverLike,
 };
 
+use crate::uri_resolver_aggregator_base::UriResolverAggregatorBase;
+
 pub struct UriResolverAggregator {
     name: Option<String>,
     resolvers: Vec<Arc<dyn UriResolver>>,
@@ -16,6 +16,7 @@ pub struct UriResolverAggregator {
 
 impl UriResolverAggregator {
     pub fn new(resolvers: Vec<Arc<dyn UriResolver>>) -> Self {
+        let resolvers = resolvers.into_iter().map(Arc::from).collect();
         Self {
             name: None,
             resolvers,
@@ -28,21 +29,6 @@ impl UriResolverAggregator {
     }
 }
 
-impl From<Vec<UriResolverLike>> for UriResolverAggregator {
-    fn from(resolver_likes: Vec<UriResolverLike>) -> Self {
-        let resolvers = resolver_likes
-            .into_iter()
-            .map(|resolver_like| {
-                let resolver: Arc<dyn UriResolver> = resolver_like.into();
-
-                resolver
-            })
-            .collect();
-
-        UriResolverAggregator::new(resolvers)
-    }
-}
-
 impl UriResolver for UriResolverAggregator {
     fn try_resolve_uri(
         &self,
@@ -93,4 +79,16 @@ impl fmt::Debug for UriResolverAggregator {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
       write!(f, "UriResolverAggregator\nResolvers: {:?}", self.resolvers)
   }
+}
+
+impl From<Vec<Box<dyn UriResolver>>> for UriResolverAggregator {
+    fn from(resolvers: Vec<Box<dyn UriResolver>>) -> Self {
+        UriResolverAggregator::new(resolvers.into_iter().map(Arc::from).collect())
+    }
+}
+
+impl From<Vec<Arc<dyn UriResolver>>> for UriResolverAggregator {
+    fn from(resolvers: Vec<Arc<dyn UriResolver>>) -> Self {
+        UriResolverAggregator::new(resolvers)
+    }
 }
\ No newline at end of file
diff --git a/packages/core/src/resolvers/uri_resolver_aggregator_base.rs b/packages/resolvers/src/uri_resolver_aggregator_base.rs
similarity index 87%
rename from packages/core/src/resolvers/uri_resolver_aggregator_base.rs
rename to packages/resolvers/src/uri_resolver_aggregator_base.rs
index bac3080ce..d367f1f22 100644
--- a/packages/core/src/resolvers/uri_resolver_aggregator_base.rs
+++ b/packages/resolvers/src/uri_resolver_aggregator_base.rs
@@ -1,8 +1,10 @@
 use std::sync::Arc;
 
-use crate::{uri::Uri, invoker::Invoker};
+use polywrap_core::error::Error;
 
-use super::{
+use polywrap_core::{uri::Uri, invoker::Invoker};
+
+use polywrap_core::resolution::{
     uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext, UriResolutionStep},
     uri_resolver::UriResolver,
 };
@@ -14,11 +16,11 @@ pub trait UriResolverAggregatorBase: UriResolver + core::fmt::Debug {
         uri: &Uri,
         client: &dyn Invoker,
         resolution_context: &mut UriResolutionContext,
-    ) -> Result<Vec<Arc<dyn UriResolver>>, crate::error::Error>;
+    ) -> Result<Vec<Arc<dyn UriResolver>>, Error>;
     fn get_step_description(
         &self,
         uri: &Uri,
-        result: &Result<UriPackageOrWrapper, crate::error::Error>,
+        result: &Result<UriPackageOrWrapper, Error>,
     ) -> String;
     fn try_resolve_uri_with_resolvers(
         &self,
@@ -26,7 +28,7 @@ pub trait UriResolverAggregatorBase: UriResolver + core::fmt::Debug {
         invoker: Arc<dyn Invoker>,
         resolvers: Vec<Arc<dyn UriResolver>>,
         resolution_context: &mut UriResolutionContext,
-    ) -> Result<UriPackageOrWrapper, crate::error::Error> {
+    ) -> Result<UriPackageOrWrapper, Error> {
         let sub_context = resolution_context.create_sub_history_context();
         for resolver in resolvers.into_iter() {
             let result = resolver
diff --git a/packages/resolvers/src/uri_resolver_wrapper.rs b/packages/resolvers/src/uri_resolver_wrapper.rs
index fd15a7e02..16ad18498 100644
--- a/packages/resolvers/src/uri_resolver_wrapper.rs
+++ b/packages/resolvers/src/uri_resolver_wrapper.rs
@@ -2,7 +2,7 @@ use core::fmt;
 use std::sync::{Arc};
 
 use polywrap_core::{
-    resolvers::{uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext, UriResolutionStep}, uri_resolver::UriResolver},
+    resolution::{uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext, UriResolutionStep}, uri_resolver::UriResolver, helpers::UriResolverExtensionFileReader},
     uri::Uri,
     error::Error, invoker::Invoker, 
 };
@@ -10,8 +10,6 @@ use polywrap_msgpack::{msgpack, decode};
 use polywrap_wasm::wasm_package::WasmPackage;
 use serde::{Serialize,Deserialize};
 
-use polywrap_core::resolvers::helpers::UriResolverExtensionFileReader;
-
 pub struct UriResolverWrapper {
     pub implementation_uri: Uri
 }
diff --git a/packages/resolvers/src/wrapper_resolver.rs b/packages/resolvers/src/wrapper_resolver.rs
new file mode 100644
index 000000000..47ce4cdb1
--- /dev/null
+++ b/packages/resolvers/src/wrapper_resolver.rs
@@ -0,0 +1,55 @@
+use core::fmt;
+use std::sync::Arc;
+
+use polywrap_core::resolution::uri_resolution_context::UriResolutionStep;
+use polywrap_core::resolution::uri_resolver::UriResolver;
+use polywrap_core::{uri::Uri, error::Error, wrapper::Wrapper, invoker::Invoker};
+
+use polywrap_core::resolution::{
+    uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
+};
+
+pub struct WrapperResolver {
+    pub uri: Uri,
+    pub wrapper: Arc<dyn Wrapper>,
+}
+
+impl WrapperResolver {}
+
+impl UriResolver for WrapperResolver {
+    fn try_resolve_uri(
+        &self,
+        uri: &Uri,
+        _: Arc<dyn Invoker>,
+        resolution_context: &mut UriResolutionContext,
+    ) -> Result<UriPackageOrWrapper, Error> {
+        let result: Result<UriPackageOrWrapper, Error> = { 
+            if uri.to_string() != self.uri.to_string() {
+                Ok(UriPackageOrWrapper::Uri(uri.clone()))
+            } else {
+                Ok(UriPackageOrWrapper::Wrapper(
+                    uri.clone(),
+                    self.wrapper.clone(),
+                ))
+            }
+        };
+
+        resolution_context.track_step(UriResolutionStep {
+            source_uri: uri.clone(),
+            description: Some(format!("Wrapper ({})", uri)),
+            result: match &result {
+                Ok(r) => Ok(r.clone()),
+                Err(e) => Err(Error::ResolutionError(e.to_string()))
+            },
+            sub_history: None,
+        });
+
+        result
+    }
+}
+
+impl fmt::Debug for WrapperResolver {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "WrapperResolver: {}", self.uri)
+    }
+}
diff --git a/packages/wasm/tests/test_runtime.rs b/packages/wasm/tests/test_runtime.rs
index 19936f642..16973cccf 100644
--- a/packages/wasm/tests/test_runtime.rs
+++ b/packages/wasm/tests/test_runtime.rs
@@ -4,7 +4,7 @@ use polywrap_core::{
     invoker::{Invoker},
     uri::Uri,
     error::Error,
-    file_reader::{SimpleFileReader}, resolvers::uri_resolution_context::UriResolutionContext, wrapper::Wrapper, env::Env, interface_implementation::InterfaceImplementations
+    file_reader::{SimpleFileReader}, resolution::uri_resolution_context::UriResolutionContext, wrapper::Wrapper, env::Env, interface_implementation::InterfaceImplementations
 };
 use wrap_manifest_schemas::{
     deserialize::deserialize_wrap_manifest