feat(plugin): activate plugins through the PHP RPC worker

Implement the remainder of PluginManager::registerPackage: the plugin
autoload map is built by the ported createLoader/parseAutoloads and
served to the worker over the existing reverse-RPC autoloader, files
entries go through a composerRequire-equivalent glue call, and
already-defined classes take the upstream _composer_tmp rename/eval
path. Instantiation uses the new NewObject/CallPhpMethod lanes backed
by a P table in the worker; PhpPluginProxy adapts the resulting handle
to PluginInterface, with $composer/$io exposed to plugin callbacks via
an R table (unsupported methods stay explicit errors). Hand-written
proxy stubs cover Composer, PartialComposer and the IO hierarchy, and
the stub autoloader is re-prepended after loading the Composer PHP
runtime so its vendor autoloader cannot shadow proxied FQCNs.

FilesystemRepository::write now mirrors InstalledVersions::reload into
a running worker (class_exists-guarded, so an unloaded class keeps its
upstream lazy-load behavior), removing the previously undefined
observation window.

The installer pipeline passes the installed repository as a shared
handle instead of a long-lived `&mut dyn`: plugin registration runs
inside InstallationManager::execute and re-enters the same local
repository through the RepositoryManager, which would panic on the
RefCell re-borrow under the old shape.

PluginInterface lifecycle methods now take an owned ComposerHandle
(plugins retain $composer past the call) and return anyhow::Result
(PHP plugin code may throw); the plugin list uses shared ownership so
the identity comparison of removePlugin survives the dual storage in
registeredPlugins, matching PHP reference semantics.

Ports the activate/upgrade/uninstall tests of PluginInstallerTest,
serialized across the shared worker process whose persistent class
table is exactly what exercises the rename path.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

3 files changed, 101 insertions, 157 deletions

diff --git a/crates/shirabe/tests/installer/installation_manager_test.rs b/crates/shirabe/tests/installer/installation_manager_test.rs
index 6cc231f5..8f2d7d4f 100644
--- a/crates/shirabe/tests/installer/installation_manager_test.rs
+++ b/crates/shirabe/tests/installer/installation_manager_test.rs
@@ -10,7 +10,7 @@ use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::package::PackageInterfaceHandle;
 use shirabe::package::handle::CompletePackageHandle;
-use shirabe::repository::{InstalledArrayRepository, InstalledRepositoryInterface};
+use shirabe::repository::{InstalledArrayRepository, InstalledRepositoryInterfaceHandle};
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
 use shirabe_php_shim::PhpMixed;
@@ -39,11 +39,9 @@ fn set_up() -> SetUp {
     SetUp { loop_, io }
 }
 
-// Equivalent to `getMockBuilder(InstallerInterface::class)->getMock()`. mockall cannot generate an
-// `#[async_trait]` impl for the async methods that take `&mut dyn InstalledRepositoryInterface`
-// (the object lifetime async_trait inserts clashes with mockall's generated lifetimes), so the
-// expectations live on inherent methods and a thin hand-written InstallerInterface impl forwards to
-// them, dropping the unused `repo` argument exactly as the PHPUnit mock ignores it. The methods not
+// Equivalent to `getMockBuilder(InstallerInterface::class)->getMock()`. The expectations live on
+// inherent methods and a thin hand-written InstallerInterface impl forwards to them, dropping the
+// unused `repo` argument exactly as the PHPUnit mock ignores it. The methods not
 // configured by any test (is_installed/download/prepare/cleanup/get_install_path, and the defaulted
 // as_binary_presence_interface/as_plugin_installer_mut) return the same defaults as an unconfigured
 // PHPUnit mock.
