refactor(package): pass package handles by value throughout

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

20 files changed, 425 insertions, 386 deletions

diff --git a/crates/shirabe/src/downloader/archive_downloader.rs b/crates/shirabe/src/downloader/archive_downloader.rs
index ffa2ef4..f2ec719 100644
--- a/crates/shirabe/src/downloader/archive_downloader.rs
+++ b/crates/shirabe/src/downloader/archive_downloader.rs
@@ -13,7 +13,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::FileDownloader;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::Platform;
 
@@ -25,7 +25,7 @@ pub trait ArchiveDownloader {
 
     async fn extract(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>>;
@@ -33,11 +33,11 @@ pub trait ArchiveDownloader {
     async fn prepare(
         &mut self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
-        self.cleanup_executed_mut().remove(package.get_name());
+        self.cleanup_executed_mut().remove(&package.get_name());
         self.inner_mut()
             .prepare(r#type, package, path, prev_package)
             .await
@@ -46,12 +46,11 @@ pub trait ArchiveDownloader {
     async fn cleanup(
         &mut self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
-        self.cleanup_executed_mut()
-            .insert(package.get_name().to_string(), true);
+        self.cleanup_executed_mut().insert(package.get_name(), true);
         self.inner_mut()
             .cleanup(r#type, package, path, prev_package)
             .await
@@ -63,15 +62,15 @@ pub trait ArchiveDownloader {
     /// @throws \UnexpectedValueException
     async fn install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         if output {
             self.inner().io.write_error(&format!(
                 "  - {}{}",
-                InstallOperation::format(package, false),
-                self.get_install_operation_appendix(package, path)
+                InstallOperation::format(package.clone(), false),
+                self.get_install_operation_appendix(package.clone(), path)
             ));
         }
 
@@ -113,22 +112,26 @@ pub trait ArchiveDownloader {
             }
         };
 
-        self.inner_mut().add_cleanup_path(package, &temporary_dir);
+        self.inner_mut()
+            .add_cleanup_path(package.clone(), &temporary_dir);
         // avoid cleaning up $path if installing in "." for eg create-project as we can not
         // delete the directory we are currently in on windows
         if !is_dir(path) || realpath(path) != Some(Platform::get_cwd(false).unwrap_or_default()) {
-            self.inner_mut().add_cleanup_path(package, path);
+            self.inner_mut().add_cleanup_path(package.clone(), path);
         }
 
         self.inner_mut()
             .filesystem
             .borrow_mut()
             .ensure_directory_exists(&temporary_dir);
-        let file_name = self.inner().get_file_name(package, path);
+        let file_name = self.inner().get_file_name(package.clone(), path);
 
-        match self.extract(package, &file_name, &temporary_dir).await {
+        match self
+            .extract(package.clone(), &file_name, &temporary_dir)
+            .await
+        {
             Err(e) => {
-                install_cleanup(self.inner_mut(), package, path, &temporary_dir)?;
+                install_cleanup(self.inner_mut(), package.clone(), path, &temporary_dir)?;
                 Err(e)
             }
             Ok(_) => {
@@ -184,7 +187,7 @@ pub trait ArchiveDownloader {
                         from = content_dir.first().unwrap().get_pathname();
                     }
 
-                    rename_recursively(&self.inner().filesystem, package, &from, path)?;
+                    rename_recursively(&self.inner().filesystem, package.clone(), &from, path)?;
                 }
 
                 self.inner()
@@ -193,7 +196,7 @@ pub trait ArchiveDownloader {
                     .remove_directory_async(&temporary_dir)
                     .await?;
                 self.inner_mut()
-                    .remove_cleanup_path(package, &temporary_dir);
+                    .remove_cleanup_path(package.clone(), &temporary_dir);
                 self.inner_mut().remove_cleanup_path(package, path);
 
                 Ok(None)
@@ -202,19 +205,23 @@ pub trait ArchiveDownloader {
     }
 
     /// @inheritDoc
-    fn get_install_operation_appendix(&self, _package: &dyn PackageInterface, _path: &str) -> &str {
+    fn get_install_operation_appendix(
+        &self,
+        _package: PackageInterfaceHandle,
+        _path: &str,
+    ) -> &str {
         ": Extracting archive"
     }
 }
 
 fn install_cleanup(
     inner: &mut FileDownloader,
-    package: &dyn PackageInterface,
+    package: PackageInterfaceHandle,
     path: &str,
     temporary_dir: &str,
 ) -> Result<()> {
     // remove cache if the file was corrupted
-    inner.clear_last_cache_write(package);
+    inner.clear_last_cache_write(package.clone());
 
     // clean up
     inner
@@ -224,7 +231,7 @@ fn install_cleanup(
     if is_dir(path) && realpath(path) != Some(Platform::get_cwd(false).unwrap_or_default()) {
         inner.filesystem.borrow_mut().remove_directory(path)?;
     }
-    inner.remove_cleanup_path(package, temporary_dir);
+    inner.remove_cleanup_path(package.clone(), temporary_dir);
     let realpath = realpath(path);
     if let Some(realpath) = realpath {
         inner.remove_cleanup_path(package, &realpath);
@@ -253,7 +260,7 @@ fn get_folder_content(dir: &str) -> Vec<SplFileInfo> {
 /// put the source into the target e.g. src/ => target/src/ (assuming target exists) instead of src/ => target/
 fn rename_recursively(
     filesystem: &std::rc::Rc<std::cell::RefCell<Filesystem>>,
-    package: &dyn PackageInterface,
+    package: PackageInterfaceHandle,
     from: &str,
     to: &str,
 ) -> Result<()> {
@@ -277,7 +284,7 @@ fn rename_recursively(
             }
             rename_recursively(
                 filesystem,
-                package,
+                package.clone(),
                 &file,
                 &format!("{}/{}", to, basename(&file)),
             )?;
diff --git a/crates/shirabe/src/downloader/change_report_interface.rs b/crates/shirabe/src/downloader/change_report_interface.rs
index f5e686a..5e770f7 100644
--- a/crates/shirabe/src/downloader/change_report_interface.rs
+++ b/crates/shirabe/src/downloader/change_report_interface.rs
@@ -2,12 +2,12 @@
 
 use anyhow::Result;
 
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 
 pub trait ChangeReportInterface {
     fn get_local_changes(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<String>>;
 }
diff --git a/crates/shirabe/src/downloader/download_manager.rs b/crates/shirabe/src/downloader/download_manager.rs
index 83a03c4..33a555a 100644
--- a/crates/shirabe/src/downloader/download_manager.rs
+++ b/crates/shirabe/src/downloader/download_manager.rs
@@ -14,7 +14,7 @@ use crate::downloader::DownloaderInterface;
 use crate::exception::IrrecoverableDownloadException;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 
 /// Downloaders manager.
@@ -130,7 +130,7 @@ impl DownloadManager {
     ///                                           wrong type
     pub fn get_downloader_for_package(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
     ) -> Result<Option<&dyn DownloaderInterface>> {
         let installation_source = package.get_installation_source();
 
@@ -138,10 +138,10 @@ impl DownloadManager {
             return Ok(None);
         }
 
-        let downloader = if installation_source == Some("dist") {
-            self.get_downloader(package.get_dist_type().unwrap_or(""))?
-        } else if installation_source == Some("source") {
-            self.get_downloader(package.get_source_type().unwrap_or(""))?
+        let downloader = if installation_source.as_deref() == Some("dist") {
+            self.get_downloader(&package.get_dist_type().unwrap_or_default())?
+        } else if installation_source.as_deref() == Some("source") {
+            self.get_downloader(&package.get_source_type().unwrap_or_default())?
         } else {
             return Err(InvalidArgumentException {
                 message: format!(
@@ -153,14 +153,14 @@ impl DownloadManager {
             .into());
         };
 
-        if installation_source != Some(&downloader.get_installation_source()) {
+        if installation_source.as_deref() != Some(&downloader.get_installation_source()) {
             return Err(LogicException {
                 message: sprintf(
                     "Downloader \"%s\" is a %s type downloader and can not be used to download %s for package %s",
                     &[
                         PhpMixed::String(shirabe_php_shim::get_class_obj(downloader)),
                         PhpMixed::String(downloader.get_installation_source()),
-                        PhpMixed::String(installation_source.unwrap_or("").to_string()),
+                        PhpMixed::String(installation_source.clone().unwrap_or_default()),
                         PhpMixed::String(package.to_string()),
                     ],
                 ),
@@ -197,16 +197,16 @@ impl DownloadManager {
     /// @throws \RuntimeException
     pub async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         target_dir: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         self.filesystem
             .borrow_mut()
             .ensure_directory_exists(&dirname(&target_dir));
 
-        let mut sources = self.get_available_sources(package, prev_package)?;
+        let mut sources = self.get_available_sources(package.clone(), prev_package.clone())?;
 
         // PHP closure: uses recursive variable $download and captures $sources by reference
         // TODO(phase-b): recursive closure with mutable shared state needs Rc<RefCell<>> or similar
@@ -231,7 +231,7 @@ impl DownloadManager {
             // TODO(phase-b): &mut on shared package — PHP mutates by reference
             todo!("package.set_installation_source(Some(source.clone()))");
 
-            let downloader = match self.get_downloader_for_package(package)? {
+            let downloader = match self.get_downloader_for_package(package.clone())? {
                 Some(d) => d,
                 None => {
                     return Ok(None);
@@ -240,7 +240,7 @@ impl DownloadManager {
 
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
             let result = match downloader
-                .download3(package, &target_dir, prev_package)
+                .download3(package.clone(), &target_dir, prev_package.clone())
                 .await
             {
                 Ok(r) => r,
@@ -290,12 +290,12 @@ impl DownloadManager {
     pub async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         target_dir: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
-        if let Some(downloader) = self.get_downloader_for_package(package)? {
+        if let Some(downloader) = self.get_downloader_for_package(package.clone())? {
             return downloader
                 .prepare(r#type, package, &target_dir, prev_package)
                 .await;
@@ -314,11 +314,11 @@ impl DownloadManager {
     /// @throws \RuntimeException
     pub async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         target_dir: &str,
     ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
-        if let Some(downloader) = self.get_downloader_for_package(package)? {
+        if let Some(downloader) = self.get_downloader_for_package(package.clone())? {
             return downloader.install2(package, &target_dir).await;
         }
 
@@ -335,13 +335,13 @@ impl DownloadManager {
     /// @throws \InvalidArgumentException if initial package is not installed
     pub async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         target_dir: &str,
     ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
-        let downloader = self.get_downloader_for_package(target)?;
-        let initial_downloader = self.get_downloader_for_package(initial)?;
+        let downloader = self.get_downloader_for_package(target.clone())?;
+        let initial_downloader = self.get_downloader_for_package(initial.clone())?;
 
         // no downloaders present means update from metapackage to metapackage, nothing to do
         if initial_downloader.is_none() && downloader.is_none() {
@@ -362,7 +362,7 @@ impl DownloadManager {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
             match downloader
                 .unwrap()
-                .update(initial, target, &target_dir)
+                .update(initial.clone(), target.clone(), &target_dir)
                 .await
             {
                 Ok(p) => return Ok(p),
@@ -404,11 +404,11 @@ impl DownloadManager {
     /// @phpstan-return PromiseInterface<void|null>
     pub async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         target_dir: &str,
     ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
-        if let Some(downloader) = self.get_downloader_for_package(package)? {
+        if let Some(downloader) = self.get_downloader_for_package(package.clone())? {
             return downloader.remove2(package, &target_dir).await;
         }
 
@@ -425,12 +425,12 @@ impl DownloadManager {
     pub async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         target_dir: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
-        if let Some(downloader) = self.get_downloader_for_package(package)? {
+        if let Some(downloader) = self.get_downloader_for_package(package.clone())? {
             return downloader
                 .cleanup(r#type, package, &target_dir, prev_package)
                 .await;
@@ -444,14 +444,14 @@ impl DownloadManager {
     /// @param PackageInterface $package package instance
     pub(crate) fn resolve_package_install_preference(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
     ) -> String {
         for (pattern, preference) in &self.package_preferences {
             let pattern_regex = format!(
                 "{{^{}$}}i",
                 str_replace("\\*", ".*", &preg_quote(pattern, None)),
             );
-            if Preg::is_match(&pattern_regex, package.get_name()).unwrap_or(false) {
+            if Preg::is_match(&pattern_regex, &package.get_name()).unwrap_or(false) {
                 if "dist" == preference || (!package.is_dev() && "auto" == preference) {
                     return "dist".to_string();
                 }
@@ -471,8 +471,8 @@ impl DownloadManager {
     /// @phpstan-return array<'dist'|'source'>&non-empty-array
     fn get_available_sources(
         &self,
-        package: &dyn PackageInterface,
-        prev_package: Option<&dyn PackageInterface>,
+        package: PackageInterfaceHandle,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Vec<String>> {
         let source_type = package.get_source_type();
         let dist_type = package.get_dist_type();
@@ -498,7 +498,7 @@ impl DownloadManager {
             // if we are updating, we want to keep the same source as the previously installed package (if available in the new one)
             let prev_source = prev.get_installation_source();
             if in_array(
-                PhpMixed::String(prev_source.unwrap_or("").to_string()),
+                PhpMixed::String(prev_source.clone().unwrap_or_default()),
                 &PhpMixed::List(
                     sources
                         .iter()
@@ -509,10 +509,10 @@ impl DownloadManager {
             )
                 // unless the previous package was stable dist (by default) and the new package is dev, then we allow the new default to take over
                 && !(!prev.is_dev()
-                    && prev.get_installation_source() == Some("dist")
+                    && prev.get_installation_source().as_deref() == Some("dist")
                     && package.is_dev())
             {
-                let prev_source_owned = prev_source.unwrap_or("").to_string();
+                let prev_source_owned = prev_source.unwrap_or_default();
                 usort(&mut sources, move |a: &String, b: &String| -> i64 {
                     if *a == prev_source_owned { -1 } else { 1 }
                 });
@@ -523,7 +523,8 @@ impl DownloadManager {
 
         // reverse sources in case dist is the preferred source for this package
         if !self.prefer_source
-            && (self.prefer_dist || "dist" == self.resolve_package_install_preference(package))
+            && (self.prefer_dist
+                || "dist" == self.resolve_package_install_preference(package.clone()))
         {
             sources = array_reverse(&sources, false);
         }
diff --git a/crates/shirabe/src/downloader/downloader_interface.rs b/crates/shirabe/src/downloader/downloader_interface.rs
index 18026a4..986db28 100644
--- a/crates/shirabe/src/downloader/downloader_interface.rs
+++ b/crates/shirabe/src/downloader/downloader_interface.rs
@@ -1,6 +1,6 @@
 //! ref: composer/src/Composer/Downloader/DownloaderInterface.php
 
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use shirabe_php_shim::PhpMixed;
 
 #[async_trait::async_trait(?Send)]
@@ -9,18 +9,18 @@ pub trait DownloaderInterface: std::fmt::Debug {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> anyhow::Result<Option<PhpMixed>>;
 
     /// Convenience for the PHP default `$output = true` overload.
     async fn download3(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>> {
         self.download(package, path, prev_package, true).await
     }
@@ -28,14 +28,14 @@ pub trait DownloaderInterface: std::fmt::Debug {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>>;
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> anyhow::Result<Option<PhpMixed>>;
@@ -43,7 +43,7 @@ pub trait DownloaderInterface: std::fmt::Debug {
     /// Convenience for the PHP default `$output = true` overload.
     async fn install2(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> anyhow::Result<Option<PhpMixed>> {
         self.install(package, path, true).await
@@ -51,14 +51,14 @@ pub trait DownloaderInterface: std::fmt::Debug {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> anyhow::Result<Option<PhpMixed>>;
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> anyhow::Result<Option<PhpMixed>>;
@@ -66,7 +66,7 @@ pub trait DownloaderInterface: std::fmt::Debug {
     /// Convenience for the PHP default `$output = true` overload.
     async fn remove2(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> anyhow::Result<Option<PhpMixed>> {
         self.remove(package, path, true).await
@@ -75,9 +75,9 @@ pub trait DownloaderInterface: std::fmt::Debug {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>>;
 
     /// TODO(phase-b): runtime downcast helpers for PHP `instanceof` checks.
diff --git a/crates/shirabe/src/downloader/dvcs_downloader_interface.rs b/crates/shirabe/src/downloader/dvcs_downloader_interface.rs
index 94c3e4f..4c8ebd3 100644
--- a/crates/shirabe/src/downloader/dvcs_downloader_interface.rs
+++ b/crates/shirabe/src/downloader/dvcs_downloader_interface.rs
@@ -1,7 +1,8 @@
 //! ref: composer/src/Composer/Downloader/DvcsDownloaderInterface.php
 
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 
 pub trait DvcsDownloaderInterface {
-    fn get_unpushed_changes(&self, package: &dyn PackageInterface, path: String) -> Option<String>;
+    fn get_unpushed_changes(&self, package: PackageInterfaceHandle, path: String)
+    -> Option<String>;
 }
diff --git a/crates/shirabe/src/downloader/file_downloader.rs b/crates/shirabe/src/downloader/file_downloader.rs
index 4f2ee63..dadf8fb 100644
--- a/crates/shirabe/src/downloader/file_downloader.rs
+++ b/crates/shirabe/src/downloader/file_downloader.rs
@@ -28,7 +28,7 @@ use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
 use crate::io::IOInterfaceMutable;
 use crate::io::NullIO;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::package::comparer::Comparer;
 use crate::plugin::PluginEvents;
 use crate::plugin::PostFileDownloadEvent;
@@ -156,9 +156,9 @@ impl DownloaderInterface for FileDownloader {
     /// @inheritDoc
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         if package.get_dist_url().is_none() {
@@ -169,14 +169,14 @@ impl DownloaderInterface for FileDownloader {
             .into());
         }
 
-        let cache_key_generator = |package: &dyn PackageInterface, key: &str| -> String {
+        let cache_key_generator = |package: PackageInterfaceHandle, key: &str| -> String {
             let cache_key = hash("sha1", key);
 
             format!(
                 "{}/{}.{}",
                 package.get_name(),
                 cache_key,
-                package.get_dist_type().unwrap_or("")
+                package.get_dist_type().unwrap_or_default()
             )
         };
 
@@ -185,8 +185,8 @@ impl DownloaderInterface for FileDownloader {
         // @var array<array{base: non-empty-string, processed: non-empty-string, cacheKey: string}> $urls
         let mut urls: Vec<UrlEntry> = vec![];
         for url in dist_urls {
-            let processed_url = self.process_url(package, &url)?;
-            let cache_key = cache_key_generator(package, &processed_url);
+            let processed_url = self.process_url(package.clone(), &url)?;
+            let cache_key = cache_key_generator(package.clone(), &processed_url);
             urls.push(UrlEntry {
                 base: url,
                 processed: processed_url,
@@ -199,7 +199,7 @@ impl DownloaderInterface for FileDownloader {
         }
         debug_assert!(urls.len() > 0);
 
-        let file_name = self.get_file_name(package, path);
+        let file_name = self.get_file_name(package.clone(), path);
         self.filesystem.borrow_mut().ensure_directory_exists(path)?;
         let dir_of_file = shirabe_php_shim::dirname(&file_name);
         self.filesystem
@@ -312,7 +312,7 @@ impl DownloaderInterface for FileDownloader {
                         if file_exists(&file_name) {
                             self.filesystem.borrow().unlink(&file_name)?;
                         }
-                        self.clear_last_cache_write(package);
+                        self.clear_last_cache_write(package.clone());
 
                         if e.downcast_ref::<IrrecoverableDownloadException>().is_some() {
                             return Err(e);
@@ -429,9 +429,9 @@ impl DownloaderInterface for FileDownloader {
     async fn prepare(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         Ok(Some(PhpMixed::Null))
     }
@@ -440,11 +440,11 @@ impl DownloaderInterface for FileDownloader {
     async fn cleanup(
         &self,
         _type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
-        let file_name = self.get_file_name(package, path);
+        let file_name = self.get_file_name(package.clone(), path);
         if file_exists(&file_name) {
             self.filesystem.borrow_mut().unlink(&file_name)?;
         }
@@ -471,7 +471,7 @@ impl DownloaderInterface for FileDownloader {
 
         if let Some(paths) = self
             .additional_cleanup_paths
-            .get(package.get_name())
+            .get(&package.get_name())
             .cloned()
         {
             for path_to_clean in &paths {
@@ -494,13 +494,15 @@ impl DownloaderInterface for FileDownloader {
     /// @inheritDoc
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         if output {
-            self.io
-                .write_error(&format!("  - {}", InstallOperation::format(package, false)));
+            self.io.write_error(&format!(
+                "  - {}",
+                InstallOperation::format(package.clone(), false)
+            ));
         }
 
         let vendor_dir = self
@@ -526,11 +528,11 @@ impl DownloaderInterface for FileDownloader {
         }
         self.filesystem.borrow_mut().ensure_directory_exists(path)?;
         self.filesystem.borrow_mut().rename(
-            &self.get_file_name(package, path),
+            &self.get_file_name(package.clone(), path),
             &format!(
                 "{}/{}",
                 path,
-                self.get_dist_path(package, PATHINFO_BASENAME)
+                self.get_dist_path(package.clone(), PATHINFO_BASENAME)
             ),
         )?;
 
@@ -554,14 +556,14 @@ impl DownloaderInterface for FileDownloader {
     /// @inheritDoc
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.io.write_error(&format!(
             "  - {}{}",
-            UpdateOperation::format(initial, target, false),
-            self.get_install_operation_appendix(target, path)
+            UpdateOperation::format(initial.clone(), target.clone(), false),
+            self.get_install_operation_appendix(target.clone(), path)
         ));
 
         // PHP: return $this->remove($initial, $path, false)->then(fn () => $this->install($target, $path, false));
@@ -572,7 +574,7 @@ impl DownloaderInterface for FileDownloader {
     /// @inheritDoc
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -604,7 +606,7 @@ impl ChangeReportInterface for FileDownloader {
     /// @throws \RuntimeException
     fn get_local_changes(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<String>> {
         // TODO(phase-b): swap self.io to NullIO and restore — needs a take/swap helper
@@ -626,14 +628,18 @@ impl ChangeReportInterface for FileDownloader {
             tokio::runtime::Runtime::new()
                 .unwrap()
                 .block_on(self.download(
-                    package,
+                    package.clone(),
                     &format!("{}_compare", target_dir),
                     None,
                     false,
                 ))?;
             tokio::runtime::Runtime::new()
                 .unwrap()
-                .block_on(self.install(package, &format!("{}_compare", target_dir), false))?;
+                .block_on(self.install(
+                    package.clone(),
+                    &format!("{}_compare", target_dir),
+                    false,
+                ))?;
 
             let mut comparer = Comparer::new();
             comparer.set_source(format!("{}_compare", target_dir));
@@ -677,11 +683,11 @@ impl ChangeReportInterface for FileDownloader {
 
 impl FileDownloader {
     /// @param PATHINFO_EXTENSION|PATHINFO_BASENAME $component
-    fn get_dist_path(&self, package: &dyn PackageInterface, component: i64) -> String {
+    fn get_dist_path(&self, package: PackageInterfaceHandle, component: i64) -> String {
         pathinfo(
             PhpMixed::String(
                 parse_url(
-                    &strtr(package.get_dist_url().unwrap_or(""), "\\", "/"),
+                    &strtr(&package.get_dist_url().unwrap_or_default(), "\\", "/"),
                     PHP_URL_PATH,
                 )
                 .as_string()
@@ -695,24 +701,24 @@ impl FileDownloader {
         .to_string()
     }
 
-    pub(crate) fn clear_last_cache_write(&self, package: &dyn PackageInterface) {
+    pub(crate) fn clear_last_cache_write(&self, package: PackageInterfaceHandle) {
         let mut last_cache_writes = self.last_cache_writes.lock().unwrap();
-        if self.cache.is_some() && last_cache_writes.contains_key(package.get_name()) {
-            let key = last_cache_writes.get(package.get_name()).unwrap().clone();
+        if self.cache.is_some() && last_cache_writes.contains_key(&package.get_name()) {
+            let key = last_cache_writes.get(&package.get_name()).unwrap().clone();
             self.cache.as_ref().unwrap().borrow_mut().remove(&key);
-            last_cache_writes.shift_remove(package.get_name());
+            last_cache_writes.shift_remove(&package.get_name());
         }
     }
 
-    pub(crate) fn add_cleanup_path(&mut self, package: &dyn PackageInterface, path: &str) {
+    pub(crate) fn add_cleanup_path(&mut self, package: PackageInterfaceHandle, path: &str) {
         self.additional_cleanup_paths
-            .entry(package.get_name().to_string())
+            .entry(package.get_name())
             .or_insert_with(Vec::new)
             .push(path.to_string());
     }
 
-    pub(crate) fn remove_cleanup_path(&mut self, package: &dyn PackageInterface, path: &str) {
-        if let Some(paths) = self.additional_cleanup_paths.get_mut(package.get_name()) {
+    pub(crate) fn remove_cleanup_path(&mut self, package: PackageInterfaceHandle, path: &str) {
+        if let Some(paths) = self.additional_cleanup_paths.get_mut(&package.get_name()) {
             // PHP: array_search($path, ..., true)
             let idx = paths.iter().position(|p| p == path);
             if let Some(i) = idx {
@@ -723,10 +729,10 @@ impl FileDownloader {
     }
 
     /// Gets file name for specific package
-    pub(crate) fn get_file_name(&self, package: &dyn PackageInterface, _path: &str) -> String {
-        let extension = self.get_dist_path(package, PATHINFO_EXTENSION);
+    pub(crate) fn get_file_name(&self, package: PackageInterfaceHandle, _path: &str) -> String {
+        let extension = self.get_dist_path(package.clone(), PATHINFO_EXTENSION);
         let extension = if extension.is_empty() {
-            package.get_dist_type().unwrap_or("").to_string()
+            package.get_dist_type().unwrap_or_default()
         } else {
             extension
         };
@@ -752,14 +758,14 @@ impl FileDownloader {
     /// Gets appendix message to add to the "- Upgrading x" string being output on update
     fn get_install_operation_appendix(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
     ) -> String {
         String::new()
     }
 
     /// Process the download url
-    pub(crate) fn process_url(&self, package: &dyn PackageInterface, url: &str) -> Result<String> {
+    pub(crate) fn process_url(&self, package: PackageInterfaceHandle, url: &str) -> Result<String> {
         if !shirabe_php_shim::extension_loaded("openssl") && Some(0) == strpos(url, "https:") {
             return Err(RuntimeException {
                 message: "You must enable the openssl extension to download files via https"
@@ -774,7 +780,7 @@ impl FileDownloader {
             url = UrlUtil::update_dist_reference(
                 &*self.config.borrow(),
                 url,
-                package.get_dist_reference().unwrap(),
+                &package.get_dist_reference().unwrap(),
             );
         }
 
diff --git a/crates/shirabe/src/downloader/fossil_downloader.rs b/crates/shirabe/src/downloader/fossil_downloader.rs
index 9f0277e..fae3bd4 100644
--- a/crates/shirabe/src/downloader/fossil_downloader.rs
+++ b/crates/shirabe/src/downloader/fossil_downloader.rs
@@ -5,7 +5,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::VcsDownloaderBase;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
@@ -31,17 +31,17 @@ impl FossilDownloader {
 
     pub(crate) async fn do_download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: String,
         _url: String,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         Ok(None)
     }
 
     pub(crate) async fn do_install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
         url: String,
     ) -> Result<Option<PhpMixed>> {
@@ -101,8 +101,8 @@ impl FossilDownloader {
 
     pub(crate) async fn do_update(
         &self,
-        _initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: String,
         url: String,
     ) -> Result<Option<PhpMixed>> {
@@ -153,7 +153,7 @@ impl FossilDownloader {
 
     pub fn get_local_changes(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         path: String,
     ) -> Option<String> {
         if !self.has_metadata_repository(&path) {
@@ -259,9 +259,9 @@ impl DownloaderInterface for FossilDownloader {
 
     async fn download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
         todo!()
@@ -270,16 +270,16 @@ impl DownloaderInterface for FossilDownloader {
     async fn prepare(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
     async fn install(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -288,8 +288,8 @@ impl DownloaderInterface for FossilDownloader {
 
     async fn update(
         &self,
-        _initial: &dyn PackageInterface,
-        _target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        _target: PackageInterfaceHandle,
         _path: &str,
     ) -> Result<Option<PhpMixed>> {
         todo!()
@@ -297,7 +297,7 @@ impl DownloaderInterface for FossilDownloader {
 
     async fn remove(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -307,9 +307,9 @@ impl DownloaderInterface for FossilDownloader {
     async fn cleanup(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         todo!()
     }
diff --git a/crates/shirabe/src/downloader/git_downloader.rs b/crates/shirabe/src/downloader/git_downloader.rs
index b3e00a2..ed6f913 100644
--- a/crates/shirabe/src/downloader/git_downloader.rs
+++ b/crates/shirabe/src/downloader/git_downloader.rs
@@ -16,6 +16,7 @@ use crate::downloader::VcsDownloaderBase;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
 use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::Git as GitUtil;
 use crate::util::Platform;
@@ -59,10 +60,10 @@ impl GitDownloader {
 
     pub(crate) async fn do_download(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         _path: &str,
         url: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         // Do not create an extra local cache when repository is already local
         if Filesystem::is_local_path(url) {
@@ -109,17 +110,18 @@ impl GitDownloader {
                 io_interface::DEBUG,
             );
             let r#ref = package.get_source_reference();
+            let pretty_version = package.get_pretty_version();
             if self.git_util.fetch_ref_or_sync_mirror(
                 url,
                 &cache_path,
-                r#ref.unwrap_or(""),
-                Some(package.get_pretty_version()),
+                r#ref.as_deref().unwrap_or(""),
+                Some(&pretty_version),
             )? && is_dir(&cache_path)
             {
                 self.cached_packages
                     .entry(package.get_id())
                     .or_insert_with(IndexMap::new)
-                    .insert(r#ref.unwrap_or("").to_string(), true);
+                    .insert(r#ref.as_deref().unwrap_or("").to_string(), true);
             }
         } else if git_version.is_none() {
             return Err(RuntimeException {
@@ -134,7 +136,7 @@ impl GitDownloader {
 
     pub(crate) async fn do_install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         url: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -150,7 +152,7 @@ impl GitDownloader {
                 .unwrap_or(""),
             Preg::replace(r"{[^a-z0-9.]}i", "-", &Url::sanitize(url.to_string()))?,
         );
-        let r#ref = package.get_source_reference().unwrap_or("").to_string();
+        let r#ref = package.get_source_reference().unwrap_or_default();
 
         let msg;
         let commands: Vec<Vec<String>>;
@@ -265,14 +267,15 @@ impl GitDownloader {
             .run_commands(commands, url, Some(&path), true, None)?;
 
         let source_url = package.get_source_url();
-        if url != source_url.unwrap_or("") && source_url.is_some() {
-            self.update_origin_url(&path, source_url.unwrap());
+        if Some(url) != source_url.as_deref() && source_url.is_some() {
+            self.update_origin_url(&path, source_url.as_deref().unwrap());
         } else {
             self.set_push_url(&path, url);
         }
 
+        let pretty_version = package.get_pretty_version();
         if let Some(new_ref) =
-            self.update_to_commit(package, &path, &r#ref, package.get_pretty_version())?
+            self.update_to_commit(package.clone(), &path, &r#ref, &pretty_version)?
         {
             if package.get_dist_reference() == package.get_source_reference() {
                 // TODO(phase-b): set_dist_reference requires &mut PackageInterface
@@ -287,8 +290,8 @@ impl GitDownloader {
 
     pub(crate) async fn do_update(
         &mut self,
-        _initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
         url: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -315,7 +318,7 @@ impl GitDownloader {
                 .unwrap_or(""),
             Preg::replace(r"{[^a-z0-9.]}i", "-", &Url::sanitize(url.to_string()))?,
         );
-        let r#ref = target.get_source_reference().unwrap_or("").to_string();
+        let r#ref = target.get_source_reference().unwrap_or_default();
 
         let msg;
         let remote_url;
@@ -395,8 +398,9 @@ impl GitDownloader {
         self.git_util
             .run_commands(vec![command], url, Some(&path), false, None)?;
 
+        let pretty_version = target.get_pretty_version();
         if let Some(new_ref) =
-            self.update_to_commit(target, &path, &r#ref, target.get_pretty_version())?
+            self.update_to_commit(target.clone(), &path, &r#ref, &pretty_version)?
         {
             if target.get_dist_reference() == target.get_source_reference() {
                 // TODO(phase-b): set_dist_reference requires &mut PackageInterface
@@ -438,20 +442,24 @@ impl GitDownloader {
                     .cloned()
                     .unwrap_or_default();
                 if origin_url == composer_url
-                    && Some(composer_url.as_str()) != target.get_source_url()
+                    && Some(composer_url.as_str()) != target.get_source_url().as_deref()
                 {
                     update_origin_url = true;
                 }
             }
         }
         if update_origin_url && target.get_source_url().is_some() {
-            self.update_origin_url(&path, target.get_source_url().unwrap());
+            self.update_origin_url(&path, &target.get_source_url().unwrap());
         }
 
         Ok(None)
     }
 
-    pub fn get_local_changes(&self, _package: &dyn PackageInterface, path: &str) -> Option<String> {
+    pub fn get_local_changes(
+        &self,
+        _package: PackageInterfaceHandle,
+        path: &str,
+    ) -> Option<String> {
         GitUtil::clean_env(&self.inner.process);
         if !self.has_metadata_repository(path) {
             return None;
@@ -492,7 +500,7 @@ impl GitDownloader {
 
     pub fn get_unpushed_changes(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         path: &str,
     ) -> Option<String> {
         GitUtil::clean_env(&self.inner.process);
@@ -686,14 +694,14 @@ impl GitDownloader {
 
     pub(crate) async fn clean_changes(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         update: bool,
     ) -> Result<Option<PhpMixed>> {
         GitUtil::clean_env(&self.inner.process);
         let path = self.normalize_path(path);
 
-        let unpushed = self.get_unpushed_changes(package, &path);
+        let unpushed = self.get_unpushed_changes(package.clone(), &path);
         if let Some(unpushed) = unpushed.as_deref() {
             if self.inner.io.is_interactive()
                 || self
@@ -715,7 +723,7 @@ impl GitDownloader {
             }
         }
 
-        let changes = match self.get_local_changes(package, &path) {
+        let changes = match self.get_local_changes(package.clone(), &path) {
             Some(c) => c,
             None => return Ok(None),
         };
@@ -727,7 +735,10 @@ impl GitDownloader {
             }
             if discard_changes.as_string() == Some("stash") {
                 if !update {
-                    return self.inner.clean_changes(package, &path, update).await;
+                    return self
+                        .inner
+                        .clean_changes(package.clone(), &path, update)
+                        .await;
                 }
 
                 return self.stash_changes(&path).await;
@@ -892,7 +903,7 @@ impl GitDownloader {
     /// @return null|string       if a string is returned, it is the commit reference that was checked out if the original could not be found
     pub(crate) fn update_to_commit(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         reference: &str,
         pretty_version: &str,
@@ -1351,7 +1362,11 @@ impl GitDownloader {
 }
 
 impl DvcsDownloaderInterface for GitDownloader {
-    fn get_unpushed_changes(&self, package: &dyn PackageInterface, path: String) -> Option<String> {
+    fn get_unpushed_changes(
+        &self,
+        package: PackageInterfaceHandle,
+        path: String,
+    ) -> Option<String> {
         GitDownloader::get_unpushed_changes(self, package, &path)
     }
 }
@@ -1367,9 +1382,9 @@ impl crate::downloader::DownloaderInterface for GitDownloader {
 
     async fn download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         _output: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
@@ -1378,16 +1393,16 @@ impl crate::downloader::DownloaderInterface for GitDownloader {
     async fn prepare(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
     async fn install(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -1396,8 +1411,8 @@ impl crate::downloader::DownloaderInterface for GitDownloader {
 
     async fn update(
         &self,
-        _initial: &dyn PackageInterface,
-        _target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        _target: PackageInterfaceHandle,
         _path: &str,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
@@ -1405,7 +1420,7 @@ impl crate::downloader::DownloaderInterface for GitDownloader {
 
     async fn remove(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -1415,9 +1430,9 @@ impl crate::downloader::DownloaderInterface for GitDownloader {
     async fn cleanup(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
diff --git a/crates/shirabe/src/downloader/gzip_downloader.rs b/crates/shirabe/src/downloader/gzip_downloader.rs
index 55dff10..00adca9 100644
--- a/crates/shirabe/src/downloader/gzip_downloader.rs
+++ b/crates/shirabe/src/downloader/gzip_downloader.rs
@@ -6,7 +6,7 @@ use crate::downloader::ArchiveDownloader;
 use crate::downloader::FileDownloader;
 use crate::event_dispatcher::EventDispatcher;
 use crate::io::IOInterface;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::HttpDownloader;
 use crate::util::Platform;
@@ -51,7 +51,7 @@ impl GzipDownloader {
 
     pub(crate) async fn extract(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -137,9 +137,9 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -150,9 +150,9 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -161,7 +161,7 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -170,8 +170,8 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -179,7 +179,7 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -189,9 +189,9 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)
diff --git a/crates/shirabe/src/downloader/hg_downloader.rs b/crates/shirabe/src/downloader/hg_downloader.rs
index d4c53f3..7a48054 100644
--- a/crates/shirabe/src/downloader/hg_downloader.rs
+++ b/crates/shirabe/src/downloader/hg_downloader.rs
@@ -5,7 +5,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::VcsDownloaderBase;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::Hg as HgUtils;
 use crate::util::ProcessExecutor;
@@ -31,10 +31,10 @@ impl HgDownloader {
 
     pub(crate) async fn do_download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
         url: String,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         if HgUtils::get_version(&self.inner.process).is_none() {
             return Err(RuntimeException {
@@ -49,7 +49,7 @@ impl HgDownloader {
 
     pub(crate) async fn do_install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
         url: String,
     ) -> Result<Option<PhpMixed>> {
@@ -103,8 +103,8 @@ impl HgDownloader {
 
     pub(crate) async fn do_update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: String,
         url: String,
     ) -> Result<Option<PhpMixed>> {
@@ -154,7 +154,7 @@ impl HgDownloader {
 
     pub fn get_local_changes(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
     ) -> Option<String> {
         if !std::path::Path::new(&format!("{}/.hg", path)).is_dir() {
@@ -229,9 +229,9 @@ impl DownloaderInterface for HgDownloader {
 
     async fn download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
         todo!()
@@ -240,16 +240,16 @@ impl DownloaderInterface for HgDownloader {
     async fn prepare(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
     async fn install(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -258,8 +258,8 @@ impl DownloaderInterface for HgDownloader {
 
     async fn update(
         &self,
-        _initial: &dyn PackageInterface,
-        _target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        _target: PackageInterfaceHandle,
         _path: &str,
     ) -> Result<Option<PhpMixed>> {
         todo!()
@@ -267,7 +267,7 @@ impl DownloaderInterface for HgDownloader {
 
     async fn remove(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -277,9 +277,9 @@ impl DownloaderInterface for HgDownloader {
     async fn cleanup(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         todo!()
     }
diff --git a/crates/shirabe/src/downloader/path_downloader.rs b/crates/shirabe/src/downloader/path_downloader.rs
index 44541d4..c50856e 100644
--- a/crates/shirabe/src/downloader/path_downloader.rs
+++ b/crates/shirabe/src/downloader/path_downloader.rs
@@ -20,7 +20,7 @@ use crate::downloader::VcsCapableDownloaderInterface;
 use crate::event_dispatcher::EventDispatcher;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::package::archiver::ArchivableFilesFinder;
 use crate::package::dumper::ArrayDumper;
 use crate::package::version::VersionGuesser;
@@ -63,9 +63,9 @@ impl PathDownloader {
 
     pub async fn download(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
         let path = Filesystem::trim_trailing_slash(&path);
@@ -125,7 +125,7 @@ impl PathDownloader {
 
     pub async fn install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -144,11 +144,11 @@ impl PathDownloader {
 
         if realpath(&path).as_deref() == Some(&real_url) {
             if output {
-                let appendix = self.get_install_operation_appendix(package, &path)?;
+                let appendix = self.get_install_operation_appendix(package.clone(), &path)?;
                 self.inner.io.write_error3(
                     &format!(
                         "  - {}{}",
-                        InstallOperation::format(package, false),
+                        InstallOperation::format(package.clone(), false),
                         appendix
                     ),
                     true,
@@ -296,7 +296,7 @@ impl PathDownloader {
 
     pub async fn remove(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -314,7 +314,7 @@ impl PathDownloader {
                 self.inner.io.write_error3(
                     &format!(
                         "  - {}, source is still present in {}",
-                        UninstallOperation::format(package, false),
+                        UninstallOperation::format(package.clone(), false),
                         path
                     ),
                     true,
@@ -371,7 +371,7 @@ impl PathDownloader {
                 self.inner.io.write_error3(
                     &format!(
                         "  - {}, source is still present in {}",
-                        UninstallOperation::format(package, false),
+                        UninstallOperation::format(package.clone(), false),
                         path
                     ),
                     true,
@@ -385,7 +385,7 @@ impl PathDownloader {
         self.inner.remove(package, &path, output).await
     }
 
-    pub fn get_vcs_reference(&self, package: &dyn PackageInterface, path: &str) -> Option<String> {
+    pub fn get_vcs_reference(&self, package: PackageInterfaceHandle, path: &str) -> Option<String> {
         let path = Filesystem::trim_trailing_slash(path);
         let parser = VersionParser::new();
         let mut guesser = VersionGuesser::new(
@@ -396,7 +396,7 @@ impl PathDownloader {
         );
         let dumper = ArrayDumper::new();
 
-        let package_config = dumper.dump(package);
+        let package_config = dumper.dump(package.clone());
         let package_version = guesser.guess_version(&package_config, &path);
         if let Ok(Some(version)) = package_version {
             return version.commit;
@@ -407,7 +407,7 @@ impl PathDownloader {
 
     pub(crate) fn get_install_operation_appendix(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> Result<String> {
         let url = package.get_dist_url().ok_or_else(|| RuntimeException {
@@ -529,7 +529,7 @@ impl PathDownloader {
 }
 
 impl VcsCapableDownloaderInterface for PathDownloader {
-    fn get_vcs_reference(&self, package: &dyn PackageInterface, path: String) -> Option<String> {
+    fn get_vcs_reference(&self, package: PackageInterfaceHandle, path: String) -> Option<String> {
         PathDownloader::get_vcs_reference(self, package, &path)
     }
 }
@@ -546,9 +546,9 @@ impl DownloaderInterface for PathDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -559,9 +559,9 @@ impl DownloaderInterface for PathDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -570,7 +570,7 @@ impl DownloaderInterface for PathDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -579,8 +579,8 @@ impl DownloaderInterface for PathDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -588,7 +588,7 @@ impl DownloaderInterface for PathDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -598,9 +598,9 @@ impl DownloaderInterface for PathDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)
diff --git a/crates/shirabe/src/downloader/perforce_downloader.rs b/crates/shirabe/src/downloader/perforce_downloader.rs
index f967111..4a54511 100644
--- a/crates/shirabe/src/downloader/perforce_downloader.rs
+++ b/crates/shirabe/src/downloader/perforce_downloader.rs
@@ -6,6 +6,7 @@ use crate::downloader::VcsDownloaderBase;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
 use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::repository::VcsRepository;
 use crate::util::Filesystem;
 use crate::util::Perforce;
@@ -36,17 +37,17 @@ impl PerforceDownloader {
 
     pub(crate) async fn do_download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: String,
         _url: String,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         Ok(None)
     }
 
     pub async fn do_install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: String,
         url: String,
     ) -> Result<Option<PhpMixed>> {
@@ -83,13 +84,14 @@ impl PerforceDownloader {
         None
     }
 
-    pub fn init_perforce(&mut self, package: &dyn PackageInterface, path: String, url: String) {
+    pub fn init_perforce(&mut self, package: PackageInterfaceHandle, path: String, url: String) {
         if self.perforce.is_some() {
             self.perforce.as_mut().unwrap().initialize_path(&path);
             return;
         }
 
-        let repository = package.get_repository();
+        let package_rc = package.as_rc().borrow();
+        let repository = package_rc.as_package_interface().get_repository();
         let repo_config: Option<IndexMap<String, PhpMixed>> = if let Some(repo) = repository {
             if let Some(vcs_repo) = repo.as_any().downcast_ref::<VcsRepository>() {
                 Some(self.get_repo_config(vcs_repo))
@@ -99,6 +101,7 @@ impl PerforceDownloader {
         } else {
             None
         };
+        drop(package_rc);
         self.perforce = Some(Perforce::create(
             repo_config.unwrap_or_default(),
             url,
@@ -114,8 +117,8 @@ impl PerforceDownloader {
 
     pub(crate) async fn do_update(
         &mut self,
-        _initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: String,
         url: String,
     ) -> Result<Option<PhpMixed>> {
@@ -124,7 +127,7 @@ impl PerforceDownloader {
 
     pub fn get_local_changes(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: String,
     ) -> Option<String> {
         self.inner
@@ -168,9 +171,9 @@ impl DownloaderInterface for PerforceDownloader {
 
     async fn download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
         todo!()
@@ -179,16 +182,16 @@ impl DownloaderInterface for PerforceDownloader {
     async fn prepare(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
     async fn install(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -197,8 +200,8 @@ impl DownloaderInterface for PerforceDownloader {
 
     async fn update(
         &self,
-        _initial: &dyn PackageInterface,
-        _target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        _target: PackageInterfaceHandle,
         _path: &str,
     ) -> Result<Option<PhpMixed>> {
         todo!()
@@ -206,7 +209,7 @@ impl DownloaderInterface for PerforceDownloader {
 
     async fn remove(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -216,9 +219,9 @@ impl DownloaderInterface for PerforceDownloader {
     async fn cleanup(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         todo!()
     }
diff --git a/crates/shirabe/src/downloader/phar_downloader.rs b/crates/shirabe/src/downloader/phar_downloader.rs
index 235e0bb..6a4ac97 100644
--- a/crates/shirabe/src/downloader/phar_downloader.rs
+++ b/crates/shirabe/src/downloader/phar_downloader.rs
@@ -7,7 +7,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::FileDownloader;
 use crate::event_dispatcher::EventDispatcher;
 use crate::io::IOInterface;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::HttpDownloader;
 use crate::util::ProcessExecutor;
@@ -47,7 +47,7 @@ impl PharDownloader {
 
     pub(crate) async fn extract(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -71,9 +71,9 @@ impl DownloaderInterface for PharDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -84,9 +84,9 @@ impl DownloaderInterface for PharDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -95,7 +95,7 @@ impl DownloaderInterface for PharDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -104,8 +104,8 @@ impl DownloaderInterface for PharDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -113,7 +113,7 @@ impl DownloaderInterface for PharDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -123,9 +123,9 @@ impl DownloaderInterface for PharDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)
diff --git a/crates/shirabe/src/downloader/rar_downloader.rs b/crates/shirabe/src/downloader/rar_downloader.rs
index bb0c2f8..9ce6c51 100644
--- a/crates/shirabe/src/downloader/rar_downloader.rs
+++ b/crates/shirabe/src/downloader/rar_downloader.rs
@@ -6,7 +6,7 @@ use crate::downloader::ArchiveDownloader;
 use crate::downloader::FileDownloader;
 use crate::event_dispatcher::EventDispatcher;
 use crate::io::IOInterface;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::HttpDownloader;
 use crate::util::IniHelper;
@@ -50,7 +50,7 @@ impl RarDownloader {
 
     pub(crate) async fn extract(
         &mut self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -151,9 +151,9 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -164,9 +164,9 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -175,7 +175,7 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -184,8 +184,8 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -193,7 +193,7 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -203,9 +203,9 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)
diff --git a/crates/shirabe/src/downloader/svn_downloader.rs b/crates/shirabe/src/downloader/svn_downloader.rs
index f3683dd..9f5d2ed 100644
--- a/crates/shirabe/src/downloader/svn_downloader.rs
+++ b/crates/shirabe/src/downloader/svn_downloader.rs
@@ -10,7 +10,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::VcsDownloaderBase;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::repository::VcsRepository;
 use crate::util::Filesystem;
 use crate::util::ProcessExecutor;
@@ -37,10 +37,10 @@ impl SvnDownloader {
 
     pub(crate) async fn do_download(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         url: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>> {
         SvnUtil::clean_env();
         let mut util = SvnUtil::new(
@@ -62,23 +62,26 @@ impl SvnDownloader {
 
     pub(crate) async fn do_install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         url: &str,
     ) -> anyhow::Result<Option<PhpMixed>> {
         SvnUtil::clean_env();
         let r#ref = package.get_source_reference();
 
-        let repo = package.get_repository();
-        if let Some(repo) = repo {
-            if let Some(vcs_repo) = repo.as_any().downcast_ref::<VcsRepository>() {
-                let repo_config = vcs_repo.get_repo_config();
-                if repo_config.contains_key("svn-cache-credentials") {
-                    if let Some(val) = repo_config
-                        .get("svn-cache-credentials")
-                        .and_then(|v| v.as_bool())
-                    {
-                        self.cache_credentials = val;
+        {
+            let package_ref = package.as_rc().borrow();
+            let repo = package_ref.as_package_interface().get_repository();
+            if let Some(repo) = repo {
+                if let Some(vcs_repo) = repo.as_any().downcast_ref::<VcsRepository>() {
+                    let repo_config = vcs_repo.get_repo_config();
+                    if repo_config.contains_key("svn-cache-credentials") {
+                        if let Some(val) = repo_config
+                            .get("svn-cache-credentials")
+                            .and_then(|v| v.as_bool())
+                        {
+                            self.cache_credentials = val;
+                        }
                     }
                 }
             }
@@ -106,8 +109,8 @@ impl SvnDownloader {
 
     pub(crate) async fn do_update(
         &mut self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
         url: &str,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -137,7 +140,7 @@ impl SvnDownloader {
         }
 
         self.inner.io.write_error3(
-            &format!(" Checking out {}", r#ref.unwrap_or_default()),
+            &format!(" Checking out {}", r#ref.clone().unwrap_or_default()),
             true,
             io_interface::NORMAL,
         );
@@ -155,7 +158,7 @@ impl SvnDownloader {
         Ok(None)
     }
 
-    pub fn get_local_changes(&self, package: &dyn PackageInterface, path: &str) -> Option<String> {
+    pub fn get_local_changes(&self, package: PackageInterfaceHandle, path: &str) -> Option<String> {
         if !self.has_metadata_repository(path) {
             return None;
         }
@@ -178,7 +181,7 @@ impl SvnDownloader {
 
     pub(crate) fn execute(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         base_url: &str,
         command: Vec<String>,
         url: &str,
@@ -204,11 +207,11 @@ impl SvnDownloader {
 
     pub(crate) async fn clean_changes(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         update: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
-        let changes = self.get_local_changes(package, path);
+        let changes = self.get_local_changes(package.clone(), path);
         if changes.is_none() {
             return Ok(None);
         }
@@ -440,9 +443,9 @@ impl DownloaderInterface for SvnDownloader {
 
     async fn download(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
         _output: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
@@ -451,16 +454,16 @@ impl DownloaderInterface for SvnDownloader {
     async fn prepare(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
     async fn install(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -469,8 +472,8 @@ impl DownloaderInterface for SvnDownloader {
 
     async fn update(
         &self,
-        _initial: &dyn PackageInterface,
-        _target: &dyn PackageInterface,
+        _initial: PackageInterfaceHandle,
+        _target: PackageInterfaceHandle,
         _path: &str,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
@@ -478,7 +481,7 @@ impl DownloaderInterface for SvnDownloader {
 
     async fn remove(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _output: bool,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -488,9 +491,9 @@ impl DownloaderInterface for SvnDownloader {
     async fn cleanup(
         &self,
         _type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
-        _prev_package: Option<&dyn PackageInterface>,
+        _prev_package: Option<PackageInterfaceHandle>,
     ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
diff --git a/crates/shirabe/src/downloader/tar_downloader.rs b/crates/shirabe/src/downloader/tar_downloader.rs
index 7314ecd..07d8a5f 100644
--- a/crates/shirabe/src/downloader/tar_downloader.rs
+++ b/crates/shirabe/src/downloader/tar_downloader.rs
@@ -7,7 +7,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::FileDownloader;
 use crate::event_dispatcher::EventDispatcher;
 use crate::io::IOInterface;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::HttpDownloader;
 use crate::util::ProcessExecutor;
@@ -47,7 +47,7 @@ impl TarDownloader {
 
     pub(crate) async fn extract(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -66,9 +66,9 @@ impl DownloaderInterface for TarDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -79,9 +79,9 @@ impl DownloaderInterface for TarDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -90,7 +90,7 @@ impl DownloaderInterface for TarDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -99,8 +99,8 @@ impl DownloaderInterface for TarDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -108,7 +108,7 @@ impl DownloaderInterface for TarDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -118,9 +118,9 @@ impl DownloaderInterface for TarDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)
diff --git a/crates/shirabe/src/downloader/vcs_capable_downloader_interface.rs b/crates/shirabe/src/downloader/vcs_capable_downloader_interface.rs
index 68e9caa..c2d07f6 100644
--- a/crates/shirabe/src/downloader/vcs_capable_downloader_interface.rs
+++ b/crates/shirabe/src/downloader/vcs_capable_downloader_interface.rs
@@ -1,7 +1,7 @@
 //! ref: composer/src/Composer/Downloader/VcsCapableDownloaderInterface.php
 
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 
 pub trait VcsCapableDownloaderInterface {
-    fn get_vcs_reference(&self, package: &dyn PackageInterface, path: String) -> Option<String>;
+    fn get_vcs_reference(&self, package: PackageInterfaceHandle, path: String) -> Option<String>;
 }
diff --git a/crates/shirabe/src/downloader/vcs_downloader.rs b/crates/shirabe/src/downloader/vcs_downloader.rs
index 736d433..b09841e 100644
--- a/crates/shirabe/src/downloader/vcs_downloader.rs
+++ b/crates/shirabe/src/downloader/vcs_downloader.rs
@@ -18,7 +18,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::VcsCapableDownloaderInterface;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::package::dumper::ArrayDumper;
 use crate::package::version::VersionGuesser;
 use crate::package::version::VersionParser;
@@ -61,7 +61,7 @@ impl VcsDownloaderBase {
     /// already verified that no local changes exist.
     pub async fn clean_changes(
         &self,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         _path: &str,
         _update: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -88,16 +88,16 @@ pub trait VcsDownloader:
     /// Downloads data needed to run an install/update later
     async fn do_download(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         url: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>>;
 
     /// Downloads specific package into specific folder.
     async fn do_install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         url: &str,
     ) -> Result<Option<PhpMixed>>;
@@ -105,8 +105,8 @@ pub trait VcsDownloader:
     /// Updates specific package in specific folder from initial to target version.
     async fn do_update(
         &mut self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
         url: &str,
     ) -> Result<Option<PhpMixed>>;
@@ -124,9 +124,9 @@ pub trait VcsDownloader:
 
     async fn download(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         if package.get_source_reference().is_none() {
             return Err(InvalidArgumentException {
@@ -143,8 +143,9 @@ pub trait VcsDownloader:
 
         while let Some(url) = array_shift(&mut urls) {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
-            let attempt: Result<Option<PhpMixed>> =
-                self.do_download(package, path, &url, prev_package).await;
+            let attempt: Result<Option<PhpMixed>> = self
+                .do_download(package.clone(), path, &url, prev_package.clone())
+                .await;
             match attempt {
                 Ok(promise) => return Ok(promise),
                 Err(e) => {
@@ -190,12 +191,12 @@ pub trait VcsDownloader:
     async fn prepare(
         &mut self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         if r#type == "update" {
-            self.clean_changes(prev_package.unwrap(), path, true)
+            self.clean_changes(prev_package.clone().unwrap(), path, true)
                 .await?;
             self.has_cleaned_changes_mut()
                 .insert(prev_package.unwrap().get_unique_name(), true);
@@ -213,12 +214,13 @@ pub trait VcsDownloader:
     async fn cleanup(
         &mut self,
         r#type: &str,
-        _package: &dyn PackageInterface,
+        _package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         if r#type == "update"
             && prev_package
+                .clone()
                 .map(|p| {
                     self.has_cleaned_changes()
                         .contains_key(&p.get_unique_name())
@@ -235,7 +237,7 @@ pub trait VcsDownloader:
 
     async fn install(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         if package.get_source_reference().is_none() {
@@ -250,7 +252,7 @@ pub trait VcsDownloader:
         }
 
         self.io_mut().write_error3(
-            &format!("  - {}: ", InstallOperation::format(package, false)),
+            &format!("  - {}: ", InstallOperation::format(package.clone(), false)),
             false,
             io_interface::NORMAL,
         );
@@ -258,7 +260,8 @@ pub trait VcsDownloader:
         let mut urls = self.prepare_urls(package.get_source_urls());
         while let Some(url) = array_shift(&mut urls) {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
-            let attempt: Result<Option<PhpMixed>> = self.do_install(package, path, &url).await;
+            let attempt: Result<Option<PhpMixed>> =
+                self.do_install(package.clone(), path, &url).await;
             match attempt {
                 Ok(_) => break,
                 Err(e) => {
@@ -303,8 +306,8 @@ pub trait VcsDownloader:
 
     async fn update(
         &mut self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         if target.get_source_reference().is_none() {
@@ -319,7 +322,10 @@ pub trait VcsDownloader:
         }
 
         self.io_mut().write_error3(
-            &format!("  - {}: ", UpdateOperation::format(initial, target, false),),
+            &format!(
+                "  - {}: ",
+                UpdateOperation::format(initial.clone(), target.clone(), false),
+            ),
             false,
             io_interface::NORMAL,
         );
@@ -329,8 +335,9 @@ pub trait VcsDownloader:
         let mut exception: Option<anyhow::Error> = None;
         while let Some(url) = array_shift(&mut urls) {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
-            let attempt: Result<Option<PhpMixed>> =
-                self.do_update(initial, target, path, &url).await;
+            let attempt: Result<Option<PhpMixed>> = self
+                .do_update(initial.clone(), target.clone(), path, &url)
+                .await;
             match attempt {
                 Ok(_) => {
                     exception = None;
@@ -369,20 +376,14 @@ pub trait VcsDownloader:
         // print the commit logs if in verbose mode and VCS metadata is present
         // because in case of missing metadata code would trigger another exception
         if exception.is_none() && self.io().is_verbose() && self.has_metadata_repository(path) {
+            let initial_ref = initial.get_source_reference().unwrap_or_default();
+            let target_ref = target.get_source_reference().unwrap_or_default();
             let mut message = "Pulling in changes:";
-            let mut logs = self.get_commit_logs(
-                initial.get_source_reference().unwrap_or(""),
-                target.get_source_reference().unwrap_or(""),
-                path,
-            );
+            let mut logs = self.get_commit_logs(&initial_ref, &target_ref, path);
 
             if trim(&logs, None) == "" {
                 message = "Rolling back changes:";
-                logs = self.get_commit_logs(
-                    target.get_source_reference().unwrap_or(""),
-                    initial.get_source_reference().unwrap_or(""),
-                    path,
-                );
+                logs = self.get_commit_logs(&target_ref, &initial_ref, path);
             }
 
             if trim(&logs, None) != "" {
@@ -413,7 +414,7 @@ pub trait VcsDownloader:
 
     async fn remove(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.io_mut().write_error3(
@@ -438,7 +439,7 @@ pub trait VcsDownloader:
         Ok(None)
     }
 
-    fn get_vcs_reference(&self, package: &dyn PackageInterface, path: &str) -> Option<String> {
+    fn get_vcs_reference(&self, package: PackageInterfaceHandle, path: &str) -> Option<String> {
         let parser = VersionParser::new();
         let guesser = VersionGuesser::new(
             self.config().clone(),
@@ -448,7 +449,7 @@ pub trait VcsDownloader:
         );
         let dumper = ArrayDumper::new();
 
-        let package_config = dumper.dump(package);
+        let package_config = dumper.dump(package.clone());
         let mut guesser = guesser;
         if let Ok(Some(package_version)) = guesser.guess_version(&package_config, path) {
             return package_version.commit.clone();
@@ -463,7 +464,7 @@ pub trait VcsDownloader:
     ///                       if false (remove) the changes should be assumed to be lost if the operation is not aborted
     async fn clean_changes(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         _update: bool,
     ) -> Result<Option<PhpMixed>> {
diff --git a/crates/shirabe/src/downloader/xz_downloader.rs b/crates/shirabe/src/downloader/xz_downloader.rs
index fd83b28..ac8b6ba 100644
--- a/crates/shirabe/src/downloader/xz_downloader.rs
+++ b/crates/shirabe/src/downloader/xz_downloader.rs
@@ -6,7 +6,7 @@ use crate::downloader::ArchiveDownloader;
 use crate::downloader::FileDownloader;
 use crate::event_dispatcher::EventDispatcher;
 use crate::io::IOInterface;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::Filesystem;
 use crate::util::HttpDownloader;
 use crate::util::ProcessExecutor;
@@ -46,7 +46,7 @@ impl XzDownloader {
 
     pub(crate) async fn extract(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -85,9 +85,9 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -98,9 +98,9 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -109,7 +109,7 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -118,8 +118,8 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -127,7 +127,7 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -137,9 +137,9 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)
diff --git a/crates/shirabe/src/downloader/zip_downloader.rs b/crates/shirabe/src/downloader/zip_downloader.rs
index 4c72b91..17eeae5 100644
--- a/crates/shirabe/src/downloader/zip_downloader.rs
+++ b/crates/shirabe/src/downloader/zip_downloader.rs
@@ -5,7 +5,7 @@ use crate::downloader::DownloaderInterface;
 use crate::downloader::FileDownloader;
 use crate::io::IOInterface;
 use crate::io::IOInterfaceImmutable;
-use crate::package::PackageInterface;
+use crate::package::PackageInterfaceHandle;
 use crate::util::IniHelper;
 use crate::util::Platform;
 use anyhow::Result;
@@ -62,9 +62,9 @@ impl ZipDownloader {
 
     pub async fn download(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         {
@@ -202,7 +202,7 @@ impl ZipDownloader {
 
     async fn extract_with_system_unzip(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -282,7 +282,7 @@ impl ZipDownloader {
         match process_result {
             Ok(process) => {
                 if !process.is_successful() {
-                    if self.cleanup_executed.contains_key(package.get_name()) {
+                    if self.cleanup_executed.contains_key(&package.get_name()) {
                         return Err(RuntimeException {
                             message: format!(
                                 "Failed to extract {} as the installation was aborted by another package operation.",
@@ -337,7 +337,7 @@ impl ZipDownloader {
         is_last_chance: bool,
         file: &str,
         path: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         executable: &str,
     ) -> Result<Option<PhpMixed>> {
         if is_last_chance {
@@ -390,17 +390,19 @@ impl ZipDownloader {
                         substr(&file_get_contents(file).unwrap_or_default(), -100, None).as_bytes()
                     )
                 ));
-                if strlen(package.get_dist_url().unwrap_or("")) > 0 {
+                if strlen(&package.get_dist_url().unwrap_or_default()) > 0 {
                     self.inner.io.write_error(&format!(
                         "Origin URL: {}",
-                        self.inner
-                            .process_url(package, package.get_dist_url().unwrap_or(""))?
+                        self.inner.process_url(
+                            package.clone(),
+                            &package.get_dist_url().unwrap_or_default()
+                        )?
                     ));
                     let headers = {
                         let response_headers = crate::downloader::file_downloader::RESPONSE_HEADERS
                             .lock()
                             .unwrap();
-                        match response_headers.get(package.get_name()) {
+                        match response_headers.get(&package.get_name()) {
                             Some(list) => PhpMixed::List(
                                 list.iter()
                                     .map(|s| Box::new(PhpMixed::String(s.clone())))
@@ -422,7 +424,7 @@ impl ZipDownloader {
 
     async fn extract_with_zip_archive(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -521,7 +523,7 @@ impl ZipDownloader {
 
     pub(crate) async fn extract(
         &mut self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         file: &str,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
@@ -562,9 +564,9 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
 
     async fn download(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
         self.inner
@@ -575,9 +577,9 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
     async fn prepare(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .prepare(r#type, package, path, prev_package)
@@ -586,7 +588,7 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
 
     async fn install(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -595,8 +597,8 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
 
     async fn update(
         &self,
-        initial: &dyn PackageInterface,
-        target: &dyn PackageInterface,
+        initial: PackageInterfaceHandle,
+        target: PackageInterfaceHandle,
         path: &str,
     ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path).await
@@ -604,7 +606,7 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
 
     async fn remove(
         &self,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
         output: bool,
     ) -> Result<Option<PhpMixed>> {
@@ -614,9 +616,9 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
     async fn cleanup(
         &self,
         r#type: &str,
-        package: &dyn PackageInterface,
+        package: PackageInterfaceHandle,
         path: &str,
-        prev_package: Option<&dyn PackageInterface>,
+        prev_package: Option<PackageInterfaceHandle>,
     ) -> Result<Option<PhpMixed>> {
         self.inner
             .cleanup(r#type, package, path, prev_package)