feat(locker): wire get_locked_repository via LockArrayRepository

Implement LockArrayRepository::new/add_package and
CanonicalPackagesTrait::get_packages (delegating to inner
ArrayRepository), expose add_package on LockArrayRepositoryHandle, and
add set_root_package_alias on CompleteAliasPackageHandle.

With these in place, Locker::get_locked_repository is fully wired:
load each locked package, register it (plus its aliasOf for
AliasPackages) in package_by_name, then build CompleteAliasPackage
handles for lock-file aliases via as_complete_package() narrowing.

Drop the unused RepositoryInterface::clone_box default and the stale
inherent LockArrayRepository::clone_box (no callers).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

5 files changed, 39 insertions, 26 deletions

diff --git a/crates/shirabe/src/package/handle.rs b/crates/shirabe/src/package/handle.rs
index aa21bf1..ab1bd0f 100644
--- a/crates/shirabe/src/package/handle.rs
+++ b/crates/shirabe/src/package/handle.rs
@@ -1459,6 +1459,14 @@ impl CompleteAliasPackageHandle {
             _ => unreachable!("CompleteAliasPackageHandle invariant violated"),
         }
     }
+
+    pub fn set_root_package_alias(&self, value: bool) {
+        match &mut *self.0.borrow_mut() {
+            AnyPackage::CompleteAliasPackage(p) => p.set_root_package_alias(value),
+            AnyPackage::RootAliasPackage(p) => p.set_root_package_alias(value),
+            _ => unreachable!("CompleteAliasPackageHandle invariant violated"),
+        }
+    }
 }
 
 impl RootAliasPackageHandle {
diff --git a/crates/shirabe/src/package/locker.rs b/crates/shirabe/src/package/locker.rs
index 3b5db05..e90a8f0 100644
--- a/crates/shirabe/src/package/locker.rs
+++ b/crates/shirabe/src/package/locker.rs
@@ -16,7 +16,7 @@ use crate::installer::InstallationManager;
 use crate::io::IOInterface;
 use crate::json::JsonFile;
 use crate::package::BasePackageHandle;
-use crate::package::CompleteAliasPackage;
+use crate::package::CompleteAliasPackageHandle;
 use crate::package::Link;
 use crate::package::PackageInterface;
 use crate::package::PackageInterfaceHandle;
@@ -28,6 +28,7 @@ use crate::package::version::VersionParser;
 use crate::plugin::plugin_interface::{self, PluginInterface};
 use crate::repository::FindPackageConstraint;
 use crate::repository::InstalledRepository;
+use crate::repository::LockArrayRepository;
 use crate::repository::LockArrayRepositoryHandle;
 use crate::repository::PlatformRepository;
 use crate::repository::RootPackageRepository;
@@ -187,9 +188,8 @@ impl Locker {
         with_dev_reqs: bool,
     ) -> Result<LockArrayRepositoryHandle> {
         let lock_data = self.get_lock_data()?;
-        // TODO(phase-b): LockArrayRepository has no `new` constructor yet
-        let mut packages: LockArrayRepositoryHandle =
-            todo!("LockArrayRepositoryHandle::new(LockArrayRepository::new(vec![]))");
+        let packages: LockArrayRepositoryHandle =
+            LockArrayRepositoryHandle::new(LockArrayRepository::new(vec![])?);
 
         let mut locked_packages = lock_data
             .get("packages")
@@ -211,7 +211,6 @@ impl Locker {
             return Ok(packages);
         }
 
-        // PHP: if (isset($lockedPackages[0]['name']))
         let has_name = if let PhpMixed::List(list) = &locked_packages {
             list.first()
                 .map(|v| match v.as_ref() {
@@ -230,12 +229,13 @@ impl Locker {
                         let info_map: IndexMap<String, PhpMixed> =
                             m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect();
                         let package = self.loader.load(info_map, None)?;
-                        // PHP shares the package between repository and map; the handle is the shared Rc.
-                        let _name = package.get_name();
-                        let _ = (&mut packages, &mut package_by_name, package);
-                        todo!(
-                            "packages.add_package(package); package_by_name.insert(name, package); + AliasPackage downcast"
-                        );
+                        packages.add_package(package.clone())?;
+                        package_by_name.insert(package.get_name(), package.clone());
+
+                        if let Some(alias) = package.as_alias() {
+                            let alias_of: BasePackageHandle = alias.get_alias_of().into();
+                            package_by_name.insert(alias_of.get_name(), alias_of);
+                        }
                     }
                 }
             }
@@ -250,10 +250,11 @@ impl Locker {
                                 .unwrap_or("")
                                 .to_string();
                             if let Some(base_pkg) = package_by_name.get(&alias_pkg_name) {
-                                let mut alias_pkg = CompleteAliasPackage::new(
-                                    todo!(
-                                        "phase-c: narrow base_pkg handle to CompletePackageHandle"
-                                    ),
+                                let alias_of = base_pkg.as_complete_package().expect(
+                                    "CompleteAliasPackage requires aliasOf to be a real CompletePackage",
+                                );
+                                let alias_pkg = CompleteAliasPackageHandle::new(
+                                    alias_of,
                                     m.get("alias_normalized")
                                         .and_then(|v| v.as_string())
                                         .unwrap_or("")
@@ -263,10 +264,8 @@ impl Locker {
                                         .unwrap_or("")
                                         .to_string(),
                                 );
-                                // TODO(phase-b): set_root_package_alias missing on CompleteAliasPackage
-                                let _ = base_pkg;
-                                // TODO(phase-b): packages.add_package(Box::new(alias_pkg))
-                                let _ = alias_pkg;
+                                alias_pkg.set_root_package_alias(true);
+                                packages.add_package(alias_pkg.into())?;
                             }
                         }
                     }
diff --git a/crates/shirabe/src/repository/handle.rs b/crates/shirabe/src/repository/handle.rs
index 38a4f28..73d4493 100644
--- a/crates/shirabe/src/repository/handle.rs
+++ b/crates/shirabe/src/repository/handle.rs
@@ -202,6 +202,10 @@ impl LockArrayRepositoryHandle {
         self.0.borrow_mut()
     }
 
+    pub fn add_package(&self, package: PackageInterfaceHandle) -> anyhow::Result<()> {
+        self.0.borrow().add_package(package)
+    }
+
     pub fn ptr_eq(&self, other: &Self) -> bool {
         Rc::ptr_eq(&self.0, &other.0)
     }
diff --git a/crates/shirabe/src/repository/lock_array_repository.rs b/crates/shirabe/src/repository/lock_array_repository.rs
index f9b64a7..08e888a 100644
--- a/crates/shirabe/src/repository/lock_array_repository.rs
+++ b/crates/shirabe/src/repository/lock_array_repository.rs
@@ -19,13 +19,19 @@ pub struct LockArrayRepository {
 
 impl CanonicalPackagesTrait for LockArrayRepository {
     fn get_packages(&self) -> Vec<PackageInterfaceHandle> {
-        todo!()
+        RepositoryInterface::get_packages(&self.inner)
     }
 }
 
 impl LockArrayRepository {
-    pub fn clone_box(&self) -> Box<dyn RepositoryInterface> {
-        todo!()
+    pub fn new(packages: Vec<PackageInterfaceHandle>) -> anyhow::Result<Self> {
+        Ok(Self {
+            inner: ArrayRepository::new(packages)?,
+        })
+    }
+
+    pub fn add_package(&self, package: PackageInterfaceHandle) -> anyhow::Result<()> {
+        self.inner.add_package(package)
     }
 }
 
diff --git a/crates/shirabe/src/repository/repository_interface.rs b/crates/shirabe/src/repository/repository_interface.rs
index 21914f6..e75f54e 100644
--- a/crates/shirabe/src/repository/repository_interface.rs
+++ b/crates/shirabe/src/repository/repository_interface.rs
@@ -109,8 +109,4 @@ pub trait RepositoryInterface: Countable + std::fmt::Debug {
     fn set_self_handle(&self, weak: crate::repository::RepositoryInterfaceWeakHandle) {
         let _ = weak;
     }
-
-    fn clone_box(&self) -> Box<dyn RepositoryInterface> {
-        todo!()
-    }
 }