@@ -75,7 +73,7 @@ impl InstallerInterface for MockInstaller {
 
     fn is_installed(
         &self,
-        _repo: &mut dyn InstalledRepositoryInterface,
+        _repo: &InstalledRepositoryInterfaceHandle,
         _package: PackageInterfaceHandle,
     ) -> anyhow::Result<bool> {
         Ok(false)
@@ -100,7 +98,7 @@ impl InstallerInterface for MockInstaller {
 
     async fn install(
         &self,
-        _repo: &std::cell::RefCell<&mut dyn InstalledRepositoryInterface>,
+        _repo: &InstalledRepositoryInterfaceHandle,
         package: PackageInterfaceHandle,
     ) -> anyhow::Result<Option<PhpMixed>> {
         MockInstaller::install(self, package)
@@ -108,7 +106,7 @@ impl InstallerInterface for MockInstaller {
 
     async fn update(
         &self,
-        _repo: &std::cell::RefCell<&mut dyn InstalledRepositoryInterface>,
+        _repo: &InstalledRepositoryInterfaceHandle,
         initial: PackageInterfaceHandle,
         target: PackageInterfaceHandle,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -117,7 +115,7 @@ impl InstallerInterface for MockInstaller {
 
     async fn uninstall(
         &self,
-        _repo: &std::cell::RefCell<&mut dyn InstalledRepositoryInterface>,
+        _repo: &InstalledRepositoryInterfaceHandle,
         package: PackageInterfaceHandle,
     ) -> anyhow::Result<Option<PhpMixed>> {
         MockInstaller::uninstall(self, package)
@@ -175,7 +173,7 @@ impl InstallerInterface for BinaryInstaller {
 
     fn is_installed(
         &self,
-        _repo: &mut dyn InstalledRepositoryInterface,
+        _repo: &InstalledRepositoryInterfaceHandle,
         _package: PackageInterfaceHandle,
     ) -> anyhow::Result<bool> {
         Ok(false)
@@ -200,7 +198,7 @@ impl InstallerInterface for BinaryInstaller {
 
     async fn install(
         &self,
-        _repo: &std::cell::RefCell<&mut dyn InstalledRepositoryInterface>,
+        _repo: &InstalledRepositoryInterfaceHandle,
         _package: PackageInterfaceHandle,
     ) -> anyhow::Result<Option<PhpMixed>> {
         Ok(None)
@@ -208,7 +206,7 @@ impl InstallerInterface for BinaryInstaller {
 
     async fn update(
         &self,
-        _repo: &std::cell::RefCell<&mut dyn InstalledRepositoryInterface>,
+        _repo: &InstalledRepositoryInterfaceHandle,
         _initial: PackageInterfaceHandle,
         _target: PackageInterfaceHandle,
     ) -> anyhow::Result<Option<PhpMixed>> {
@@ -217,7 +215,7 @@ impl InstallerInterface for BinaryInstaller {
 
     async fn uninstall(
         &self,
-        _repo: &std::cell::RefCell<&mut dyn InstalledRepositoryInterface>,
+        _repo: &InstalledRepositoryInterfaceHandle,
         _package: PackageInterfaceHandle,
     ) -> anyhow::Result<Option<PhpMixed>> {
         Ok(None)
@@ -360,11 +358,9 @@ fn test_install() {
 
     let operation = InstallOperation::new(package);
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    run(manager.install(
-        &std::cell::RefCell::new(&mut repository as &mut dyn InstalledRepositoryInterface),
-        &operation,
-    ));
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    run(manager.install(&repository, &operation));
 }
 
 #[test]
@@ -395,11 +391,9 @@ fn test_update_with_equal_types() {
 
     let operation = UpdateOperation::new(initial, target);
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    run(manager.update(
-        &std::cell::RefCell::new(&mut repository as &mut dyn InstalledRepositoryInterface),
-        &operation,
-    ));
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    run(manager.update(&repository, &operation));
 }
 
 #[test]
@@ -440,11 +434,9 @@ fn test_update_with_not_equal_types() {
 
     let operation = UpdateOperation::new(initial, target);
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    run(manager.update(
-        &std::cell::RefCell::new(&mut repository as &mut dyn InstalledRepositoryInterface),
-        &operation,
-    ));
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    run(manager.update(&repository, &operation));
 }
 
 #[test]
@@ -471,11 +463,9 @@ fn test_uninstall() {
 
     let operation = UninstallOperation::new(package);
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    run(manager.uninstall(
-        &std::cell::RefCell::new(&mut repository as &mut dyn InstalledRepositoryInterface),
-        &operation,
-    ));
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    run(manager.uninstall(&repository, &operation));
 }
 
 #[test]
diff --git a/crates/shirabe/tests/installer/library_installer_test.rs b/crates/shirabe/tests/installer/library_installer_test.rs
index baa4f13a..6402d903 100644
--- a/crates/shirabe/tests/installer/library_installer_test.rs
+++ b/crates/shirabe/tests/installer/library_installer_test.rs
@@ -12,9 +12,7 @@ use shirabe::installer::{BinaryInstallerInterface, InstallerInterface, LibraryIn
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::package::PackageInterfaceHandle;
-use shirabe::repository::InstalledArrayRepository;
-use shirabe::repository::RepositoryInterface;
-use shirabe::repository::WritableRepositoryInterface;
+use shirabe::repository::{InstalledArrayRepository, InstalledRepositoryInterfaceHandle};
 use shirabe::util::filesystem::Filesystem;
 use shirabe_php_shim::PhpMixed;
 use std::fs;
@@ -199,32 +197,27 @@ fn test_is_installed() {
     let library = LibraryInstaller::new(setup.io.clone(), setup.composer.clone(), None, None, None);
     let package = get_package("test/pkg", "1.0.0");
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    assert!(
-        !library
-            .is_installed(&mut repository, package.clone())
-            .unwrap()
-    );
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    assert!(!library.is_installed(&repository, package.clone()).unwrap());
 
     // package being in repo is not enough to be installed
-    repository.add_package(package.clone()).unwrap();
-    assert!(
-        !library
-            .is_installed(&mut repository, package.clone())
-            .unwrap()
-    );
+    repository
+        .borrow_mut()
+        .add_package(package.clone())
+        .unwrap();
+    assert!(!library.is_installed(&repository, package.clone()).unwrap());
 
     // package being in repo and vendor/pkg/foo dir present means it is seen as installed
     let pkg_dir = format!("{}/{}", setup.vendor_dir, package.get_pretty_name());
     fs::create_dir_all(&pkg_dir).unwrap();
-    assert!(
-        library
-            .is_installed(&mut repository, package.clone())
-            .unwrap()
-    );
+    assert!(library.is_installed(&repository, package.clone()).unwrap());
 
-    repository.remove_package(package.clone()).unwrap();
-    assert!(!library.is_installed(&mut repository, package).unwrap());
+    repository
+        .borrow_mut()
+        .remove_package(package.clone())
+        .unwrap();
+    assert!(!library.is_installed(&repository, package).unwrap());
 
     tear_down(&mut setup);
 }
@@ -250,18 +243,13 @@ fn test_install() {
 
     let library = LibraryInstaller::new(setup.io.clone(), setup.composer.clone(), None, None, None);
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
 
-    run(library.install(
-        &std::cell::RefCell::new(
-            &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface,
-        ),
-        package.clone(),
-    ))
-    .unwrap();
+    run(library.install(&repository, package.clone())).unwrap();
 
     // PHP asserts repository->addPackage was called once with $package.
-    assert!(repository.has_package(package).unwrap());
+    assert!(repository.borrow_mut().has_package(package).unwrap());
 
     assert!(
         std::path::Path::new(&setup.vendor_dir).exists(),
@@ -308,20 +296,17 @@ fn test_update() {
         .returning(|_, _, _| Ok(None));
     set_download_manager(&setup, dm);
 
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    repository.add_package(initial.clone()).unwrap();
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    repository
+        .borrow_mut()
+        .add_package(initial.clone())
+        .unwrap();
 
     // The default Filesystem is fine; the LibraryInstaller's own filesystem performs the rename.
     let library = LibraryInstaller::new(setup.io.clone(), setup.composer.clone(), None, None, None);
 
-    run(library.update(
-        &std::cell::RefCell::new(
-            &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface,
-        ),
-        initial.clone(),
-        target.clone(),
-    ))
-    .unwrap();
+    run(library.update(&repository, initial.clone(), target.clone())).unwrap();
 
     assert!(
         std::path::Path::new(&new_target_dir).exists(),
@@ -329,8 +314,13 @@ fn test_update() {
     );
     assert!(!std::path::Path::new(&old_target_dir).exists());
 
-    assert!(!repository.has_package(initial.clone()).unwrap());
-    assert!(repository.has_package(target.clone()).unwrap());
+    assert!(
+        !repository
+            .borrow_mut()
+            .has_package(initial.clone())
+            .unwrap()
+    );
+    assert!(repository.borrow_mut().has_package(target.clone()).unwrap());
 
     assert!(
         std::path::Path::new(&setup.vendor_dir).exists(),
@@ -342,16 +332,7 @@ fn test_update() {
     );
 
     // Updating again, with the initial package no longer installed, fails.
-    assert!(
-        run(library.update(
-            &std::cell::RefCell::new(
-                &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface
-            ),
-            initial,
-            target
-        ))
-        .is_err()
-    );
+    assert!(run(library.update(&repository, initial, target)).is_err());
 
     tear_down(&mut setup);
 }
@@ -380,30 +361,25 @@ fn test_uninstall() {
     // PHP mocks hasPackage to return (true, false) over two calls; a real repository
     // seeded with the package reproduces this naturally: present, then absent after
     // the first uninstall removes it.
-    let mut repository = InstalledArrayRepository::new().unwrap();
-    repository.add_package(package.clone()).unwrap();
-
-    run(library.uninstall(
-        &std::cell::RefCell::new(
-            &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface,
-        ),
-        package.clone(),
-    ))
-    .unwrap();
+    let repository =
+        InstalledRepositoryInterfaceHandle::new(InstalledArrayRepository::new().unwrap());
+    repository
+        .borrow_mut()
+        .add_package(package.clone())
+        .unwrap();
 
-    assert!(!repository.has_package(package.clone()).unwrap());
+    run(library.uninstall(&repository, package.clone())).unwrap();
 
-    // Uninstalling again, with the package no longer installed, fails.
     assert!(
-        run(library.uninstall(
-            &std::cell::RefCell::new(
-                &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface
-            ),
-            package
-        ))
-        .is_err()
+        !repository
+            .borrow_mut()
+            .has_package(package.clone())
+            .unwrap()
     );
 
+    // Uninstalling again, with the package no longer installed, fails.
+    assert!(run(library.uninstall(&repository, package)).is_err());
+
     tear_down(&mut setup);
 }
 
diff --git a/crates/shirabe/tests/installer/metapackage_installer_test.rs b/crates/shirabe/tests/installer/metapackage_installer_test.rs
index b87fdebd..8675c00e 100644
--- a/crates/shirabe/tests/installer/metapackage_installer_test.rs
+++ b/crates/shirabe/tests/installer/metapackage_installer_test.rs
@@ -8,7 +8,7 @@ use crate::test_case::get_package;
 use shirabe::installer::{InstallerInterface, MetapackageInstaller};
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
-use shirabe::repository::{InstalledArrayRepository, RepositoryInterface};
+use shirabe::repository::{InstalledArrayRepository, InstalledRepositoryInterfaceHandle};
 
 fn installer() -> MetapackageInstaller {
     let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
@@ -20,17 +20,13 @@ fn installer() -> MetapackageInstaller {
 fn test_install() {
     let package = get_package("test/pkg", "1.0.0");
     let installer = installer();
-    let mut repository = InstalledArrayRepository::new_with_packages(vec![]).unwrap();
+    let repository = InstalledRepositoryInterfaceHandle::new(
+        InstalledArrayRepository::new_with_packages(vec![]).unwrap(),
+    );
 
-    run(installer.install(
-        &std::cell::RefCell::new(
-            &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface,
-        ),
-        package.clone(),
-    ))
-    .unwrap();
+    run(installer.install(&repository, package.clone())).unwrap();
 
-    assert!(repository.has_package(package).unwrap());
+    assert!(repository.borrow_mut().has_package(package).unwrap());
 }
 
 #[test]
@@ -38,59 +34,41 @@ fn test_update() {
     let initial = get_package("test/initial", "1.0.0");
     let target = get_package("test/target", "1.0.1");
     let installer = installer();
-    let mut repository =
-        InstalledArrayRepository::new_with_packages(vec![initial.clone()]).unwrap();
-
-    run(installer.update(
-        &std::cell::RefCell::new(
-            &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface,
-        ),
-        initial.clone(),
-        target.clone(),
-    ))
-    .unwrap();
+    let repository = InstalledRepositoryInterfaceHandle::new(
+        InstalledArrayRepository::new_with_packages(vec![initial.clone()]).unwrap(),
+    );
 
-    assert!(!repository.has_package(initial.clone()).unwrap());
-    assert!(repository.has_package(target.clone()).unwrap());
+    run(installer.update(&repository, initial.clone(), target.clone())).unwrap();
 
-    // Updating again, with the initial package no longer installed, fails.
     assert!(
-        run(installer.update(
-            &std::cell::RefCell::new(
-                &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface
-            ),
-            initial,
-            target
-        ))
-        .is_err()
+        !repository
+            .borrow_mut()
+            .has_package(initial.clone())
+            .unwrap()
     );
+    assert!(repository.borrow_mut().has_package(target.clone()).unwrap());
+
+    // Updating again, with the initial package no longer installed, fails.
+    assert!(run(installer.update(&repository, initial, target)).is_err());
 }
 
 #[test]
 fn test_uninstall() {
     let package = get_package("test/pkg", "1.0.0");
     let installer = installer();
-    let mut repository =
-        InstalledArrayRepository::new_with_packages(vec![package.clone()]).unwrap();
-
-    run(installer.uninstall(
-        &std::cell::RefCell::new(
-            &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface,
-        ),
-        package.clone(),
-    ))
-    .unwrap();
+    let repository = InstalledRepositoryInterfaceHandle::new(
+        InstalledArrayRepository::new_with_packages(vec![package.clone()]).unwrap(),
+    );
 
-    assert!(!repository.has_package(package.clone()).unwrap());
+    run(installer.uninstall(&repository, package.clone())).unwrap();
 
-    // Uninstalling again, with the package no longer installed, fails.
     assert!(
-        run(installer.uninstall(
-            &std::cell::RefCell::new(
-                &mut repository as &mut dyn shirabe::repository::InstalledRepositoryInterface
-            ),
-            package
-        ))
-        .is_err()
+        !repository
+            .borrow_mut()
+            .has_package(package.clone())
+            .unwrap()
     );
+
+    // Uninstalling again, with the package no longer installed, fails.
+    assert!(run(installer.uninstall(&repository, package)).is_err());
 }