From b4ab3df2ec85fbe477d7721344a8cd3630b437a1 Mon Sep 17 00:00:00 2001
From: nsfisis <nsfisis@gmail.com>
Date: Sun, 16 Aug 2026 13:59:28 +0900
Subject: feat(plugin): guard Rust-owned classes the worker has no proxy for

The worker's autoloader fell through to the real Composer source for every
Rust-owned FQCN without a proxy stub, so plugin code doing `new Filesystem()`
or subclassing `LibraryInstaller` silently ran on a second instance the Rust
side never sees. An unimplemented part of the plugin API has to fail with an
explicit error naming it, not quietly work on a disconnected copy.

The stub generator now emits a guard class for each of those FQCNs: the real
declaration, hierarchy and constants, with every constructor and method
raising an explicit error. References satisfied by the declaration alone
(`instanceof`, `X::class`, `Link::TYPE_REQUIRE`) keep working. Two FQCNs stay
resolvable to the real class, each listed with the worker-side mechanism that
makes a natively constructed instance correct.

The error had nowhere to go: `Installer::run` dropped the `Result` of both
`dispatch_script` calls, so an exception from a listener ended in exit 0.
Both propagate now, the way the exception does upstream.

Three real-plugin E2E comparisons stop at a guard and are ignored, each
naming the class it needs.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 crates/shirabe-php-rpc/build.rs                    |  20 ++
 .../php/guards/Composer/Advisory/AuditConfig.php   |  24 ++
 .../Composer/Advisory/IgnoredSecurityAdvisory.php  |  25 ++
 .../Composer/Advisory/PartialSecurityAdvisory.php  |  31 +++
 .../guards/Composer/Advisory/SecurityAdvisory.php  |  30 +++
 .../guards/Composer/Autoload/AutoloadGenerator.php | 143 ++++++++++++
 .../shirabe-php-rpc/php/guards/Composer/Cache.php  | 110 +++++++++
 .../php/guards/Composer/Compiler.php               |  22 ++
 .../guards/Composer/Config/JsonConfigSource.php    |  74 ++++++
 .../Composer/DependencyResolver/Decisions.php      | 145 ++++++++++++
 .../Composer/DependencyResolver/DefaultPolicy.php  |  55 +++++
 .../Composer/DependencyResolver/GenericRule.php    | 107 +++++++++
 .../DependencyResolver/LocalRepoTransaction.php    |  20 ++
 .../DependencyResolver/LockTransaction.php         |  37 +++
 .../DependencyResolver/MultiConflictRule.php       | 107 +++++++++
 .../guards/Composer/DependencyResolver/Pool.php    | 115 ++++++++++
 .../Composer/DependencyResolver/PoolBuilder.php    |  37 +++
 .../Composer/DependencyResolver/PoolOptimizer.php  |  22 ++
 .../guards/Composer/DependencyResolver/Request.php | 126 ++++++++++
 .../Composer/DependencyResolver/Rule2Literals.php  | 107 +++++++++
 .../guards/Composer/DependencyResolver/RuleSet.php |  78 +++++++
 .../DependencyResolver/RuleSetGenerator.php        |  65 ++++++
 .../DependencyResolver/RuleSetIterator.php         |  42 ++++
 .../SecurityAdvisoryPoolFilter.php                 |  25 ++
 .../guards/Composer/DependencyResolver/Solver.php  |  58 +++++
 .../Composer/DependencyResolver/Transaction.php    |  39 ++++
 .../guards/Composer/Downloader/FileDownloader.php  | 105 +++++++++
 .../Composer/Downloader/FossilDownloader.php       | 100 ++++++++
 .../guards/Composer/Downloader/GitDownloader.php   | 149 ++++++++++++
 .../guards/Composer/Downloader/GzipDownloader.php  |  45 ++++
 .../guards/Composer/Downloader/HgDownloader.php    | 100 ++++++++
 .../guards/Composer/Downloader/PathDownloader.php  |  48 ++++
 .../Composer/Downloader/PerforceDownloader.php     | 111 +++++++++
 .../guards/Composer/Downloader/PharDownloader.php  |  45 ++++
 .../guards/Composer/Downloader/RarDownloader.php   |  45 ++++
 .../guards/Composer/Downloader/SvnDownloader.php   | 110 +++++++++
 .../guards/Composer/Downloader/TarDownloader.php   |  45 ++++
 .../guards/Composer/Downloader/XzDownloader.php    |  45 ++++
 .../guards/Composer/Downloader/ZipDownloader.php   |  55 +++++
 .../php/guards/Composer/Factory.php                | 134 +++++++++++
 .../IgnoreListPlatformRequirementFilter.php        |  34 +++
 .../php/guards/Composer/Installer.php              | 253 +++++++++++++++++++++
 .../guards/Composer/Installer/BinaryInstaller.php  |  66 ++++++
 .../guards/Composer/Installer/InstallerEvent.php   |  47 ++++
 .../guards/Composer/Installer/LibraryInstaller.php | 104 +++++++++
 .../Composer/Installer/MetapackageInstaller.php    |  66 ++++++
 .../guards/Composer/Installer/PluginInstaller.php  |  64 ++++++
 .../guards/Composer/Installer/ProjectInstaller.php |  68 ++++++
 .../php/guards/Composer/Json/JsonFile.php          |  81 +++++++
 .../Package/Archiver/ArchivableFilesFinder.php     |  24 ++
 .../Composer/Package/Archiver/ArchiveManager.php   |  51 +++++
 .../Composer/Package/Archiver/PharArchiver.php     |  27 +++
 .../Composer/Package/Archiver/ZipArchiver.php      |  27 +++
 .../guards/Composer/Package/Loader/ArrayLoader.php |  40 ++++
 .../Composer/Package/Loader/RootPackageLoader.php  |  39 ++++
 .../Package/Loader/ValidatingArrayLoader.php       |  44 ++++
 .../php/guards/Composer/Package/Locker.php         | 113 +++++++++
 .../Composer/Package/Version/VersionBumper.php     |  25 ++
 .../Composer/Package/Version/VersionSelector.php   |  32 +++
 .../php/guards/Composer/Plugin/CommandEvent.php    |  36 +++
 .../php/guards/Composer/Plugin/PluginManager.php   | 118 ++++++++++
 .../Composer/Plugin/PostFileDownloadEvent.php      |  50 ++++
 .../Composer/Plugin/PreFileDownloadEvent.php       |  65 ++++++
 .../guards/Composer/Plugin/PrePoolCreateEvent.php  |  70 ++++++
 .../Composer/Repository/ArtifactRepository.php     |  34 +++
 .../Composer/Repository/ComposerRepository.php     | 108 +++++++++
 .../Composer/Repository/CompositeRepository.php    |  80 +++++++
 .../Composer/Repository/FilterRepository.php       |  80 +++++++
 .../Composer/Repository/InstalledRepository.php    |  39 ++++
 .../Composer/Repository/LockArrayRepository.php    |  27 +++
 .../Composer/Repository/PackageRepository.php      |  37 +++
 .../guards/Composer/Repository/PathRepository.php  |  38 ++++
 .../guards/Composer/Repository/PearRepository.php  |  17 ++
 .../Composer/Repository/PlatformRepository.php     |  63 +++++
 .../Composer/Repository/RepositoryFactory.php      |  58 +++++
 .../guards/Composer/Repository/RepositorySet.php   |  93 ++++++++
 .../Composer/Repository/RootPackageRepository.php  |  24 ++
 .../Composer/Repository/Vcs/ForgejoDriver.php      | 122 ++++++++++
 .../Composer/Repository/Vcs/FossilDriver.php       | 116 ++++++++++
 .../Composer/Repository/Vcs/GitBitbucketDriver.php | 137 +++++++++++
 .../guards/Composer/Repository/Vcs/GitDriver.php   | 106 +++++++++
 .../Composer/Repository/Vcs/GitHubDriver.php       | 147 ++++++++++++
 .../Composer/Repository/Vcs/GitLabDriver.php       | 165 ++++++++++++++
 .../guards/Composer/Repository/Vcs/HgDriver.php    | 106 +++++++++
 .../Composer/Repository/Vcs/PerforceDriver.php     | 117 ++++++++++
 .../guards/Composer/Repository/Vcs/SvnDriver.php   | 121 ++++++++++
 .../guards/Composer/Repository/VcsRepository.php   |  70 ++++++
 .../php/guards/Composer/Util/AuthHelper.php        |  45 ++++
 .../php/guards/Composer/Util/Bitbucket.php         |  42 ++++
 .../php/guards/Composer/Util/ConfigValidator.php   |  27 +++
 .../php/guards/Composer/Util/Filesystem.php        | 167 ++++++++++++++
 .../php/guards/Composer/Util/Git.php               | 100 ++++++++
 .../php/guards/Composer/Util/GitHub.php            |  52 +++++
 .../php/guards/Composer/Util/GitLab.php            |  40 ++++
 .../guards/Composer/Util/Http/CurlDownloader.php   |  37 +++
 .../php/guards/Composer/Util/Http/CurlResponse.php |  22 ++
 .../php/guards/Composer/Util/Http/Response.php     |  57 +++++
 .../php/guards/Composer/Util/HttpDownloader.php    |  86 +++++++
 .../php/guards/Composer/Util/Loop.php              |  39 ++++
 .../php/guards/Composer/Util/Perforce.php          | 219 ++++++++++++++++++
 .../php/guards/Composer/Util/Platform.php          |  92 ++++++++
 .../php/guards/Composer/Util/ProcessExecutor.php   | 114 ++++++++++
 .../php/guards/Composer/Util/RemoteFilesystem.php  |  85 +++++++
 .../php/guards/Composer/Util/Svn.php               |  82 +++++++
 crates/shirabe-php-rpc/php/worker.php              |  38 +++-
 crates/shirabe-php-rpc/src/lib.rs                  |  22 +-
 crates/shirabe-php-rpc/tests/generated_stubs.rs    |   6 +-
 107 files changed, 7607 insertions(+), 15 deletions(-)
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Advisory/AuditConfig.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Advisory/IgnoredSecurityAdvisory.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Advisory/PartialSecurityAdvisory.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Advisory/SecurityAdvisory.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Autoload/AutoloadGenerator.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Cache.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Compiler.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Config/JsonConfigSource.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Decisions.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/DefaultPolicy.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/GenericRule.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LocalRepoTransaction.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LockTransaction.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/MultiConflictRule.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Pool.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolBuilder.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolOptimizer.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Request.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Rule2Literals.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSet.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetGenerator.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetIterator.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/SecurityAdvisoryPoolFilter.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Solver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Transaction.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/FileDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/FossilDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/GitDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/GzipDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/HgDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/PathDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/PerforceDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/PharDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/RarDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/SvnDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/TarDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/XzDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Downloader/ZipDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Factory.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Filter/PlatformRequirementFilter/IgnoreListPlatformRequirementFilter.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer/BinaryInstaller.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer/InstallerEvent.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer/LibraryInstaller.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer/MetapackageInstaller.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer/PluginInstaller.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Installer/ProjectInstaller.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Json/JsonFile.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchivableFilesFinder.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchiveManager.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/PharArchiver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ZipArchiver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ArrayLoader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/RootPackageLoader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ValidatingArrayLoader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Locker.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionBumper.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionSelector.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Plugin/CommandEvent.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Plugin/PluginManager.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Plugin/PostFileDownloadEvent.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Plugin/PreFileDownloadEvent.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Plugin/PrePoolCreateEvent.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/ArtifactRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/ComposerRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/CompositeRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/FilterRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/InstalledRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/LockArrayRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/PackageRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/PathRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/PearRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/PlatformRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositoryFactory.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositorySet.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/RootPackageRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/ForgejoDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/FossilDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitBitbucketDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitHubDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitLabDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/HgDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/PerforceDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/SvnDriver.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Repository/VcsRepository.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php

(limited to 'crates/shirabe-php-rpc')

diff --git a/crates/shirabe-php-rpc/build.rs b/crates/shirabe-php-rpc/build.rs
index 07a77a07..937d0bb2 100644
--- a/crates/shirabe-php-rpc/build.rs
+++ b/crates/shirabe-php-rpc/build.rs
@@ -79,6 +79,26 @@ fn main() {
     )
     .unwrap();
     println!("cargo::rustc-env=SHIRABE_COMPOSER_RUNTIME_BUNDLE_ID={bundle_id}");
+
+    write_guard_files(&manifest_dir.join("php/guards"), &out_dir);
+}
+
+/// Writes the initializer of `GUARD_FILES`: one `include_str!` per generated guard class. The
+/// list is built here rather than spelled out in the source because there is one guard for every
+/// Rust-owned class the worker has no proxy stub for.
+fn write_guard_files(guards: &Path, out_dir: &Path) {
+    println!("cargo::rerun-if-changed={}", guards.display());
+
+    let mut code = String::from("&[\n");
+    for file in find_files(guards) {
+        code += &format!(
+            "    ({:?}, include_str!({:?})),\n",
+            relative_path(guards, &file),
+            file.to_str().unwrap()
+        );
+    }
+    code += "]\n";
+    std::fs::write(out_dir.join("guard-files.rs"), code).unwrap();
 }
 
 /// Every file the bundle holds, in the order `Compiler::compile` adds them.
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Advisory/AuditConfig.php b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/AuditConfig.php
new file mode 100644
index 00000000..d45d56ad
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/AuditConfig.php
@@ -0,0 +1,24 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Advisory\AuditConfig.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Advisory;
+
+use Composer\Config;
+
+class AuditConfig
+{
+    public function __construct(bool $audit, string $auditFormat, string $auditAbandoned, bool $blockInsecure, bool $blockAbandoned, bool $ignoreUnreachable, array $ignoreListForAudit, array $ignoreListForBlocking, array $ignoreSeverityForAudit, array $ignoreSeverityForBlocking, array $ignoreAbandonedForAudit, array $ignoreAbandonedForBlocking)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public static function fromConfig(Config $config, bool $audit = true, string $auditFormat = Auditor::FORMAT_SUMMARY): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fromConfig');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Advisory/IgnoredSecurityAdvisory.php b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/IgnoredSecurityAdvisory.php
new file mode 100644
index 00000000..56d423bc
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/IgnoredSecurityAdvisory.php
@@ -0,0 +1,25 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Advisory\IgnoredSecurityAdvisory.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Advisory;
+
+use Composer\Semver\Constraint\ConstraintInterface;
+use DateTimeImmutable;
+
+class IgnoredSecurityAdvisory extends SecurityAdvisory
+{
+    public function __construct(string $packageName, string $advisoryId, ConstraintInterface $affectedVersions, string $title, array $sources, DateTimeImmutable $reportedAt, ?string $cve = null, ?string $link = null, ?string $ignoreReason = null, ?string $severity = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function jsonSerialize()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'jsonSerialize');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Advisory/PartialSecurityAdvisory.php b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/PartialSecurityAdvisory.php
new file mode 100644
index 00000000..04d3b121
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/PartialSecurityAdvisory.php
@@ -0,0 +1,31 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Advisory\PartialSecurityAdvisory.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Advisory;
+
+use Composer\Semver\Constraint\ConstraintInterface;
+use Composer\Semver\VersionParser;
+use JsonSerializable;
+
+class PartialSecurityAdvisory implements JsonSerializable
+{
+    public static function create(string $packageName, array $data, VersionParser $parser): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'create');
+    }
+
+    public function __construct(string $packageName, string $advisoryId, ConstraintInterface $affectedVersions)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function jsonSerialize()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'jsonSerialize');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Advisory/SecurityAdvisory.php b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/SecurityAdvisory.php
new file mode 100644
index 00000000..69749f77
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Advisory/SecurityAdvisory.php
@@ -0,0 +1,30 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Advisory\SecurityAdvisory.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Advisory;
+
+use Composer\Semver\Constraint\ConstraintInterface;
+use DateTimeImmutable;
+
+class SecurityAdvisory extends PartialSecurityAdvisory
+{
+    public function __construct(string $packageName, string $advisoryId, ConstraintInterface $affectedVersions, string $title, array $sources, DateTimeImmutable $reportedAt, ?string $cve = null, ?string $link = null, ?string $severity = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function toIgnoredAdvisory(?string $ignoreReason): IgnoredSecurityAdvisory
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'toIgnoredAdvisory');
+    }
+
+    public function jsonSerialize()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'jsonSerialize');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Autoload/AutoloadGenerator.php b/crates/shirabe-php-rpc/php/guards/Composer/Autoload/AutoloadGenerator.php
new file mode 100644
index 00000000..92b6edad
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Autoload/AutoloadGenerator.php
@@ -0,0 +1,143 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Autoload\AutoloadGenerator.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Autoload;
+
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterInterface;
+use Composer\Installer\InstallationManager;
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\Package\RootPackageInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Util\Filesystem;
+use Composer\Package\Locker;
+
+class AutoloadGenerator
+{
+    public function __construct(EventDispatcher $eventDispatcher, ?IOInterface $io = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function setDevMode(bool $devMode = true)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setDevMode');
+    }
+
+    public function setClassMapAuthoritative(bool $classMapAuthoritative)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setClassMapAuthoritative');
+    }
+
+    public function setApcu(bool $apcu, ?string $apcuPrefix = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setApcu');
+    }
+
+    public function setRunScripts(bool $runScripts = true)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setRunScripts');
+    }
+
+    public function setDryRun(bool $dryRun = true): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setDryRun');
+    }
+
+    public function setIgnorePlatformRequirements($ignorePlatformReqs)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setIgnorePlatformRequirements');
+    }
+
+    public function setPlatformRequirementFilter(PlatformRequirementFilterInterface $platformRequirementFilter)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPlatformRequirementFilter');
+    }
+
+    public function dump(Config $config, InstalledRepositoryInterface $localRepo, RootPackageInterface $rootPackage, InstallationManager $installationManager, string $targetDir, bool $scanPsrPackages = false, ?string $suffix = null, ?Locker $locker = null, bool $strictAmbiguous = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'dump');
+    }
+
+    public function buildPackageMap(InstallationManager $installationManager, PackageInterface $rootPackage, array $packages)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'buildPackageMap');
+    }
+
+    protected function validatePackage(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'validatePackage');
+    }
+
+    public function parseAutoloads(array $packageMap, PackageInterface $rootPackage, $filteredDevPackages = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'parseAutoloads');
+    }
+
+    public function createLoader(array $autoloads, ?string $vendorDir = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createLoader');
+    }
+
+    protected function getIncludePathsFile(array $packageMap, Filesystem $filesystem, string $basePath, string $vendorPath, string $vendorPathCode, string $appBaseDirCode)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getIncludePathsFile');
+    }
+
+    protected function getIncludeFilesFile(array $files, Filesystem $filesystem, string $basePath, string $vendorPath, string $vendorPathCode, string $appBaseDirCode)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getIncludeFilesFile');
+    }
+
+    protected function getPathCode(Filesystem $filesystem, string $basePath, string $vendorPath, string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPathCode');
+    }
+
+    protected function getPlatformCheck(array $packageMap, $checkPlatform, array $devPackageNames)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPlatformCheck');
+    }
+
+    protected function getAutoloadFile(string $vendorPathToTargetDirCode, string $suffix)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAutoloadFile');
+    }
+
+    protected function getAutoloadRealFile(bool $useClassMap, bool $useIncludePath, ?string $targetDirLoader, bool $useIncludeFiles, string $vendorPathCode, string $appBaseDirCode, string $suffix, bool $useGlobalIncludePath, string $prependAutoloader, bool $checkPlatform)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAutoloadRealFile');
+    }
+
+    protected function getStaticFile(string $suffix, string $targetDir, string $vendorPath, string $basePath)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStaticFile');
+    }
+
+    protected function parseAutoloadsType(array $packageMap, string $type, RootPackageInterface $rootPackage)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'parseAutoloadsType');
+    }
+
+    protected function getFileIdentifier(PackageInterface $package, string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileIdentifier');
+    }
+
+    protected function filterPackageMap(array $packageMap, RootPackageInterface $rootPackage)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'filterPackageMap');
+    }
+
+    protected function sortPackageMap(array $packageMap)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'sortPackageMap');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Cache.php b/crates/shirabe-php-rpc/php/guards/Composer/Cache.php
new file mode 100644
index 00000000..286b262c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Cache.php
@@ -0,0 +1,110 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Cache.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer;
+
+use Composer\IO\IOInterface;
+use Composer\Util\Filesystem;
+
+class Cache
+{
+    public function __construct(IOInterface $io, string $cacheDir, string $allowlist = 'a-z0-9._', ?Filesystem $filesystem = null, bool $readOnly = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function setReadOnly(bool $readOnly)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setReadOnly');
+    }
+
+    public function isReadOnly()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isReadOnly');
+    }
+
+    public static function isUsable(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isUsable');
+    }
+
+    public function isEnabled()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isEnabled');
+    }
+
+    public function getRoot()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRoot');
+    }
+
+    public function read(string $file)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'read');
+    }
+
+    public function write(string $file, string $contents)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'write');
+    }
+
+    public function copyFrom(string $file, string $source)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'copyFrom');
+    }
+
+    public function copyTo(string $file, string $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'copyTo');
+    }
+
+    public function gcIsNecessary()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'gcIsNecessary');
+    }
+
+    public function remove(string $file)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function clear()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'clear');
+    }
+
+    public function getAge(string $file)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAge');
+    }
+
+    public function gc(int $ttl, int $maxSize)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'gc');
+    }
+
+    public function gcVcsCache(int $ttl): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'gcVcsCache');
+    }
+
+    public function sha1(string $file)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'sha1');
+    }
+
+    public function sha256(string $file)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'sha256');
+    }
+
+    protected function getFinder()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFinder');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Compiler.php b/crates/shirabe-php-rpc/php/guards/Composer/Compiler.php
new file mode 100644
index 00000000..ba4ddff4
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Compiler.php
@@ -0,0 +1,22 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Compiler.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer;
+
+class Compiler
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function compile(string $pharFile = 'composer.phar'): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'compile');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Config/JsonConfigSource.php b/crates/shirabe-php-rpc/php/guards/Composer/Config/JsonConfigSource.php
new file mode 100644
index 00000000..ce71cc7e
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Config/JsonConfigSource.php
@@ -0,0 +1,74 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Config\JsonConfigSource.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Config;
+
+use Composer\Json\JsonFile;
+
+class JsonConfigSource implements ConfigSourceInterface
+{
+    public function __construct(JsonFile $file, bool $authConfig = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getName');
+    }
+
+    public function addRepository(string $name, $config, bool $append = true): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRepository');
+    }
+
+    public function insertRepository(string $name, $config, string $referenceName, int $offset = 0): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'insertRepository');
+    }
+
+    public function setRepositoryUrl(string $name, string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setRepositoryUrl');
+    }
+
+    public function removeRepository(string $name): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeRepository');
+    }
+
+    public function addConfigSetting(string $name, $value): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addConfigSetting');
+    }
+
+    public function removeConfigSetting(string $name): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeConfigSetting');
+    }
+
+    public function addProperty(string $name, $value): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addProperty');
+    }
+
+    public function removeProperty(string $name): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeProperty');
+    }
+
+    public function addLink(string $type, string $name, string $value): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addLink');
+    }
+
+    public function removeLink(string $type, string $name): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeLink');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Decisions.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Decisions.php
new file mode 100644
index 00000000..21d44992
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Decisions.php
@@ -0,0 +1,145 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\Decisions.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class Decisions implements \Iterator, \Countable
+{
+    public const DECISION_LITERAL = 0;
+    public const DECISION_REASON = 1;
+
+    public function __construct(Pool $pool)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function decide(int $literal, int $level, Rule $why): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'decide');
+    }
+
+    public function satisfy(int $literal): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'satisfy');
+    }
+
+    public function conflict(int $literal): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'conflict');
+    }
+
+    public function decided(int $literalOrPackageId): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'decided');
+    }
+
+    public function undecided(int $literalOrPackageId): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'undecided');
+    }
+
+    public function decidedInstall(int $literalOrPackageId): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'decidedInstall');
+    }
+
+    public function decisionLevel(int $literalOrPackageId): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'decisionLevel');
+    }
+
+    public function decisionRule(int $literalOrPackageId): Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'decisionRule');
+    }
+
+    public function atOffset(int $queueOffset): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'atOffset');
+    }
+
+    public function validOffset(int $queueOffset): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'validOffset');
+    }
+
+    public function lastReason(): Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'lastReason');
+    }
+
+    public function lastLiteral(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'lastLiteral');
+    }
+
+    public function reset(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'reset');
+    }
+
+    public function resetToOffset(int $offset): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'resetToOffset');
+    }
+
+    public function revertLast(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'revertLast');
+    }
+
+    public function count(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'count');
+    }
+
+    public function rewind(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'rewind');
+    }
+
+    public function current()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'current');
+    }
+
+    public function key(): ?int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'key');
+    }
+
+    public function next(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'next');
+    }
+
+    public function valid(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'valid');
+    }
+
+    public function isEmpty(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isEmpty');
+    }
+
+    protected function addDecision(int $literal, int $level): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addDecision');
+    }
+
+    public function toString(?Pool $pool = null): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'toString');
+    }
+
+    public function __toString(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__toString');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/DefaultPolicy.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/DefaultPolicy.php
new file mode 100644
index 00000000..bf6e55fb
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/DefaultPolicy.php
@@ -0,0 +1,55 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\DefaultPolicy.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Package\BasePackage;
+use Composer\Package\PackageInterface;
+
+class DefaultPolicy implements PolicyInterface
+{
+    public function __construct(bool $preferStable = false, bool $preferLowest = false, ?array $preferredVersions = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function versionCompare(PackageInterface $a, PackageInterface $b, string $operator): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'versionCompare');
+    }
+
+    public function selectPreferredPackages(Pool $pool, array $literals, ?string $requiredPackage = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'selectPreferredPackages');
+    }
+
+    protected function groupLiteralsByName(Pool $pool, array $literals): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'groupLiteralsByName');
+    }
+
+    public function compareByPriority(Pool $pool, BasePackage $a, BasePackage $b, ?string $requiredPackage = null, bool $ignoreReplace = false): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'compareByPriority');
+    }
+
+    protected function replaces(BasePackage $source, BasePackage $target): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'replaces');
+    }
+
+    protected function pruneToBestVersion(Pool $pool, array $literals): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'pruneToBestVersion');
+    }
+
+    protected function pruneRemoteAliases(Pool $pool, array $literals): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'pruneRemoteAliases');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/GenericRule.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/GenericRule.php
new file mode 100644
index 00000000..639f47fa
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/GenericRule.php
@@ -0,0 +1,107 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\GenericRule.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class GenericRule extends Rule
+{
+    public function __construct(array $literals, $reason, $reasonData)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getLiterals(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLiterals');
+    }
+
+    public function getHash()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHash');
+    }
+
+    public function equals(Rule $rule): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'equals');
+    }
+
+    public function isAssertion(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isAssertion');
+    }
+
+    public function __toString(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__toString');
+    }
+
+    public function getReason(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReason');
+    }
+
+    public function getReasonData()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReasonData');
+    }
+
+    public function getRequiredPackage(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRequiredPackage');
+    }
+
+    public function setType($type): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setType');
+    }
+
+    public function getType(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getType');
+    }
+
+    public function disable(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'disable');
+    }
+
+    public function enable(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'enable');
+    }
+
+    public function isDisabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDisabled');
+    }
+
+    public function isEnabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isEnabled');
+    }
+
+    public function isCausedByLock(RepositorySet $repositorySet, Request $request, Pool $pool): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isCausedByLock');
+    }
+
+    public function getSourcePackage(Pool $pool): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSourcePackage');
+    }
+
+    public function getPrettyString(RepositorySet $repositorySet, Request $request, Pool $pool, bool $isVerbose, array $installedMap = [], array $learnedPool = []): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPrettyString');
+    }
+
+    protected function formatPackagesUnique(Pool $pool, array $literalsOrPackages, bool $isVerbose, ?ConstraintInterface $constraint = null, bool $useRemovedVersionGroup = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'formatPackagesUnique');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LocalRepoTransaction.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LocalRepoTransaction.php
new file mode 100644
index 00000000..8c702b28
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LocalRepoTransaction.php
@@ -0,0 +1,20 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\LocalRepoTransaction.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Repository\RepositoryInterface;
+
+class LocalRepoTransaction extends Transaction
+{
+    public function __construct(RepositoryInterface $lockedRepository, InstalledRepositoryInterface $localRepository)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LockTransaction.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LockTransaction.php
new file mode 100644
index 00000000..e7a0b36f
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/LockTransaction.php
@@ -0,0 +1,37 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\LockTransaction.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class LockTransaction extends Transaction
+{
+    public function __construct(Pool $pool, array $presentMap, array $unlockableMap, Decisions $decisions)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function setResultPackages(Pool $pool, Decisions $decisions): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setResultPackages');
+    }
+
+    public function setNonDevPackages(LockTransaction $extractionResult): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setNonDevPackages');
+    }
+
+    public function getNewLockPackages(bool $devMode, bool $updateMirrors = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getNewLockPackages');
+    }
+
+    public function getAliases(array $aliases): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAliases');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/MultiConflictRule.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/MultiConflictRule.php
new file mode 100644
index 00000000..d8d86170
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/MultiConflictRule.php
@@ -0,0 +1,107 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\MultiConflictRule.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class MultiConflictRule extends Rule
+{
+    public function __construct(array $literals, $reason, $reasonData)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getLiterals(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLiterals');
+    }
+
+    public function getHash()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHash');
+    }
+
+    public function equals(Rule $rule): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'equals');
+    }
+
+    public function isAssertion(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isAssertion');
+    }
+
+    public function disable(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'disable');
+    }
+
+    public function __toString(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__toString');
+    }
+
+    public function getReason(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReason');
+    }
+
+    public function getReasonData()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReasonData');
+    }
+
+    public function getRequiredPackage(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRequiredPackage');
+    }
+
+    public function setType($type): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setType');
+    }
+
+    public function getType(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getType');
+    }
+
+    public function enable(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'enable');
+    }
+
+    public function isDisabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDisabled');
+    }
+
+    public function isEnabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isEnabled');
+    }
+
+    public function isCausedByLock(RepositorySet $repositorySet, Request $request, Pool $pool): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isCausedByLock');
+    }
+
+    public function getSourcePackage(Pool $pool): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSourcePackage');
+    }
+
+    public function getPrettyString(RepositorySet $repositorySet, Request $request, Pool $pool, bool $isVerbose, array $installedMap = [], array $learnedPool = []): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPrettyString');
+    }
+
+    protected function formatPackagesUnique(Pool $pool, array $literalsOrPackages, bool $isVerbose, ?ConstraintInterface $constraint = null, bool $useRemovedVersionGroup = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'formatPackagesUnique');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Pool.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Pool.php
new file mode 100644
index 00000000..a1770817
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Pool.php
@@ -0,0 +1,115 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\Pool.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Package\BasePackage;
+use Composer\Semver\Constraint\ConstraintInterface;
+
+class Pool implements \Countable
+{
+    public function __construct(array $packages = [], array $unacceptableFixedOrLockedPackages = [], array $removedVersions = [], array $removedVersionsByPackage = [], array $securityRemovedVersions = [], array $abandonedRemovedVersions = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRemovedVersions(string $name, ConstraintInterface $constraint): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRemovedVersions');
+    }
+
+    public function getAllRemovedVersions(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAllRemovedVersions');
+    }
+
+    public function getRemovedVersionsByPackage(string $objectHash): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRemovedVersionsByPackage');
+    }
+
+    public function getAllRemovedVersionsByPackage(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAllRemovedVersionsByPackage');
+    }
+
+    public function isSecurityRemovedPackageVersion(string $packageName, ?ConstraintInterface $constraint): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isSecurityRemovedPackageVersion');
+    }
+
+    public function getSecurityAdvisoryIdentifiersForPackageVersion(string $packageName, ?ConstraintInterface $constraint): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSecurityAdvisoryIdentifiersForPackageVersion');
+    }
+
+    public function isAbandonedRemovedPackageVersion(string $packageName, ?ConstraintInterface $constraint): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isAbandonedRemovedPackageVersion');
+    }
+
+    public function getAllSecurityRemovedPackageVersions(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAllSecurityRemovedPackageVersions');
+    }
+
+    public function getAllAbandonedRemovedPackageVersions(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAllAbandonedRemovedPackageVersions');
+    }
+
+    public function getPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackages');
+    }
+
+    public function packageById(int $id): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'packageById');
+    }
+
+    public function count(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'count');
+    }
+
+    public function whatProvides(string $name, ?ConstraintInterface $constraint = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'whatProvides');
+    }
+
+    public function literalToPackage(int $literal): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'literalToPackage');
+    }
+
+    public function literalToPrettyString(int $literal, array $installedMap): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'literalToPrettyString');
+    }
+
+    public function match(BasePackage $candidate, string $name, ?ConstraintInterface $constraint = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'match');
+    }
+
+    public function isUnacceptableFixedOrLockedPackage(BasePackage $package): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isUnacceptableFixedOrLockedPackage');
+    }
+
+    public function getUnacceptableFixedOrLockedPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUnacceptableFixedOrLockedPackages');
+    }
+
+    public function __toString(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__toString');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolBuilder.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolBuilder.php
new file mode 100644
index 00000000..78afa42d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolBuilder.php
@@ -0,0 +1,37 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\PoolBuilder.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\IO\IOInterface;
+
+class PoolBuilder
+{
+    private const LOAD_BATCH_SIZE = 50;
+
+    public function __construct(array $acceptableStabilities, array $stabilityFlags, array $rootAliases, array $rootReferences, IOInterface $io, ?EventDispatcher $eventDispatcher = null, ?PoolOptimizer $poolOptimizer = null, array $temporaryConstraints = [], ?SecurityAdvisoryPoolFilter $securityAdvisoryPoolFilter = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function setIgnoredTypes(array $types): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setIgnoredTypes');
+    }
+
+    public function setAllowedTypes(?array $types): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setAllowedTypes');
+    }
+
+    public function buildPool(array $repositories, Request $request): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'buildPool');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolOptimizer.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolOptimizer.php
new file mode 100644
index 00000000..59489d6c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/PoolOptimizer.php
@@ -0,0 +1,22 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\PoolOptimizer.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class PoolOptimizer
+{
+    public function __construct(PolicyInterface $policy)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function optimize(Request $request, Pool $pool): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'optimize');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Request.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Request.php
new file mode 100644
index 00000000..2d472d18
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Request.php
@@ -0,0 +1,126 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\Request.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Package\BasePackage;
+use Composer\Package\PackageInterface;
+use Composer\Repository\LockArrayRepository;
+use Composer\Semver\Constraint\ConstraintInterface;
+
+class Request
+{
+    public const UPDATE_ONLY_LISTED = 0;
+    public const UPDATE_LISTED_WITH_TRANSITIVE_DEPS_NO_ROOT_REQUIRE = 1;
+    public const UPDATE_LISTED_WITH_TRANSITIVE_DEPS = 2;
+
+    public function __construct(?LockArrayRepository $lockedRepository = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function requireName(string $packageName, ?ConstraintInterface $constraint = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'requireName');
+    }
+
+    public function fixPackage(BasePackage $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fixPackage');
+    }
+
+    public function lockPackage(BasePackage $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'lockPackage');
+    }
+
+    public function fixLockedPackage(BasePackage $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fixLockedPackage');
+    }
+
+    public function unlockPackage(BasePackage $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'unlockPackage');
+    }
+
+    public function setUpdateAllowList(array $updateAllowList, $updateAllowTransitiveDependencies): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUpdateAllowList');
+    }
+
+    public function getUpdateAllowList(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUpdateAllowList');
+    }
+
+    public function getUpdateAllowTransitiveDependencies(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUpdateAllowTransitiveDependencies');
+    }
+
+    public function getUpdateAllowTransitiveRootDependencies(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUpdateAllowTransitiveRootDependencies');
+    }
+
+    public function getRequires(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRequires');
+    }
+
+    public function getFixedPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFixedPackages');
+    }
+
+    public function isFixedPackage(BasePackage $package): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isFixedPackage');
+    }
+
+    public function getLockedPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLockedPackages');
+    }
+
+    public function isLockedPackage(PackageInterface $package): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isLockedPackage');
+    }
+
+    public function getFixedOrLockedPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFixedOrLockedPackages');
+    }
+
+    public function getPresentMap(bool $packageIds = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPresentMap');
+    }
+
+    public function getFixedPackagesMap(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFixedPackagesMap');
+    }
+
+    public function getLockedRepository(): ?LockArrayRepository
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLockedRepository');
+    }
+
+    public function restrictPackages(array $names): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'restrictPackages');
+    }
+
+    public function getRestrictedPackages(): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRestrictedPackages');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Rule2Literals.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Rule2Literals.php
new file mode 100644
index 00000000..6527e99b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Rule2Literals.php
@@ -0,0 +1,107 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\Rule2Literals.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class Rule2Literals extends Rule
+{
+    public function __construct(int $literal1, int $literal2, $reason, $reasonData)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getLiterals(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLiterals');
+    }
+
+    public function getHash()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHash');
+    }
+
+    public function equals(Rule $rule): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'equals');
+    }
+
+    public function isAssertion(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isAssertion');
+    }
+
+    public function __toString(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__toString');
+    }
+
+    public function getReason(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReason');
+    }
+
+    public function getReasonData()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReasonData');
+    }
+
+    public function getRequiredPackage(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRequiredPackage');
+    }
+
+    public function setType($type): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setType');
+    }
+
+    public function getType(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getType');
+    }
+
+    public function disable(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'disable');
+    }
+
+    public function enable(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'enable');
+    }
+
+    public function isDisabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDisabled');
+    }
+
+    public function isEnabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isEnabled');
+    }
+
+    public function isCausedByLock(RepositorySet $repositorySet, Request $request, Pool $pool): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isCausedByLock');
+    }
+
+    public function getSourcePackage(Pool $pool): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSourcePackage');
+    }
+
+    public function getPrettyString(RepositorySet $repositorySet, Request $request, Pool $pool, bool $isVerbose, array $installedMap = [], array $learnedPool = []): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPrettyString');
+    }
+
+    protected function formatPackagesUnique(Pool $pool, array $literalsOrPackages, bool $isVerbose, ?ConstraintInterface $constraint = null, bool $useRemovedVersionGroup = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'formatPackagesUnique');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSet.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSet.php
new file mode 100644
index 00000000..40d6780a
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSet.php
@@ -0,0 +1,78 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\RuleSet.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Repository\RepositorySet;
+
+class RuleSet implements \IteratorAggregate, \Countable
+{
+    public const TYPE_PACKAGE = 0;
+    public const TYPE_REQUEST = 1;
+    public const TYPE_LEARNED = 4;
+    public const TYPES = [
+        self::TYPE_PACKAGE => 'PACKAGE',
+        self::TYPE_REQUEST => 'REQUEST',
+        self::TYPE_LEARNED => 'LEARNED',
+    ];
+
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function add(Rule $rule, $type): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'add');
+    }
+
+    public function count(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'count');
+    }
+
+    public function ruleById(int $id): Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'ruleById');
+    }
+
+    public function getRules(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRules');
+    }
+
+    public function getIterator(): RuleSetIterator
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getIterator');
+    }
+
+    public function getIteratorFor($types): RuleSetIterator
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getIteratorFor');
+    }
+
+    public function getIteratorWithout($types): RuleSetIterator
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getIteratorWithout');
+    }
+
+    public function getTypes(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTypes');
+    }
+
+    public function getPrettyString(?RepositorySet $repositorySet = null, ?Request $request = null, ?Pool $pool = null, bool $isVerbose = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPrettyString');
+    }
+
+    public function __toString(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__toString');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetGenerator.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetGenerator.php
new file mode 100644
index 00000000..4406ddda
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetGenerator.php
@@ -0,0 +1,65 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\RuleSetGenerator.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterInterface;
+use Composer\Package\BasePackage;
+
+class RuleSetGenerator
+{
+    public function __construct(PolicyInterface $policy, Pool $pool)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function createRequireRule(BasePackage $package, array $providers, $reason, $reasonData): ?Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createRequireRule');
+    }
+
+    protected function createInstallOneOfRule(array $packages, $reason, $reasonData): Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createInstallOneOfRule');
+    }
+
+    protected function createRule2Literals(BasePackage $issuer, BasePackage $provider, $reason, $reasonData): ?Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createRule2Literals');
+    }
+
+    protected function createMultiConflictRule(array $packages, $reason, $reasonData): Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createMultiConflictRule');
+    }
+
+    protected function addRulesForPackage(BasePackage $package, PlatformRequirementFilterInterface $platformRequirementFilter): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRulesForPackage');
+    }
+
+    protected function addConflictRules(PlatformRequirementFilterInterface $platformRequirementFilter): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addConflictRules');
+    }
+
+    protected function addRulesForRequest(Request $request, PlatformRequirementFilterInterface $platformRequirementFilter): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRulesForRequest');
+    }
+
+    protected function addRulesForRootAliases(PlatformRequirementFilterInterface $platformRequirementFilter): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRulesForRootAliases');
+    }
+
+    public function getRulesFor(Request $request, ?PlatformRequirementFilterInterface $platformRequirementFilter = null): RuleSet
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRulesFor');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetIterator.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetIterator.php
new file mode 100644
index 00000000..e02b58de
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/RuleSetIterator.php
@@ -0,0 +1,42 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\RuleSetIterator.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+class RuleSetIterator implements \Iterator
+{
+    public function __construct(array $rules)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function current(): Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'current');
+    }
+
+    public function key(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'key');
+    }
+
+    public function next(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'next');
+    }
+
+    public function rewind(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'rewind');
+    }
+
+    public function valid(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'valid');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/SecurityAdvisoryPoolFilter.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/SecurityAdvisoryPoolFilter.php
new file mode 100644
index 00000000..43250c43
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/SecurityAdvisoryPoolFilter.php
@@ -0,0 +1,25 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\SecurityAdvisoryPoolFilter.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Advisory\AuditConfig;
+use Composer\Advisory\Auditor;
+
+class SecurityAdvisoryPoolFilter
+{
+    public function __construct(Auditor $auditor, AuditConfig $auditConfig)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function filter(Pool $pool, array $repositories, Request $request): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'filter');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Solver.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Solver.php
new file mode 100644
index 00000000..b339f276
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Solver.php
@@ -0,0 +1,58 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\Solver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterInterface;
+use Composer\IO\IOInterface;
+
+class Solver
+{
+    private const BRANCH_LITERALS = 0;
+    private const BRANCH_LEVEL = 1;
+
+    public function __construct(PolicyInterface $policy, Pool $pool, IOInterface $io)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRuleSetSize(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRuleSetSize');
+    }
+
+    public function getPool(): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPool');
+    }
+
+    protected function setupFixedMap(Request $request): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setupFixedMap');
+    }
+
+    protected function checkForRootRequireProblems(Request $request, PlatformRequirementFilterInterface $platformRequirementFilter): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'checkForRootRequireProblems');
+    }
+
+    public function solve(Request $request, ?PlatformRequirementFilterInterface $platformRequirementFilter = null): LockTransaction
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'solve');
+    }
+
+    protected function propagate(int $level): ?Rule
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'propagate');
+    }
+
+    protected function analyze(int $level, Rule $rule): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'analyze');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Transaction.php b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Transaction.php
new file mode 100644
index 00000000..e3388d49
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/DependencyResolver/Transaction.php
@@ -0,0 +1,39 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\DependencyResolver\Transaction.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\DependencyResolver;
+
+use Composer\Package\Link;
+
+class Transaction
+{
+    public function __construct(array $presentPackages, array $resultPackages)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getOperations(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getOperations');
+    }
+
+    protected function calculateOperations(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'calculateOperations');
+    }
+
+    protected function getRootPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootPackages');
+    }
+
+    protected function getProvidersInResult(Link $link): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProvidersInResult');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/FileDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/FileDownloader.php
new file mode 100644
index 00000000..0232b002
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/FileDownloader.php
@@ -0,0 +1,105 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\FileDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use Composer\Config;
+use Composer\Cache;
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Util\Filesystem;
+use Composer\Util\HttpDownloader;
+use Composer\Util\ProcessExecutor;
+use React\Promise\PromiseInterface;
+
+class FileDownloader implements DownloaderInterface, ChangeReportInterface
+{
+    public static $downloadMetadata = [];
+    public static $responseHeaders = [];
+
+    public function __construct(IOInterface $io, Config $config, HttpDownloader $httpDownloader, ?EventDispatcher $eventDispatcher = null, ?Cache $cache = null, ?Filesystem $filesystem = null, ?ProcessExecutor $process = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getInstallationSource(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallationSource');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getDistPath(PackageInterface $package, int $component): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDistPath');
+    }
+
+    protected function clearLastCacheWrite(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'clearLastCacheWrite');
+    }
+
+    protected function addCleanupPath(PackageInterface $package, string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addCleanupPath');
+    }
+
+    protected function removeCleanupPath(PackageInterface $package, string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeCleanupPath');
+    }
+
+    public function update(PackageInterface $initial, PackageInterface $target, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function remove(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    protected function getFileName(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileName');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+
+    protected function processUrl(PackageInterface $package, string $url): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'processUrl');
+    }
+
+    public function getLocalChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLocalChanges');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/FossilDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/FossilDownloader.php
new file mode 100644
index 00000000..1990705e
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/FossilDownloader.php
@@ -0,0 +1,100 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\FossilDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class FossilDownloader extends VcsDownloader
+{
+    protected function doDownload(PackageInterface $package, string $path, string $url, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doDownload');
+    }
+
+    protected function doInstall(PackageInterface $package, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doInstall');
+    }
+
+    protected function doUpdate(PackageInterface $initial, PackageInterface $target, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doUpdate');
+    }
+
+    public function getLocalChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLocalChanges');
+    }
+
+    protected function getCommitLogs(string $fromReference, string $toReference, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs');
+    }
+
+    protected function hasMetadataRepository(string $path): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasMetadataRepository');
+    }
+
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?Filesystem $fs = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getInstallationSource(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallationSource');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(PackageInterface $initial, PackageInterface $target, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function remove(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function getVcsReference(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVcsReference');
+    }
+
+    protected function cleanChanges(PackageInterface $package, string $path, bool $update): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanChanges');
+    }
+
+    protected function reapplyChanges(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'reapplyChanges');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/GitDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/GitDownloader.php
new file mode 100644
index 00000000..3ab711fb
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/GitDownloader.php
@@ -0,0 +1,149 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\GitDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\Util\Filesystem;
+use Composer\Util\ProcessExecutor;
+use React\Promise\PromiseInterface;
+
+class GitDownloader extends VcsDownloader implements DvcsDownloaderInterface
+{
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?Filesystem $fs = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function doDownload(PackageInterface $package, string $path, string $url, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doDownload');
+    }
+
+    protected function doInstall(PackageInterface $package, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doInstall');
+    }
+
+    protected function doUpdate(PackageInterface $initial, PackageInterface $target, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doUpdate');
+    }
+
+    public function getLocalChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLocalChanges');
+    }
+
+    public function getUnpushedChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUnpushedChanges');
+    }
+
+    protected function cleanChanges(PackageInterface $package, string $path, bool $update): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanChanges');
+    }
+
+    protected function reapplyChanges(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'reapplyChanges');
+    }
+
+    protected function updateToCommit(PackageInterface $package, string $path, string $reference, string $prettyVersion): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'updateToCommit');
+    }
+
+    protected function updateOriginUrl(string $path, string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'updateOriginUrl');
+    }
+
+    protected function setPushUrl(string $path, string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPushUrl');
+    }
+
+    protected function getCommitLogs(string $fromReference, string $toReference, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs');
+    }
+
+    protected function discardChanges(string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'discardChanges');
+    }
+
+    protected function stashChanges(string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'stashChanges');
+    }
+
+    protected function viewDiff(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'viewDiff');
+    }
+
+    protected function normalizePath(string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'normalizePath');
+    }
+
+    protected function hasMetadataRepository(string $path): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasMetadataRepository');
+    }
+
+    protected function getShortHash(string $reference): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getShortHash');
+    }
+
+    public function getInstallationSource(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallationSource');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(PackageInterface $initial, PackageInterface $target, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function remove(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function getVcsReference(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVcsReference');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/GzipDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/GzipDownloader.php
new file mode 100644
index 00000000..df6da1d5
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/GzipDownloader.php
@@ -0,0 +1,45 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\GzipDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class GzipDownloader extends ArchiveDownloader
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function extract(PackageInterface $package, string $file, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extract');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/HgDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/HgDownloader.php
new file mode 100644
index 00000000..24abe7d2
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/HgDownloader.php
@@ -0,0 +1,100 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\HgDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class HgDownloader extends VcsDownloader
+{
+    protected function doDownload(PackageInterface $package, string $path, string $url, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doDownload');
+    }
+
+    protected function doInstall(PackageInterface $package, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doInstall');
+    }
+
+    protected function doUpdate(PackageInterface $initial, PackageInterface $target, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doUpdate');
+    }
+
+    public function getLocalChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLocalChanges');
+    }
+
+    protected function getCommitLogs(string $fromReference, string $toReference, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs');
+    }
+
+    protected function hasMetadataRepository(string $path): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasMetadataRepository');
+    }
+
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?Filesystem $fs = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getInstallationSource(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallationSource');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(PackageInterface $initial, PackageInterface $target, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function remove(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function getVcsReference(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVcsReference');
+    }
+
+    protected function cleanChanges(PackageInterface $package, string $path, bool $update): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanChanges');
+    }
+
+    protected function reapplyChanges(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'reapplyChanges');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PathDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PathDownloader.php
new file mode 100644
index 00000000..f565b3c4
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PathDownloader.php
@@ -0,0 +1,48 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\PathDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class PathDownloader extends FileDownloader implements VcsCapableDownloaderInterface
+{
+    private const STRATEGY_SYMLINK = 10;
+    private const STRATEGY_MIRROR = 20;
+
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function remove(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function getVcsReference(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVcsReference');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PerforceDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PerforceDownloader.php
new file mode 100644
index 00000000..91eb45cf
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PerforceDownloader.php
@@ -0,0 +1,111 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\PerforceDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+use Composer\Util\Perforce;
+
+class PerforceDownloader extends VcsDownloader
+{
+    protected function doDownload(PackageInterface $package, string $path, string $url, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doDownload');
+    }
+
+    public function doInstall(PackageInterface $package, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doInstall');
+    }
+
+    public function initPerforce(PackageInterface $package, string $path, string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initPerforce');
+    }
+
+    protected function doUpdate(PackageInterface $initial, PackageInterface $target, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doUpdate');
+    }
+
+    public function getLocalChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLocalChanges');
+    }
+
+    protected function getCommitLogs(string $fromReference, string $toReference, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs');
+    }
+
+    public function setPerforce(Perforce $perforce): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPerforce');
+    }
+
+    protected function hasMetadataRepository(string $path): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasMetadataRepository');
+    }
+
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?Filesystem $fs = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getInstallationSource(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallationSource');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(PackageInterface $initial, PackageInterface $target, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function remove(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function getVcsReference(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVcsReference');
+    }
+
+    protected function cleanChanges(PackageInterface $package, string $path, bool $update): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanChanges');
+    }
+
+    protected function reapplyChanges(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'reapplyChanges');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PharDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PharDownloader.php
new file mode 100644
index 00000000..84314215
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/PharDownloader.php
@@ -0,0 +1,45 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\PharDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class PharDownloader extends ArchiveDownloader
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function extract(PackageInterface $package, string $file, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extract');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/RarDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/RarDownloader.php
new file mode 100644
index 00000000..74dbfa9f
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/RarDownloader.php
@@ -0,0 +1,45 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\RarDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class RarDownloader extends ArchiveDownloader
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function extract(PackageInterface $package, string $file, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extract');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/SvnDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/SvnDownloader.php
new file mode 100644
index 00000000..9e776766
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/SvnDownloader.php
@@ -0,0 +1,110 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\SvnDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use Composer\Package\PackageInterface;
+use React\Promise\PromiseInterface;
+
+class SvnDownloader extends VcsDownloader
+{
+    protected function doDownload(PackageInterface $package, string $path, string $url, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doDownload');
+    }
+
+    protected function doInstall(PackageInterface $package, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doInstall');
+    }
+
+    protected function doUpdate(PackageInterface $initial, PackageInterface $target, string $path, string $url): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doUpdate');
+    }
+
+    public function getLocalChanges(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLocalChanges');
+    }
+
+    protected function execute(PackageInterface $package, string $baseUrl, array $command, string $url, ?string $cwd = null, ?string $path = null): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'execute');
+    }
+
+    protected function cleanChanges(PackageInterface $package, string $path, bool $update): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanChanges');
+    }
+
+    protected function getCommitLogs(string $fromReference, string $toReference, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs');
+    }
+
+    protected function discardChanges(string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'discardChanges');
+    }
+
+    protected function hasMetadataRepository(string $path): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasMetadataRepository');
+    }
+
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?Filesystem $fs = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getInstallationSource(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallationSource');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(PackageInterface $initial, PackageInterface $target, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function remove(PackageInterface $package, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function getVcsReference(PackageInterface $package, string $path): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVcsReference');
+    }
+
+    protected function reapplyChanges(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'reapplyChanges');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/TarDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/TarDownloader.php
new file mode 100644
index 00000000..755f6b24
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/TarDownloader.php
@@ -0,0 +1,45 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\TarDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use Composer\Package\PackageInterface;
+use React\Promise\PromiseInterface;
+
+class TarDownloader extends ArchiveDownloader
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function extract(PackageInterface $package, string $file, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extract');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/XzDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/XzDownloader.php
new file mode 100644
index 00000000..8a76e994
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/XzDownloader.php
@@ -0,0 +1,45 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\XzDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+
+class XzDownloader extends ArchiveDownloader
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function extract(PackageInterface $package, string $file, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extract');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Downloader/ZipDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/ZipDownloader.php
new file mode 100644
index 00000000..6fda26a5
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Downloader/ZipDownloader.php
@@ -0,0 +1,55 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Downloader\ZipDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Downloader;
+
+use Composer\Package\PackageInterface;
+use React\Promise\PromiseInterface;
+
+class ZipDownloader extends ArchiveDownloader
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function download(PackageInterface $package, string $path, ?PackageInterface $prevPackage = null, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    protected function extract(PackageInterface $package, string $file, string $path): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extract');
+    }
+
+    protected function getErrorMessage(int $retval, string $file): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getErrorMessage');
+    }
+
+    public function prepare(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup(string $type, PackageInterface $package, string $path, ?PackageInterface $prevPackage = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(PackageInterface $package, string $path, bool $output = true): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    protected function getInstallOperationAppendix(PackageInterface $package, string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallOperationAppendix');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Factory.php b/crates/shirabe-php-rpc/php/guards/Composer/Factory.php
new file mode 100644
index 00000000..3edad509
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Factory.php
@@ -0,0 +1,134 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Factory.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer;
+
+use Composer\IO\IOInterface;
+use Composer\Package\Version\VersionGuesser;
+use Composer\Package\RootPackageInterface;
+use Composer\Repository\RepositoryManager;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\HttpDownloader;
+use Composer\Util\Loop;
+use Symfony\Component\Console\Output\ConsoleOutput;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Package\Version\VersionParser;
+use Composer\Repository\InstalledRepositoryInterface;
+
+class Factory
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected static function getHomeDir(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHomeDir');
+    }
+
+    protected static function getCacheDir(string $home): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCacheDir');
+    }
+
+    protected static function getDataDir(string $home): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDataDir');
+    }
+
+    public static function createConfig(?IOInterface $io = null, ?string $cwd = null): Config
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createConfig');
+    }
+
+    public static function getComposerFile(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerFile');
+    }
+
+    public static function getLockFile(string $composerFile): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLockFile');
+    }
+
+    public static function createAdditionalStyles(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createAdditionalStyles');
+    }
+
+    public static function createOutput(): ConsoleOutput
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createOutput');
+    }
+
+    public function createComposer(IOInterface $io, $localConfig = null, $disablePlugins = false, ?string $cwd = null, bool $fullLoad = true, bool $disableScripts = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createComposer');
+    }
+
+    public static function createGlobal(IOInterface $io, bool $disablePlugins = false, bool $disableScripts = false): ?Composer
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createGlobal');
+    }
+
+    protected function addLocalRepository(IOInterface $io, RepositoryManager $rm, string $vendorDir, RootPackageInterface $rootPackage, ?ProcessExecutor $process = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addLocalRepository');
+    }
+
+    protected function createGlobalComposer(IOInterface $io, Config $config, $disablePlugins, bool $disableScripts, bool $fullLoad = false): ?PartialComposer
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createGlobalComposer');
+    }
+
+    public function createDownloadManager(IOInterface $io, Config $config, HttpDownloader $httpDownloader, ProcessExecutor $process, ?EventDispatcher $eventDispatcher = null): \Composer\Downloader\DownloadManager
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createDownloadManager');
+    }
+
+    public function createArchiveManager(Config $config, \Composer\Downloader\DownloadManager $dm, Loop $loop)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createArchiveManager');
+    }
+
+    protected function createPluginManager(IOInterface $io, Composer $composer, ?PartialComposer $globalComposer = null, $disablePlugins = false): \Composer\Plugin\PluginManager
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createPluginManager');
+    }
+
+    public function createInstallationManager(Loop $loop, IOInterface $io, ?EventDispatcher $eventDispatcher = null): \Composer\Installer\InstallationManager
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createInstallationManager');
+    }
+
+    protected function createDefaultInstallers(\Composer\Installer\InstallationManager $im, PartialComposer $composer, IOInterface $io, ?ProcessExecutor $process = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createDefaultInstallers');
+    }
+
+    protected function purgePackages(InstalledRepositoryInterface $repo, \Composer\Installer\InstallationManager $im): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'purgePackages');
+    }
+
+    protected function loadRootPackage(RepositoryManager $rm, Config $config, VersionParser $parser, VersionGuesser $guesser, IOInterface $io): \Composer\Package\Loader\RootPackageLoader
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadRootPackage');
+    }
+
+    public static function create(IOInterface $io, $config = null, $disablePlugins = false, bool $disableScripts = false): Composer
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'create');
+    }
+
+    public static function createHttpDownloader(IOInterface $io, Config $config, array $options = []): HttpDownloader
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createHttpDownloader');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Filter/PlatformRequirementFilter/IgnoreListPlatformRequirementFilter.php b/crates/shirabe-php-rpc/php/guards/Composer/Filter/PlatformRequirementFilter/IgnoreListPlatformRequirementFilter.php
new file mode 100644
index 00000000..b4288ecf
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Filter/PlatformRequirementFilter/IgnoreListPlatformRequirementFilter.php
@@ -0,0 +1,34 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Filter\PlatformRequirementFilter\IgnoreListPlatformRequirementFilter.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Filter\PlatformRequirementFilter;
+
+use Composer\Semver\Constraint\ConstraintInterface;
+
+final class IgnoreListPlatformRequirementFilter implements PlatformRequirementFilterInterface
+{
+    public function __construct(array $reqList)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function isIgnored(string $req): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isIgnored');
+    }
+
+    public function isUpperBoundIgnored(string $req): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isUpperBoundIgnored');
+    }
+
+    public function filterConstraint(string $req, ConstraintInterface $constraint, bool $allowUpperBoundOverride = true): ConstraintInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'filterConstraint');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer.php
new file mode 100644
index 00000000..7197f97c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer.php
@@ -0,0 +1,253 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer;
+
+use Composer\Advisory\AuditConfig;
+use Composer\Autoload\AutoloadGenerator;
+use Composer\DependencyResolver\LockTransaction;
+use Composer\DependencyResolver\PolicyInterface;
+use Composer\Downloader\DownloadManager;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterInterface;
+use Composer\Installer\InstallationManager;
+use Composer\Installer\SuggestedPackagesReporter;
+use Composer\IO\IOInterface;
+use Composer\Package\Locker;
+use Composer\Package\RootPackageInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Repository\PlatformRepository;
+use Composer\Repository\RepositoryInterface;
+use Composer\Repository\RepositoryManager;
+use Composer\Repository\LockArrayRepository;
+
+class Installer
+{
+    public const ERROR_NONE = 0; // no error/success state
+    public const ERROR_GENERIC_FAILURE = 1;
+    public const ERROR_NO_LOCK_FILE_FOR_PARTIAL_UPDATE = 3;
+    public const ERROR_LOCK_FILE_INVALID = 4;
+    public const ERROR_DEPENDENCY_RESOLUTION_FAILED = 2;
+    public const ERROR_AUDIT_FAILED = 5;
+    public const ERROR_TRANSPORT_EXCEPTION = 100;
+
+    public function __construct(IOInterface $io, Config $config, RootPackageInterface $package, DownloadManager $downloadManager, RepositoryManager $repositoryManager, Locker $locker, InstallationManager $installationManager, EventDispatcher $eventDispatcher, AutoloadGenerator $autoloadGenerator)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function run(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'run');
+    }
+
+    protected function doUpdate(InstalledRepositoryInterface $localRepo, bool $doInstall): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doUpdate');
+    }
+
+    protected function extractDevPackages(LockTransaction $lockTransaction, PlatformRepository $platformRepo, array $aliases, PolicyInterface $policy, ?LockArrayRepository $lockedRepository = null): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extractDevPackages');
+    }
+
+    protected function doInstall(InstalledRepositoryInterface $localRepo, bool $alreadySolved = false): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doInstall');
+    }
+
+    protected function createPlatformRepo(bool $forUpdate): PlatformRepository
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createPlatformRepo');
+    }
+
+    public static function create(IOInterface $io, Composer $composer): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'create');
+    }
+
+    public function setIgnoredTypes(array $types): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setIgnoredTypes');
+    }
+
+    public function setAllowedTypes(?array $types): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setAllowedTypes');
+    }
+
+    public function setAdditionalFixedRepository(RepositoryInterface $additionalFixedRepository): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setAdditionalFixedRepository');
+    }
+
+    public function setTemporaryConstraints(array $constraints): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setTemporaryConstraints');
+    }
+
+    public function setDryRun(bool $dryRun = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setDryRun');
+    }
+
+    public function isDryRun(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDryRun');
+    }
+
+    public function setDownloadOnly(bool $downloadOnly = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setDownloadOnly');
+    }
+
+    public function setPreferSource(bool $preferSource = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPreferSource');
+    }
+
+    public function setPreferDist(bool $preferDist = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPreferDist');
+    }
+
+    public function setOptimizeAutoloader(bool $optimizeAutoloader): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setOptimizeAutoloader');
+    }
+
+    public function setClassMapAuthoritative(bool $classMapAuthoritative): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setClassMapAuthoritative');
+    }
+
+    public function setApcuAutoloader(bool $apcuAutoloader, ?string $apcuAutoloaderPrefix = null): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setApcuAutoloader');
+    }
+
+    public function setUpdate(bool $update): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUpdate');
+    }
+
+    public function setInstall(bool $install): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setInstall');
+    }
+
+    public function setDevMode(bool $devMode = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setDevMode');
+    }
+
+    public function setDumpAutoloader(bool $dumpAutoloader = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setDumpAutoloader');
+    }
+
+    public function setRunScripts(bool $runScripts = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setRunScripts');
+    }
+
+    public function setConfig(Config $config): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setConfig');
+    }
+
+    public function setVerbose(bool $verbose = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setVerbose');
+    }
+
+    public function isVerbose(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isVerbose');
+    }
+
+    public function setIgnorePlatformRequirements($ignorePlatformReqs): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setIgnorePlatformRequirements');
+    }
+
+    public function setPlatformRequirementFilter(PlatformRequirementFilterInterface $platformRequirementFilter): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPlatformRequirementFilter');
+    }
+
+    public function setUpdateMirrors(bool $updateMirrors): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUpdateMirrors');
+    }
+
+    public function setUpdateAllowList(array $packages): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUpdateAllowList');
+    }
+
+    public function setUpdateAllowTransitiveDependencies(int $updateAllowTransitiveDependencies): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUpdateAllowTransitiveDependencies');
+    }
+
+    public function setPreferStable(bool $preferStable = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPreferStable');
+    }
+
+    public function setPreferLowest(bool $preferLowest = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPreferLowest');
+    }
+
+    public function setMinimalUpdate(bool $minimalUpdate = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setMinimalUpdate');
+    }
+
+    public function setWriteLock(bool $writeLock = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setWriteLock');
+    }
+
+    public function setExecuteOperations(bool $executeOperations = true): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setExecuteOperations');
+    }
+
+    public function setAudit(bool $audit): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setAudit');
+    }
+
+    public function setErrorOnAudit(bool $errorOnAudit): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setErrorOnAudit');
+    }
+
+    public function setAuditFormat(string $auditFormat): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setAuditFormat');
+    }
+
+    public function setAuditConfig(AuditConfig $auditConfig): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setAuditConfig');
+    }
+
+    public function disablePlugins(): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'disablePlugins');
+    }
+
+    public function setSuggestedPackagesReporter(SuggestedPackagesReporter $suggestedPackagesReporter): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setSuggestedPackagesReporter');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer/BinaryInstaller.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer/BinaryInstaller.php
new file mode 100644
index 00000000..084ba3ff
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer/BinaryInstaller.php
@@ -0,0 +1,66 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer\BinaryInstaller.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Installer;
+
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\Util\Filesystem;
+
+class BinaryInstaller
+{
+    public function __construct(IOInterface $io, string $binDir, string $binCompat, ?Filesystem $filesystem = null, ?string $vendorDir = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function installBinaries(PackageInterface $package, string $installPath, bool $warnOnOverwrite = true): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'installBinaries');
+    }
+
+    public function removeBinaries(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeBinaries');
+    }
+
+    public static function determineBinaryCaller(string $bin): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'determineBinaryCaller');
+    }
+
+    protected function getBinaries(PackageInterface $package): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBinaries');
+    }
+
+    protected function installFullBinaries(string $binPath, string $link, string $bin, PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'installFullBinaries');
+    }
+
+    protected function installUnixyProxyBinaries(string $binPath, string $link): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'installUnixyProxyBinaries');
+    }
+
+    protected function initializeBinDir(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initializeBinDir');
+    }
+
+    protected function generateWindowsProxyCode(string $bin, string $link): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateWindowsProxyCode');
+    }
+
+    protected function generateUnixyProxyCode(string $bin, string $link): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateUnixyProxyCode');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer/InstallerEvent.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer/InstallerEvent.php
new file mode 100644
index 00000000..f35bbccc
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer/InstallerEvent.php
@@ -0,0 +1,47 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer\InstallerEvent.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Installer;
+
+use Composer\Composer;
+use Composer\DependencyResolver\Transaction;
+use Composer\EventDispatcher\Event;
+use Composer\IO\IOInterface;
+
+class InstallerEvent extends Event
+{
+    public function __construct(string $eventName, Composer $composer, IOInterface $io, bool $devMode, bool $executeOperations, Transaction $transaction)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getComposer(): Composer
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposer');
+    }
+
+    public function getIO(): IOInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getIO');
+    }
+
+    public function isDevMode(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDevMode');
+    }
+
+    public function isExecutingOperations(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isExecutingOperations');
+    }
+
+    public function getTransaction(): ?Transaction
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTransaction');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer/LibraryInstaller.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer/LibraryInstaller.php
new file mode 100644
index 00000000..81d4a1fe
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer/LibraryInstaller.php
@@ -0,0 +1,104 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer\LibraryInstaller.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Installer;
+
+use Composer\IO\IOInterface;
+use Composer\PartialComposer;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Package\PackageInterface;
+use Composer\Util\Filesystem;
+use Composer\Downloader\DownloadManager;
+
+class LibraryInstaller implements InstallerInterface, BinaryPresenceInterface
+{
+    public function __construct(IOInterface $io, PartialComposer $composer, ?string $type = 'library', ?Filesystem $filesystem = null, ?BinaryInstaller $binaryInstaller = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function supports(string $packageType)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isInstalled');
+    }
+
+    public function download(PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare($type, PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup($type, PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'uninstall');
+    }
+
+    public function getInstallPath(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallPath');
+    }
+
+    public function ensureBinariesPresence(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'ensureBinariesPresence');
+    }
+
+    protected function getPackageBasePath(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackageBasePath');
+    }
+
+    protected function installCode(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'installCode');
+    }
+
+    protected function updateCode(PackageInterface $initial, PackageInterface $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'updateCode');
+    }
+
+    protected function removeCode(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeCode');
+    }
+
+    protected function initializeVendorDir()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initializeVendorDir');
+    }
+
+    protected function getDownloadManager(): DownloadManager
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDownloadManager');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer/MetapackageInstaller.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer/MetapackageInstaller.php
new file mode 100644
index 00000000..fbaeaeb3
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer/MetapackageInstaller.php
@@ -0,0 +1,66 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer\MetapackageInstaller.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Installer;
+
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Package\PackageInterface;
+use Composer\IO\IOInterface;
+
+class MetapackageInstaller implements InstallerInterface
+{
+    public function __construct(IOInterface $io)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function supports(string $packageType)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isInstalled');
+    }
+
+    public function download(PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare($type, PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup($type, PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'uninstall');
+    }
+
+    public function getInstallPath(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallPath');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer/PluginInstaller.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer/PluginInstaller.php
new file mode 100644
index 00000000..dc09803b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer/PluginInstaller.php
@@ -0,0 +1,64 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer\PluginInstaller.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Installer;
+
+use Composer\IO\IOInterface;
+use Composer\PartialComposer;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Package\PackageInterface;
+use Composer\Plugin\PluginManager;
+use Composer\Util\Filesystem;
+
+class PluginInstaller extends LibraryInstaller
+{
+    public function __construct(IOInterface $io, PartialComposer $composer, ?Filesystem $fs = null, ?BinaryInstaller $binaryInstaller = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function supports(string $packageType)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function disablePlugins(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'disablePlugins');
+    }
+
+    public function prepare($type, PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function download(PackageInterface $package, ?PackageInterface $prevPackage = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'uninstall');
+    }
+
+    protected function getPluginManager(): PluginManager
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPluginManager');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Installer/ProjectInstaller.php b/crates/shirabe-php-rpc/php/guards/Composer/Installer/ProjectInstaller.php
new file mode 100644
index 00000000..50c7792e
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Installer/ProjectInstaller.php
@@ -0,0 +1,68 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Installer\ProjectInstaller.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Installer;
+
+use React\Promise\PromiseInterface;
+use Composer\Package\PackageInterface;
+use Composer\Downloader\DownloadManager;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Util\Filesystem;
+
+class ProjectInstaller implements InstallerInterface
+{
+    public function __construct(string $installPath, DownloadManager $dm, Filesystem $fs)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function supports(string $packageType): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isInstalled');
+    }
+
+    public function download(PackageInterface $package, ?PackageInterface $prevPackage = null): ?PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function prepare($type, PackageInterface $package, ?PackageInterface $prevPackage = null): ?PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'prepare');
+    }
+
+    public function cleanup($type, PackageInterface $package, ?PackageInterface $prevPackage = null): ?PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package): ?PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'install');
+    }
+
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target): ?PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'update');
+    }
+
+    public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package): ?PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'uninstall');
+    }
+
+    public function getInstallPath(PackageInterface $package): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInstallPath');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Json/JsonFile.php b/crates/shirabe-php-rpc/php/guards/Composer/Json/JsonFile.php
new file mode 100644
index 00000000..f61af348
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Json/JsonFile.php
@@ -0,0 +1,81 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Json\JsonFile.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Json;
+
+use Composer\Util\HttpDownloader;
+use Composer\IO\IOInterface;
+
+class JsonFile
+{
+    public const LAX_SCHEMA = 1;
+    public const STRICT_SCHEMA = 2;
+    public const AUTH_SCHEMA = 3;
+    public const LOCK_SCHEMA = 4;
+    public const JSON_UNESCAPED_SLASHES = 64;
+    public const JSON_PRETTY_PRINT = 128;
+    public const JSON_UNESCAPED_UNICODE = 256;
+    public const COMPOSER_SCHEMA_PATH = __DIR__ . '/../../../res/composer-schema.json';
+    public const LOCK_SCHEMA_PATH = __DIR__ . '/../../../res/composer-lock-schema.json';
+    public const INDENT_DEFAULT = '    ';
+
+    public function __construct(string $path, ?HttpDownloader $httpDownloader = null, ?IOInterface $io = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getPath(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPath');
+    }
+
+    public function exists(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'exists');
+    }
+
+    public function read()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'read');
+    }
+
+    public function write(array $hash, int $options = JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'write');
+    }
+
+    public function validateSchema(int $schema = self::STRICT_SCHEMA, ?string $schemaFile = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'validateSchema');
+    }
+
+    public static function validateJsonSchema(string $source, $data, int $schema, ?string $schemaFile = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'validateJsonSchema');
+    }
+
+    public static function encode($data, int $options = \JSON_UNESCAPED_SLASHES | \JSON_PRETTY_PRINT | \JSON_UNESCAPED_UNICODE, string $indent = self::INDENT_DEFAULT): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'encode');
+    }
+
+    public static function parseJson(?string $json, ?string $file = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'parseJson');
+    }
+
+    protected static function validateSyntax(string $json, ?string $file = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'validateSyntax');
+    }
+
+    public static function detectIndenting(?string $json): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'detectIndenting');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchivableFilesFinder.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchivableFilesFinder.php
new file mode 100644
index 00000000..be2ed91c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchivableFilesFinder.php
@@ -0,0 +1,24 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Archiver\ArchivableFilesFinder.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Archiver;
+
+use FilterIterator;
+
+class ArchivableFilesFinder extends FilterIterator
+{
+    public function __construct(string $sources, array $excludes, bool $ignoreFilters = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function accept(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'accept');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchiveManager.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchiveManager.php
new file mode 100644
index 00000000..97e9071b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ArchiveManager.php
@@ -0,0 +1,51 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Archiver\ArchiveManager.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Archiver;
+
+use Composer\Downloader\DownloadManager;
+use Composer\Util\Loop;
+use Composer\Package\CompletePackageInterface;
+
+class ArchiveManager
+{
+    public function __construct(DownloadManager $downloadManager, Loop $loop)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function addArchiver(ArchiverInterface $archiver): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addArchiver');
+    }
+
+    public function setOverwriteFiles(bool $overwriteFiles): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setOverwriteFiles');
+    }
+
+    public function getPackageFilenameParts(CompletePackageInterface $package): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackageFilenameParts');
+    }
+
+    public function getPackageFilenameFromParts(array $parts): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackageFilenameFromParts');
+    }
+
+    public function getPackageFilename(CompletePackageInterface $package): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackageFilename');
+    }
+
+    public function archive(CompletePackageInterface $package, string $format, string $targetDir, ?string $fileName = null, bool $ignoreFilters = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'archive');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/PharArchiver.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/PharArchiver.php
new file mode 100644
index 00000000..71303caf
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/PharArchiver.php
@@ -0,0 +1,27 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Archiver\PharArchiver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Archiver;
+
+class PharArchiver implements ArchiverInterface
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function archive(string $sources, string $target, string $format, array $excludes = [], bool $ignoreFilters = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'archive');
+    }
+
+    public function supports(string $format, ?string $sourceType): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ZipArchiver.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ZipArchiver.php
new file mode 100644
index 00000000..130ce74c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Archiver/ZipArchiver.php
@@ -0,0 +1,27 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Archiver\ZipArchiver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Archiver;
+
+class ZipArchiver implements ArchiverInterface
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function archive(string $sources, string $target, string $format, array $excludes = [], bool $ignoreFilters = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'archive');
+    }
+
+    public function supports(string $format, ?string $sourceType): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ArrayLoader.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ArrayLoader.php
new file mode 100644
index 00000000..4e37ad7f
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ArrayLoader.php
@@ -0,0 +1,40 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Loader\ArrayLoader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Loader;
+
+use Composer\Package\BasePackage;
+use Composer\Package\Version\VersionParser;
+
+class ArrayLoader implements LoaderInterface
+{
+    public function __construct(?VersionParser $parser = null, bool $loadOptions = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function load(array $config, string $class = 'Composer\Package\CompletePackage'): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'load');
+    }
+
+    public function loadPackages(array $versions): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadPackages');
+    }
+
+    public function parseLinks(string $source, string $sourceVersion, string $description, array $links): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'parseLinks');
+    }
+
+    public function getBranchAlias(array $config): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranchAlias');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/RootPackageLoader.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/RootPackageLoader.php
new file mode 100644
index 00000000..3d2d3390
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/RootPackageLoader.php
@@ -0,0 +1,39 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Loader\RootPackageLoader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Loader;
+
+use Composer\Package\BasePackage;
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Package\Version\VersionGuesser;
+use Composer\Package\Version\VersionParser;
+use Composer\Repository\RepositoryManager;
+
+class RootPackageLoader extends ArrayLoader
+{
+    public function __construct(RepositoryManager $manager, Config $config, ?VersionParser $parser = null, ?VersionGuesser $versionGuesser = null, ?IOInterface $io = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function load(array $config, string $class = 'Composer\Package\RootPackage', ?string $cwd = null): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'load');
+    }
+
+    public static function extractStabilityFlags(array $requires, string $minimumStability, array $stabilityFlags): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extractStabilityFlags');
+    }
+
+    public static function extractReferences(array $requires, array $references): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'extractReferences');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ValidatingArrayLoader.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ValidatingArrayLoader.php
new file mode 100644
index 00000000..c6f7af70
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Loader/ValidatingArrayLoader.php
@@ -0,0 +1,44 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Loader\ValidatingArrayLoader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Loader;
+
+use Composer\Package\BasePackage;
+use Composer\Package\Version\VersionParser;
+
+class ValidatingArrayLoader implements LoaderInterface
+{
+    public const CHECK_ALL = 3;
+    public const CHECK_UNBOUND_CONSTRAINTS = 1;
+    public const CHECK_STRICT_CONSTRAINTS = 2;
+
+    public function __construct(LoaderInterface $loader, bool $strictName = true, ?VersionParser $parser = null, int $flags = 0)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function load(array $config, string $class = 'Composer\Package\CompletePackage'): BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'load');
+    }
+
+    public function getWarnings(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getWarnings');
+    }
+
+    public function getErrors(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getErrors');
+    }
+
+    public static function hasPackageNamingError(string $name, bool $isLink = false): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasPackageNamingError');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Locker.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Locker.php
new file mode 100644
index 00000000..4009f162
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Locker.php
@@ -0,0 +1,113 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Locker.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package;
+
+use Composer\Json\JsonFile;
+use Composer\Installer\InstallationManager;
+use Composer\Repository\LockArrayRepository;
+use Composer\Util\ProcessExecutor;
+use Composer\IO\IOInterface;
+
+class Locker
+{
+    public function __construct(IOInterface $io, JsonFile $lockFile, InstallationManager $installationManager, string $composerFileContents, ?ProcessExecutor $process = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getJsonFile(): JsonFile
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getJsonFile');
+    }
+
+    public static function getContentHash(string $composerFileContents): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContentHash');
+    }
+
+    public function isLocked(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isLocked');
+    }
+
+    public function isFresh(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isFresh');
+    }
+
+    public function getLockedRepository(bool $withDevReqs = false): LockArrayRepository
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLockedRepository');
+    }
+
+    public function getDevPackageNames(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDevPackageNames');
+    }
+
+    public function getPlatformRequirements(bool $withDevReqs = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPlatformRequirements');
+    }
+
+    public function getMinimumStability(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getMinimumStability');
+    }
+
+    public function getStabilityFlags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStabilityFlags');
+    }
+
+    public function getPreferStable(): ?bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPreferStable');
+    }
+
+    public function getPreferLowest(): ?bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPreferLowest');
+    }
+
+    public function getPlatformOverrides(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPlatformOverrides');
+    }
+
+    public function getAliases(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAliases');
+    }
+
+    public function getPluginApi()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPluginApi');
+    }
+
+    public function getLockData(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLockData');
+    }
+
+    public function setLockData(array $packages, ?array $devPackages, array $platformReqs, array $platformDevReqs, array $aliases, string $minimumStability, array $stabilityFlags, bool $preferStable, bool $preferLowest, array $platformOverrides, bool $write = true): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setLockData');
+    }
+
+    public function updateHash(JsonFile $composerJson, ?callable $dataProcessor = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'updateHash');
+    }
+
+    public function getMissingRequirementInfo(RootPackageInterface $package, bool $includeDev): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getMissingRequirementInfo');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionBumper.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionBumper.php
new file mode 100644
index 00000000..c9a4ae00
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionBumper.php
@@ -0,0 +1,25 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Version\VersionBumper.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Version;
+
+use Composer\Package\PackageInterface;
+use Composer\Semver\Constraint\ConstraintInterface;
+
+class VersionBumper
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function bumpRequirement(ConstraintInterface $constraint, PackageInterface $package): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'bumpRequirement');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionSelector.php b/crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionSelector.php
new file mode 100644
index 00000000..2264073f
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Package/Version/VersionSelector.php
@@ -0,0 +1,32 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Package\Version\VersionSelector.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Package\Version;
+
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\Repository\RepositorySet;
+use Composer\Repository\PlatformRepository;
+
+class VersionSelector
+{
+    public function __construct(RepositorySet $repositorySet, ?PlatformRepository $platformRepo = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function findBestCandidate(string $packageName, ?string $targetPackageVersion = null, string $preferredStability = 'stable', $platformRequirementFilter = null, int $repoSetFlags = 0, ?IOInterface $io = null, $showWarnings = true)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findBestCandidate');
+    }
+
+    public function findRecommendedRequireVersion(PackageInterface $package): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findRecommendedRequireVersion');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Plugin/CommandEvent.php b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/CommandEvent.php
new file mode 100644
index 00000000..df84c294
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/CommandEvent.php
@@ -0,0 +1,36 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Plugin\CommandEvent.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Plugin;
+
+use Composer\EventDispatcher\Event;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class CommandEvent extends Event
+{
+    public function __construct(string $name, string $commandName, InputInterface $input, OutputInterface $output, array $args = [], array $flags = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getInput(): InputInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getInput');
+    }
+
+    public function getOutput(): OutputInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getOutput');
+    }
+
+    public function getCommandName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommandName');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PluginManager.php b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PluginManager.php
new file mode 100644
index 00000000..857c740e
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PluginManager.php
@@ -0,0 +1,118 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Plugin\PluginManager.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Plugin;
+
+use Composer\Composer;
+use Composer\IO\IOInterface;
+use Composer\PartialComposer;
+use Composer\Package\PackageInterface;
+use Composer\Plugin\Capability\Capability;
+
+class PluginManager
+{
+    public function __construct(IOInterface $io, Composer $composer, ?PartialComposer $globalComposer = null, $disablePlugins = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function setRunningInGlobalDir(bool $runningInGlobalDir): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setRunningInGlobalDir');
+    }
+
+    public function loadInstalledPlugins(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadInstalledPlugins');
+    }
+
+    public function deactivateInstalledPlugins(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'deactivateInstalledPlugins');
+    }
+
+    public function getPlugins(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPlugins');
+    }
+
+    public function getRegisteredPlugins(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRegisteredPlugins');
+    }
+
+    public function getGlobalComposer(): ?PartialComposer
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getGlobalComposer');
+    }
+
+    public function registerPackage(PackageInterface $package, bool $failOnMissingClasses = false, bool $isGlobalPlugin = false): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'registerPackage');
+    }
+
+    public function deactivatePackage(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'deactivatePackage');
+    }
+
+    public function uninstallPackage(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'uninstallPackage');
+    }
+
+    protected function getPluginApiVersion(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPluginApiVersion');
+    }
+
+    public function addPlugin(PluginInterface $plugin, bool $isGlobalPlugin = false, ?PackageInterface $sourcePackage = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addPlugin');
+    }
+
+    public function removePlugin(PluginInterface $plugin): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removePlugin');
+    }
+
+    public function uninstallPlugin(PluginInterface $plugin): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'uninstallPlugin');
+    }
+
+    protected function getCapabilityImplementationClassName(PluginInterface $plugin, string $capability): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCapabilityImplementationClassName');
+    }
+
+    public function getPluginCapability(PluginInterface $plugin, $capabilityClassName, array $ctorArgs = []): ?Capability
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPluginCapability');
+    }
+
+    public function getPluginCapabilities($capabilityClassName, array $ctorArgs = []): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPluginCapabilities');
+    }
+
+    public function arePluginsDisabled($type)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'arePluginsDisabled');
+    }
+
+    public function disablePlugins(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'disablePlugins');
+    }
+
+    public function isPluginAllowed(string $package, bool $isGlobalPlugin, bool $optional = false, bool $prompt = true): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isPluginAllowed');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PostFileDownloadEvent.php b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PostFileDownloadEvent.php
new file mode 100644
index 00000000..c387767b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PostFileDownloadEvent.php
@@ -0,0 +1,50 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Plugin\PostFileDownloadEvent.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Plugin;
+
+use Composer\EventDispatcher\Event;
+use Composer\Package\PackageInterface;
+
+class PostFileDownloadEvent extends Event
+{
+    public function __construct(string $name, ?string $fileName, ?string $checksum, string $url, string $type, $context = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getFileName(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileName');
+    }
+
+    public function getChecksum(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChecksum');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function getContext()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContext');
+    }
+
+    public function getPackage(): ?PackageInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackage');
+    }
+
+    public function getType(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getType');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PreFileDownloadEvent.php b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PreFileDownloadEvent.php
new file mode 100644
index 00000000..f1c53d99
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PreFileDownloadEvent.php
@@ -0,0 +1,65 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Plugin\PreFileDownloadEvent.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Plugin;
+
+use Composer\EventDispatcher\Event;
+use Composer\Util\HttpDownloader;
+
+class PreFileDownloadEvent extends Event
+{
+    public function __construct(string $name, HttpDownloader $httpDownloader, string $processedUrl, string $type, $context = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getHttpDownloader(): HttpDownloader
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHttpDownloader');
+    }
+
+    public function getProcessedUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProcessedUrl');
+    }
+
+    public function setProcessedUrl(string $processedUrl): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setProcessedUrl');
+    }
+
+    public function getCustomCacheKey(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCustomCacheKey');
+    }
+
+    public function setCustomCacheKey(?string $customCacheKey): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setCustomCacheKey');
+    }
+
+    public function getType(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getType');
+    }
+
+    public function getContext()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContext');
+    }
+
+    public function getTransportOptions(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTransportOptions');
+    }
+
+    public function setTransportOptions(array $options): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setTransportOptions');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PrePoolCreateEvent.php b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PrePoolCreateEvent.php
new file mode 100644
index 00000000..537a777d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Plugin/PrePoolCreateEvent.php
@@ -0,0 +1,70 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Plugin\PrePoolCreateEvent.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Plugin;
+
+use Composer\EventDispatcher\Event;
+use Composer\DependencyResolver\Request;
+
+class PrePoolCreateEvent extends Event
+{
+    public function __construct(string $name, array $repositories, Request $request, array $acceptableStabilities, array $stabilityFlags, array $rootAliases, array $rootReferences, array $packages, array $unacceptableFixedPackages)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepositories(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepositories');
+    }
+
+    public function getRequest(): Request
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRequest');
+    }
+
+    public function getAcceptableStabilities(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAcceptableStabilities');
+    }
+
+    public function getStabilityFlags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStabilityFlags');
+    }
+
+    public function getRootAliases(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootAliases');
+    }
+
+    public function getRootReferences(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootReferences');
+    }
+
+    public function getPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackages');
+    }
+
+    public function getUnacceptableFixedPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUnacceptableFixedPackages');
+    }
+
+    public function setPackages(array $packages): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setPackages');
+    }
+
+    public function setUnacceptableFixedPackages(array $packages): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUnacceptableFixedPackages');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/ArtifactRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/ArtifactRepository.php
new file mode 100644
index 00000000..893facda
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/ArtifactRepository.php
@@ -0,0 +1,34 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\ArtifactRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\IO\IOInterface;
+
+class ArtifactRepository extends ArrayRepository implements ConfigurableRepositoryInterface
+{
+    public function __construct(array $repoConfig, IOInterface $io)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getRepoConfig()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoConfig');
+    }
+
+    protected function initialize()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/ComposerRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/ComposerRepository.php
new file mode 100644
index 00000000..e36e1c4b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/ComposerRepository.php
@@ -0,0 +1,108 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\ComposerRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Package\PackageInterface;
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Util\HttpDownloader;
+use Composer\EventDispatcher\EventDispatcher;
+
+class ComposerRepository extends ArrayRepository implements ConfigurableRepositoryInterface, AdvisoryProviderInterface
+{
+    public function __construct(array $repoConfig, IOInterface $io, Config $config, HttpDownloader $httpDownloader, ?EventDispatcher $eventDispatcher = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getRepoConfig()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoConfig');
+    }
+
+    public function findPackage(string $name, $constraint)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackage');
+    }
+
+    public function findPackages(string $name, $constraint = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackages');
+    }
+
+    public function getPackages()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackages');
+    }
+
+    public function getPackageNames(?string $packageFilter = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackageNames');
+    }
+
+    public function loadPackages(array $packageNameMap, array $acceptableStabilities, array $stabilityFlags, array $alreadyLoaded = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadPackages');
+    }
+
+    public function search(string $query, int $mode = 0, ?string $type = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'search');
+    }
+
+    public function hasSecurityAdvisories(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasSecurityAdvisories');
+    }
+
+    public function getSecurityAdvisories(array $packageConstraintMap, bool $allowPartialAdvisories = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSecurityAdvisories');
+    }
+
+    public function getProviders(string $packageName)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProviders');
+    }
+
+    protected function configurePackageTransportOptions(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'configurePackageTransportOptions');
+    }
+
+    protected function initialize()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function addPackage(PackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addPackage');
+    }
+
+    protected function loadRootServerFile(?int $rootMaxAge = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadRootServerFile');
+    }
+
+    protected function fetchFile(string $filename, ?string $cacheKey = null, ?string $sha256 = null, bool $storeLastModifiedTime = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fetchFile');
+    }
+
+    protected function lazyProvidersRepoContains(string $name)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'lazyProvidersRepoContains');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/CompositeRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/CompositeRepository.php
new file mode 100644
index 00000000..691a797b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/CompositeRepository.php
@@ -0,0 +1,80 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\CompositeRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Package\BasePackage;
+use Composer\Package\PackageInterface;
+
+class CompositeRepository implements RepositoryInterface
+{
+    public function __construct(array $repositories)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getRepositories(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepositories');
+    }
+
+    public function hasPackage(PackageInterface $package): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasPackage');
+    }
+
+    public function findPackage($name, $constraint): ?BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackage');
+    }
+
+    public function findPackages($name, $constraint = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackages');
+    }
+
+    public function loadPackages(array $packageNameMap, array $acceptableStabilities, array $stabilityFlags, array $alreadyLoaded = []): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadPackages');
+    }
+
+    public function search(string $query, int $mode = 0, ?string $type = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'search');
+    }
+
+    public function getPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackages');
+    }
+
+    public function getProviders($packageName): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProviders');
+    }
+
+    public function removePackage(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removePackage');
+    }
+
+    public function count(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'count');
+    }
+
+    public function addRepository(RepositoryInterface $repository): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRepository');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/FilterRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/FilterRepository.php
new file mode 100644
index 00000000..866585a1
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/FilterRepository.php
@@ -0,0 +1,80 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\FilterRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Package\PackageInterface;
+use Composer\Package\BasePackage;
+
+class FilterRepository implements RepositoryInterface, AdvisoryProviderInterface
+{
+    public function __construct(RepositoryInterface $repo, array $options)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getRepository(): RepositoryInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepository');
+    }
+
+    public function hasPackage(PackageInterface $package): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasPackage');
+    }
+
+    public function findPackage($name, $constraint): ?BasePackage
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackage');
+    }
+
+    public function findPackages($name, $constraint = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackages');
+    }
+
+    public function loadPackages(array $packageNameMap, array $acceptableStabilities, array $stabilityFlags, array $alreadyLoaded = []): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'loadPackages');
+    }
+
+    public function search(string $query, int $mode = 0, ?string $type = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'search');
+    }
+
+    public function getPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPackages');
+    }
+
+    public function getProviders($packageName): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProviders');
+    }
+
+    public function count(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'count');
+    }
+
+    public function hasSecurityAdvisories(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasSecurityAdvisories');
+    }
+
+    public function getSecurityAdvisories(array $packageConstraintMap, bool $allowPartialAdvisories = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSecurityAdvisories');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/InstalledRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/InstalledRepository.php
new file mode 100644
index 00000000..6add0007
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/InstalledRepository.php
@@ -0,0 +1,39 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\InstalledRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Semver\Constraint\ConstraintInterface;
+
+class InstalledRepository extends CompositeRepository
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function findPackagesWithReplacersAndProviders(string $name, $constraint = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackagesWithReplacersAndProviders');
+    }
+
+    public function getDependents($needle, ?ConstraintInterface $constraint = null, bool $invert = false, bool $recurse = true, ?array $packagesFound = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDependents');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function addRepository(RepositoryInterface $repository): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRepository');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/LockArrayRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/LockArrayRepository.php
new file mode 100644
index 00000000..afa486cf
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/LockArrayRepository.php
@@ -0,0 +1,27 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\LockArrayRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+class LockArrayRepository extends ArrayRepository
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getCanonicalPackages()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCanonicalPackages');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/PackageRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PackageRepository.php
new file mode 100644
index 00000000..6ea6629b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PackageRepository.php
@@ -0,0 +1,37 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\PackageRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+class PackageRepository extends ArrayRepository implements AdvisoryProviderInterface
+{
+    public function __construct(array $config)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    protected function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function hasSecurityAdvisories(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasSecurityAdvisories');
+    }
+
+    public function getSecurityAdvisories(array $packageConstraintMap, bool $allowPartialAdvisories = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSecurityAdvisories');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/PathRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PathRepository.php
new file mode 100644
index 00000000..2c664d1b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PathRepository.php
@@ -0,0 +1,38 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\PathRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\IO\IOInterface;
+use Composer\Util\HttpDownloader;
+use Composer\Util\ProcessExecutor;
+
+class PathRepository extends ArrayRepository implements ConfigurableRepositoryInterface
+{
+    public function __construct(array $repoConfig, IOInterface $io, Config $config, ?HttpDownloader $httpDownloader = null, ?EventDispatcher $dispatcher = null, ?ProcessExecutor $process = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getRepoConfig(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoConfig');
+    }
+
+    protected function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/PearRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PearRepository.php
new file mode 100644
index 00000000..abba7813
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PearRepository.php
@@ -0,0 +1,17 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\PearRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+class PearRepository extends ArrayRepository
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/PlatformRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PlatformRepository.php
new file mode 100644
index 00000000..665ead73
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/PlatformRepository.php
@@ -0,0 +1,63 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\PlatformRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Package\PackageInterface;
+use Composer\Platform\HhvmDetector;
+use Composer\Platform\Runtime;
+
+class PlatformRepository extends ArrayRepository
+{
+    public const PLATFORM_PACKAGE_REGEX = '{^(?:php(?:-64bit|-ipv6|-zts|-debug)?|hhvm|(?:ext|lib)-[a-z0-9](?:[_.-]?[a-z0-9]+)*|composer(?:-(?:plugin|runtime)-api)?)$}iD';
+
+    public function __construct(array $packages = [], array $overrides = [], ?Runtime $runtime = null, ?HhvmDetector $hhvmDetector = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function isPlatformPackageDisabled(string $name): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isPlatformPackageDisabled');
+    }
+
+    public function getDisabledPackages(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDisabledPackages');
+    }
+
+    protected function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function addPackage(PackageInterface $package): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addPackage');
+    }
+
+    public static function isPlatformPackage(string $name): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isPlatformPackage');
+    }
+
+    public static function getPlatformPhpVersion(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPlatformPhpVersion');
+    }
+
+    public function search(string $query, int $mode = 0, ?string $type = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'search');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositoryFactory.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositoryFactory.php
new file mode 100644
index 00000000..e2f3a1b7
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositoryFactory.php
@@ -0,0 +1,58 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\RepositoryFactory.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\IO\IOInterface;
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Util\HttpDownloader;
+use Composer\Util\ProcessExecutor;
+
+class RepositoryFactory
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public static function configFromString(IOInterface $io, Config $config, string $repository, bool $allowFilesystem = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'configFromString');
+    }
+
+    public static function fromString(IOInterface $io, Config $config, string $repository, bool $allowFilesystem = false, ?RepositoryManager $rm = null): RepositoryInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fromString');
+    }
+
+    public static function createRepo(IOInterface $io, Config $config, array $repoConfig, ?RepositoryManager $rm = null): RepositoryInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createRepo');
+    }
+
+    public static function defaultRepos(?IOInterface $io = null, ?Config $config = null, ?RepositoryManager $rm = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'defaultRepos');
+    }
+
+    public static function manager(IOInterface $io, Config $config, ?HttpDownloader $httpDownloader = null, ?EventDispatcher $eventDispatcher = null, ?ProcessExecutor $process = null): RepositoryManager
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'manager');
+    }
+
+    public static function defaultReposWithDefaultManager(IOInterface $io): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'defaultReposWithDefaultManager');
+    }
+
+    public static function generateRepositoryName($index, array $repo, array $existingRepos): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateRepositoryName');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositorySet.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositorySet.php
new file mode 100644
index 00000000..0c846767
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/RepositorySet.php
@@ -0,0 +1,93 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\RepositorySet.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\DependencyResolver\PoolOptimizer;
+use Composer\DependencyResolver\Pool;
+use Composer\DependencyResolver\Request;
+use Composer\DependencyResolver\SecurityAdvisoryPoolFilter;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\IO\IOInterface;
+use Composer\Semver\Constraint\ConstraintInterface;
+
+class RepositorySet
+{
+    public const ALLOW_UNACCEPTABLE_STABILITIES = 1;
+    public const ALLOW_SHADOWED_REPOSITORIES = 2;
+
+    public function __construct(string $minimumStability = 'stable', array $stabilityFlags = [], array $rootAliases = [], array $rootReferences = [], array $rootRequires = [], array $temporaryConstraints = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function allowInstalledRepositories(bool $allow = true): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'allowInstalledRepositories');
+    }
+
+    public function getRootRequires(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootRequires');
+    }
+
+    public function getTemporaryConstraints(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTemporaryConstraints');
+    }
+
+    public function addRepository(RepositoryInterface $repo): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addRepository');
+    }
+
+    public function findPackages(string $name, ?ConstraintInterface $constraint = null, int $flags = 0): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findPackages');
+    }
+
+    public function getSecurityAdvisories(array $packageNames, bool $allowPartialAdvisories, bool $ignoreUnreachable = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSecurityAdvisories');
+    }
+
+    public function getMatchingSecurityAdvisories(array $packages, bool $allowPartialAdvisories = false, bool $ignoreUnreachable = false): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getMatchingSecurityAdvisories');
+    }
+
+    public function getProviders(string $packageName): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProviders');
+    }
+
+    public function isPackageAcceptable(array $names, string $stability): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isPackageAcceptable');
+    }
+
+    public function createPool(Request $request, IOInterface $io, ?EventDispatcher $eventDispatcher = null, ?PoolOptimizer $poolOptimizer = null, array $ignoredTypes = [], ?array $allowedTypes = null, ?SecurityAdvisoryPoolFilter $securityAdvisoryPoolFilter = null): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createPool');
+    }
+
+    public function createPoolWithAllPackages(): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createPoolWithAllPackages');
+    }
+
+    public function createPoolForPackage(string $packageName, ?LockArrayRepository $lockedRepo = null): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createPoolForPackage');
+    }
+
+    public function createPoolForPackages(array $packageNames, ?LockArrayRepository $lockedRepo = null): Pool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'createPoolForPackages');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/RootPackageRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/RootPackageRepository.php
new file mode 100644
index 00000000..ea7abae1
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/RootPackageRepository.php
@@ -0,0 +1,24 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\RootPackageRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Package\RootPackageInterface;
+
+class RootPackageRepository extends ArrayRepository
+{
+    public function __construct(RootPackageInterface $package)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/ForgejoDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/ForgejoDriver.php
new file mode 100644
index 00000000..0e812dfe
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/ForgejoDriver.php
@@ -0,0 +1,122 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\ForgejoDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Util\Http\Response;
+
+class ForgejoDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    protected function setupGitDriver(string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setupGitDriver');
+    }
+
+    protected function getNextPage(Response $response): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getNextPage');
+    }
+
+    protected function getContents(string $url, bool $fetchingRepoData = false): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    protected function attemptCloneFallback(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'attemptCloneFallback');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/FossilDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/FossilDriver.php
new file mode 100644
index 00000000..0bf55416
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/FossilDriver.php
@@ -0,0 +1,116 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\FossilDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class FossilDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    protected function checkFossil(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'checkFossil');
+    }
+
+    protected function updateLocalRepo(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'updateLocalRepo');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    protected function getContents(string $url): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitBitbucketDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitBitbucketDriver.php
new file mode 100644
index 00000000..1249b6a9
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitBitbucketDriver.php
@@ -0,0 +1,137 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\GitBitbucketDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Util\Http\Response;
+
+class GitBitbucketDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    protected function getRepoData(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoData');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    protected function fetchWithOAuthCredentials(string $url, bool $fetchingRepoData = false): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fetchWithOAuthCredentials');
+    }
+
+    protected function generateSshUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateSshUrl');
+    }
+
+    protected function attemptCloneFallback(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'attemptCloneFallback');
+    }
+
+    protected function setupFallbackDriver(string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setupFallbackDriver');
+    }
+
+    protected function parseCloneUrls(array $cloneLinks): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'parseCloneUrls');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    protected function getContents(string $url): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitDriver.php
new file mode 100644
index 00000000..ae4ed49b
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitDriver.php
@@ -0,0 +1,106 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\GitDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\IO\IOInterface;
+use Composer\Config;
+
+class GitDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    protected function getContents(string $url): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitHubDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitHubDriver.php
new file mode 100644
index 00000000..32b3551d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitHubDriver.php
@@ -0,0 +1,147 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\GitHubDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Util\Http\Response;
+
+class GitHubDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getRepositoryUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepositoryUrl');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    protected function getApiUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getApiUrl');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function getRepoData(): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoData');
+    }
+
+    protected function generateSshUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateSshUrl');
+    }
+
+    protected function getContents(string $url, bool $fetchingRepoData = false): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    protected function fetchRootIdentifier(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fetchRootIdentifier');
+    }
+
+    protected function attemptCloneFallback(?\Throwable $e = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'attemptCloneFallback');
+    }
+
+    protected function setupGitDriver(string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setupGitDriver');
+    }
+
+    protected function getNextPage(Response $response): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getNextPage');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitLabDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitLabDriver.php
new file mode 100644
index 00000000..b1d0c34d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/GitLabDriver.php
@@ -0,0 +1,165 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\GitLabDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Util\HttpDownloader;
+use Composer\Util\Http\Response;
+
+class GitLabDriver extends VcsDriver
+{
+    public const URL_REGEX = '#^(?:(?P<scheme>https?)://(?P<domain>.+?)(?::(?P<port>[0-9]+))?/|git@(?P<domain2>[^:]+):)(?P<parts>.+)/(?P<repo>[^/]+?)(?:\.git|/)?$#';
+
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function setHttpDownloader(HttpDownloader $httpDownloader): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setHttpDownloader');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getRepositoryUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepositoryUrl');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getApiUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getApiUrl');
+    }
+
+    protected function getReferences(string $type): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getReferences');
+    }
+
+    protected function fetchProject(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fetchProject');
+    }
+
+    protected function attemptCloneFallback(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'attemptCloneFallback');
+    }
+
+    protected function generateSshUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateSshUrl');
+    }
+
+    protected function generatePublicUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generatePublicUrl');
+    }
+
+    protected function setupGitDriver(string $url): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setupGitDriver');
+    }
+
+    protected function getContents(string $url, bool $fetchingRepoData = false): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function getRepoData(): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoData');
+    }
+
+    protected function getNextPage(Response $response): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getNextPage');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/HgDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/HgDriver.php
new file mode 100644
index 00000000..18cf388d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/HgDriver.php
@@ -0,0 +1,106 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\HgDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class HgDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    protected function getContents(string $url): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/PerforceDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/PerforceDriver.php
new file mode 100644
index 00000000..fbff0a56
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/PerforceDriver.php
@@ -0,0 +1,117 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\PerforceDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+use Composer\Util\Http\Response;
+
+class PerforceDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    public function getContents(string $url): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+
+    public function getDepot(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDepot');
+    }
+
+    public function getBranch(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranch');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/SvnDriver.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/SvnDriver.php
new file mode 100644
index 00000000..3f9b1569
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/Vcs/SvnDriver.php
@@ -0,0 +1,121 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\Vcs\SvnDriver.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+// Composer\Repository\Vcs\VcsDriver::__construct() is final, so it keeps running the real implementation here.
+
+namespace Composer\Repository\Vcs;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class SvnDriver extends VcsDriver
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function initialize(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function getRootIdentifier(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRootIdentifier');
+    }
+
+    public function getUrl(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUrl');
+    }
+
+    public function getSource(string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSource');
+    }
+
+    public function getDist(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDist');
+    }
+
+    protected function shouldCache(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'shouldCache');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getChangeDate(string $identifier): ?\DateTimeImmutable
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeDate');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supports');
+    }
+
+    protected static function normalizeUrl(string $url): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'normalizeUrl');
+    }
+
+    protected function execute(array $command, string $url): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'execute');
+    }
+
+    protected function buildIdentifier(string $baseDir, int $revision): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'buildIdentifier');
+    }
+
+    protected function getBaseComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBaseComposerInformation');
+    }
+
+    public function hasComposerFile(string $identifier): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasComposerFile');
+    }
+
+    protected function getScheme(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getScheme');
+    }
+
+    protected function getContents(string $url): Response
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public function cleanup(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanup');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Repository/VcsRepository.php b/crates/shirabe-php-rpc/php/guards/Composer/Repository/VcsRepository.php
new file mode 100644
index 00000000..0c3e612e
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Repository/VcsRepository.php
@@ -0,0 +1,70 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Repository\VcsRepository.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Repository;
+
+use Composer\Repository\Vcs\VcsDriverInterface;
+use Composer\Package\Loader\LoaderInterface;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\HttpDownloader;
+use Composer\IO\IOInterface;
+use Composer\Config;
+
+class VcsRepository extends ArrayRepository implements ConfigurableRepositoryInterface
+{
+    public function __construct(array $repoConfig, IOInterface $io, Config $config, HttpDownloader $httpDownloader, ?EventDispatcher $dispatcher = null, ?ProcessExecutor $process = null, ?array $drivers = null, ?VersionCacheInterface $versionCache = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getRepoName()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoName');
+    }
+
+    public function getRepoConfig()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRepoConfig');
+    }
+
+    public function setLoader(LoaderInterface $loader): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setLoader');
+    }
+
+    public function getDriver(): ?VcsDriverInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDriver');
+    }
+
+    public function hadInvalidBranches(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hadInvalidBranches');
+    }
+
+    public function getEmptyReferences(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getEmptyReferences');
+    }
+
+    public function getVersionTransportExceptions(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVersionTransportExceptions');
+    }
+
+    protected function initialize()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    protected function preProcess(VcsDriverInterface $driver, array $data, string $identifier): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'preProcess');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php
new file mode 100644
index 00000000..a17ce769
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php
@@ -0,0 +1,45 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\AuthHelper.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class AuthHelper
+{
+    public function __construct(IOInterface $io, Config $config)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function storeAuth(string $origin, $storeAuth): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'storeAuth');
+    }
+
+    public function promptAuthIfNeeded(string $url, string $origin, int $statusCode, ?string $reason = null, array $headers = [], int $retryCount = 0, ?string $responseBody = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'promptAuthIfNeeded');
+    }
+
+    public function addAuthenticationHeader(array $headers, string $origin, string $url): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addAuthenticationHeader');
+    }
+
+    public function addAuthenticationOptions(array $options, string $origin, string $url): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addAuthenticationOptions');
+    }
+
+    public function isPublicBitBucketDownload(string $urlToBitBucketFile): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isPublicBitBucketDownload');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php
new file mode 100644
index 00000000..b85c4b45
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php
@@ -0,0 +1,42 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Bitbucket.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\IO\IOInterface;
+use Composer\Config;
+
+class Bitbucket
+{
+    public const OAUTH2_ACCESS_TOKEN_URL = 'https://bitbucket.org/site/oauth2/access_token';
+
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?HttpDownloader $httpDownloader = null, ?int $time = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getToken(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getToken');
+    }
+
+    public function authorizeOAuth(string $originUrl): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuth');
+    }
+
+    public function authorizeOAuthInteractively(string $originUrl, ?string $message = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthInteractively');
+    }
+
+    public function requestToken(string $originUrl, string $consumerKey, string $consumerSecret): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'requestToken');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php
new file mode 100644
index 00000000..0e35d197
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php
@@ -0,0 +1,27 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\ConfigValidator.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\Package\Loader\ValidatingArrayLoader;
+use Composer\IO\IOInterface;
+
+class ConfigValidator
+{
+    public const CHECK_VERSION = 1;
+
+    public function __construct(IOInterface $io)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function validate(string $file, int $arrayLoaderValidationFlags = ValidatingArrayLoader::CHECK_ALL, int $flags = self::CHECK_VERSION): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'validate');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php
new file mode 100644
index 00000000..6d8dbb24
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php
@@ -0,0 +1,167 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Filesystem.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+class Filesystem
+{
+    public function __construct(?ProcessExecutor $executor = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function remove(string $file)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'remove');
+    }
+
+    public function isDirEmpty(string $dir)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDirEmpty');
+    }
+
+    public function emptyDirectory(string $dir, bool $ensureDirectoryExists = true)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'emptyDirectory');
+    }
+
+    public function removeDirectory(string $directory)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeDirectory');
+    }
+
+    public function removeDirectoryAsync(string $directory)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeDirectoryAsync');
+    }
+
+    public function removeDirectoryPhp(string $directory)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeDirectoryPhp');
+    }
+
+    public function ensureDirectoryExists(string $directory)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'ensureDirectoryExists');
+    }
+
+    public function unlink(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'unlink');
+    }
+
+    public function rmdir(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'rmdir');
+    }
+
+    public function copyThenRemove(string $source, string $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'copyThenRemove');
+    }
+
+    public function copy(string $source, string $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'copy');
+    }
+
+    public function rename(string $source, string $target)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'rename');
+    }
+
+    public function findShortestPath(string $from, string $to, bool $directories = false, bool $preferRelative = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findShortestPath');
+    }
+
+    public function findShortestPathCode(string $from, string $to, bool $directories = false, bool $staticCode = false, bool $preferRelative = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findShortestPathCode');
+    }
+
+    public function isAbsolutePath(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isAbsolutePath');
+    }
+
+    public function size(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'size');
+    }
+
+    public function normalizePath(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'normalizePath');
+    }
+
+    public static function trimTrailingSlash(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'trimTrailingSlash');
+    }
+
+    public static function isLocalPath(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isLocalPath');
+    }
+
+    public static function getPlatformPath(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPlatformPath');
+    }
+
+    public static function isReadable(string $path)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isReadable');
+    }
+
+    protected function directorySize(string $directory)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'directorySize');
+    }
+
+    protected function getProcess()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProcess');
+    }
+
+    public function relativeSymlink(string $target, string $link)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'relativeSymlink');
+    }
+
+    public function isSymlinkedDirectory(string $directory)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isSymlinkedDirectory');
+    }
+
+    public function junction(string $target, string $junction)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'junction');
+    }
+
+    public function isJunction(string $junction)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isJunction');
+    }
+
+    public function removeJunction(string $junction)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'removeJunction');
+    }
+
+    public function filePutContentsIfModified(string $path, string $content)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'filePutContentsIfModified');
+    }
+
+    public function safeCopy(string $source, string $target): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'safeCopy');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php
new file mode 100644
index 00000000..df78b1f1
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php
@@ -0,0 +1,100 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Git.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class Git
+{
+    public function __construct(IOInterface $io, Config $config, ProcessExecutor $process, Filesystem $fs)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public static function checkForRepoOwnershipError(string $output, string $path, ?IOInterface $io = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'checkForRepoOwnershipError');
+    }
+
+    public function setHttpDownloader(HttpDownloader $httpDownloader): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setHttpDownloader');
+    }
+
+    public function runCommands(array $commands, string $url, ?string $cwd, bool $initialClone = false, &$commandOutput = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'runCommands');
+    }
+
+    public function runCommand($commandCallable, string $url, ?string $cwd, bool $initialClone = false, &$commandOutput = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'runCommand');
+    }
+
+    public function syncMirror(string $url, string $dir): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'syncMirror');
+    }
+
+    public function fetchRefOrSyncMirror(string $url, string $dir, string $ref, ?string $prettyVersion = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'fetchRefOrSyncMirror');
+    }
+
+    public static function getNoShowSignatureFlag(ProcessExecutor $process): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getNoShowSignatureFlag');
+    }
+
+    public static function getNoShowSignatureFlags(ProcessExecutor $process): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getNoShowSignatureFlags');
+    }
+
+    public static function supportsNoCommitHeaderFlag(ProcessExecutor $process): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'supportsNoCommitHeaderFlag');
+    }
+
+    public static function buildRevListCommand(ProcessExecutor $process, array $arguments): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'buildRevListCommand');
+    }
+
+    public static function parseRevListOutput(string $output, ProcessExecutor $process): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'parseRevListOutput');
+    }
+
+    public function getMirrorDefaultBranch(string $url, string $dir, bool $isLocalPathRepository): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getMirrorDefaultBranch');
+    }
+
+    public static function cleanEnv(?ProcessExecutor $process = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanEnv');
+    }
+
+    public static function getGitHubDomainsRegex(Config $config): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getGitHubDomainsRegex');
+    }
+
+    public static function getGitLabDomainsRegex(Config $config): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getGitLabDomainsRegex');
+    }
+
+    public static function getVersion(ProcessExecutor $process): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getVersion');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php
new file mode 100644
index 00000000..e6dadefb
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php
@@ -0,0 +1,52 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\GitHub.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\IO\IOInterface;
+use Composer\Config;
+
+class GitHub
+{
+    public const GITHUB_TOKEN_REGEX = '{^([a-f0-9]{12,}|gh[a-z]_[a-zA-Z0-9_]+|github_pat_[a-zA-Z0-9_]+)$}';
+
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?HttpDownloader $httpDownloader = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function authorizeOAuth(string $originUrl): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuth');
+    }
+
+    public function authorizeOAuthInteractively(string $originUrl, ?string $message = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthInteractively');
+    }
+
+    public function getRateLimit(array $headers): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRateLimit');
+    }
+
+    public function getSsoUrl(array $headers): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getSsoUrl');
+    }
+
+    public function isRateLimited(array $headers): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isRateLimited');
+    }
+
+    public function requiresSso(array $headers): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'requiresSso');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php
new file mode 100644
index 00000000..4c131f61
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php
@@ -0,0 +1,40 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\GitLab.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\IO\IOInterface;
+use Composer\Config;
+
+class GitLab
+{
+    public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?HttpDownloader $httpDownloader = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function authorizeOAuth(string $originUrl): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuth');
+    }
+
+    public function authorizeOAuthInteractively(string $scheme, string $originUrl, ?string $message = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthInteractively');
+    }
+
+    public function authorizeOAuthRefresh(string $scheme, string $originUrl): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthRefresh');
+    }
+
+    public function isOAuthExpired(string $originUrl): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isOAuthExpired');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php
new file mode 100644
index 00000000..5e362356
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php
@@ -0,0 +1,37 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Http\CurlDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util\Http;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class CurlDownloader
+{
+    private const BAD_MULTIPLEXING_CURL_VERSIONS = ['7.87.0', '7.88.0', '7.88.1'];
+
+    public function __construct(IOInterface $io, Config $config, array $options = [], bool $disableTls = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function download(callable $resolve, callable $reject, string $origin, string $url, array $options, ?string $copyTo = null): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'download');
+    }
+
+    public function abortRequest(int $id): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'abortRequest');
+    }
+
+    public function tick(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'tick');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php
new file mode 100644
index 00000000..ae229589
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php
@@ -0,0 +1,22 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Http\CurlResponse.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util\Http;
+
+class CurlResponse extends Response
+{
+    public function __construct(array $request, ?int $code, array $headers, ?string $body, array $curlInfo)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getCurlInfo(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCurlInfo');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php
new file mode 100644
index 00000000..61eebb7f
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php
@@ -0,0 +1,57 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Http\Response.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util\Http;
+
+class Response
+{
+    public function __construct(array $request, ?int $code, array $headers, ?string $body)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getStatusCode(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStatusCode');
+    }
+
+    public function getStatusMessage(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStatusMessage');
+    }
+
+    public function getHeaders(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHeaders');
+    }
+
+    public function getHeader(string $name): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHeader');
+    }
+
+    public function getBody(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBody');
+    }
+
+    public function decodeJson()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'decodeJson');
+    }
+
+    public function collect(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'collect');
+    }
+
+    public static function findHeaderValue(array $headers, string $name): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findHeaderValue');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php
new file mode 100644
index 00000000..a2fad123
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php
@@ -0,0 +1,86 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\HttpDownloader.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class HttpDownloader
+{
+    private const STATUS_QUEUED = 1;
+    private const STATUS_STARTED = 2;
+    private const STATUS_COMPLETED = 3;
+    private const STATUS_FAILED = 4;
+    private const STATUS_ABORTED = 5;
+
+    public function __construct(IOInterface $io, Config $config, array $options = [], bool $disableTls = false)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function get(string $url, array $options = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'get');
+    }
+
+    public function add(string $url, array $options = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'add');
+    }
+
+    public function copy(string $url, string $to, array $options = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'copy');
+    }
+
+    public function addCopy(string $url, string $to, array $options = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'addCopy');
+    }
+
+    public function getOptions()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getOptions');
+    }
+
+    public function setOptions(array $options)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setOptions');
+    }
+
+    public function wait(?int $index = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'wait');
+    }
+
+    public function enableAsync(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'enableAsync');
+    }
+
+    public function countActiveJobs(?int $index = null): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'countActiveJobs');
+    }
+
+    public static function outputWarnings(IOInterface $io, string $url, $data): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'outputWarnings');
+    }
+
+    public static function getExceptionHints(\Throwable $e): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getExceptionHints');
+    }
+
+    public static function isCurlEnabled(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isCurlEnabled');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php
new file mode 100644
index 00000000..32648ece
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php
@@ -0,0 +1,39 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Loop.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Symfony\Component\Console\Helper\ProgressBar;
+
+class Loop
+{
+    public function __construct(HttpDownloader $httpDownloader, ?ProcessExecutor $processExecutor = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function getHttpDownloader(): HttpDownloader
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getHttpDownloader');
+    }
+
+    public function getProcessExecutor(): ?ProcessExecutor
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getProcessExecutor');
+    }
+
+    public function wait(array $promises, ?ProgressBar $progress = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'wait');
+    }
+
+    public function abortJobs(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'abortJobs');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php
new file mode 100644
index 00000000..892317b9
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php
@@ -0,0 +1,219 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Perforce.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\IO\IOInterface;
+
+class Perforce
+{
+    public function __construct($repoConfig, string $port, string $path, ProcessExecutor $process, bool $isWindows, IOInterface $io)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public static function create($repoConfig, string $port, string $path, ProcessExecutor $process, IOInterface $io): self
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'create');
+    }
+
+    public static function checkServerExists(string $url, ProcessExecutor $processExecutor): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'checkServerExists');
+    }
+
+    public function initialize($repoConfig): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initialize');
+    }
+
+    public function initializeDepotAndBranch(?string $depot, ?string $branch): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initializeDepotAndBranch');
+    }
+
+    public function generateUniquePerforceClientName(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateUniquePerforceClientName');
+    }
+
+    public function cleanupClientSpec(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanupClientSpec');
+    }
+
+    protected function executeCommand($command): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'executeCommand');
+    }
+
+    public function getClient(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getClient');
+    }
+
+    protected function getPath(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPath');
+    }
+
+    public function initializePath(string $path): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'initializePath');
+    }
+
+    protected function getPort(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPort');
+    }
+
+    public function setStream(string $stream): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setStream');
+    }
+
+    public function isStream(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isStream');
+    }
+
+    public function getStream(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStream');
+    }
+
+    public function getStreamWithoutLabel(string $stream): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getStreamWithoutLabel');
+    }
+
+    public function getP4ClientSpec(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getP4ClientSpec');
+    }
+
+    public function getUser(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUser');
+    }
+
+    public function setUser(?string $user): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setUser');
+    }
+
+    public function queryP4User(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'queryP4User');
+    }
+
+    protected function getP4variable(string $name): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getP4variable');
+    }
+
+    public function queryP4Password(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'queryP4Password');
+    }
+
+    public function generateP4Command(array $arguments, bool $useClient = true): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'generateP4Command');
+    }
+
+    public function isLoggedIn(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isLoggedIn');
+    }
+
+    public function connectClient(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'connectClient');
+    }
+
+    public function syncCodeBase(?string $sourceReference): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'syncCodeBase');
+    }
+
+    public function writeClientSpecToFile($spec): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'writeClientSpecToFile');
+    }
+
+    public function writeP4ClientSpec(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'writeP4ClientSpec');
+    }
+
+    protected function read($pipe, $name): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'read');
+    }
+
+    public function windowsLogin(?string $password): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'windowsLogin');
+    }
+
+    public function p4Login(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'p4Login');
+    }
+
+    public function getComposerInformation(string $identifier): ?array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation');
+    }
+
+    public function getFileContent(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFileContent');
+    }
+
+    public function getFilePath(string $file, string $identifier): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFilePath');
+    }
+
+    public function getBranches(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getBranches');
+    }
+
+    public function getTags(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTags');
+    }
+
+    public function checkStream(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'checkStream');
+    }
+
+    protected function getChangeList(string $reference): mixed
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getChangeList');
+    }
+
+    public function getCommitLogs(string $fromReference, string $toReference): mixed
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs');
+    }
+
+    public function getFilesystem(): Filesystem
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getFilesystem');
+    }
+
+    public function setFilesystem(Filesystem $fs): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setFilesystem');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php
new file mode 100644
index 00000000..2384723d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php
@@ -0,0 +1,92 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Platform.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+class Platform
+{
+    public function __construct()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public static function getCwd(bool $allowEmpty = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCwd');
+    }
+
+    public static function realpath(string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'realpath');
+    }
+
+    public static function getEnv(string $name)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getEnv');
+    }
+
+    public static function putEnv(string $name, string $value): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'putEnv');
+    }
+
+    public static function clearEnv(string $name): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'clearEnv');
+    }
+
+    public static function expandPath(string $path): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'expandPath');
+    }
+
+    public static function getUserDirectory(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUserDirectory');
+    }
+
+    public static function isWindowsSubsystemForLinux(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isWindowsSubsystemForLinux');
+    }
+
+    public static function isWindows(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isWindows');
+    }
+
+    public static function isDocker(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isDocker');
+    }
+
+    public static function strlen(string $str): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'strlen');
+    }
+
+    public static function isTty($fd = null): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isTty');
+    }
+
+    public static function isInputCompletionProcess(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isInputCompletionProcess');
+    }
+
+    public static function workaroundFilesystemIssues(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'workaroundFilesystemIssues');
+    }
+
+    public static function getDevNull(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getDevNull');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php
new file mode 100644
index 00000000..405905e8
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php
@@ -0,0 +1,114 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\ProcessExecutor.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\IO\IOInterface;
+use React\Promise\PromiseInterface;
+
+class ProcessExecutor
+{
+    private const STATUS_QUEUED = 1;
+    private const STATUS_STARTED = 2;
+    private const STATUS_COMPLETED = 3;
+    private const STATUS_FAILED = 4;
+    private const STATUS_ABORTED = 5;
+    private const BUILTIN_CMD_COMMANDS = [
+        'assoc', 'break', 'call', 'cd', 'chdir', 'cls', 'color', 'copy', 'date',
+        'del', 'dir', 'echo', 'endlocal', 'erase', 'exit', 'for', 'ftype', 'goto',
+        'help', 'if', 'label', 'md', 'mkdir', 'mklink', 'move', 'path', 'pause',
+        'popd', 'prompt', 'pushd', 'rd', 'rem', 'ren', 'rename', 'rmdir', 'set',
+        'setlocal', 'shift', 'start', 'time', 'title', 'type', 'ver', 'vol',
+    ];
+    private const GIT_CMDS_NEED_GIT_DIR = [
+        ['show'],
+        ['log'],
+        ['branch'],
+        ['remote', 'set-url'],
+    ];
+
+    public function __construct(?IOInterface $io = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function execute($command, &$output = null, ?string $cwd = null): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'execute');
+    }
+
+    public function executeTty($command, ?string $cwd = null): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'executeTty');
+    }
+
+    public function executeAsync($command, ?string $cwd = null): PromiseInterface
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'executeAsync');
+    }
+
+    protected function outputHandler(string $type, string $buffer): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'outputHandler');
+    }
+
+    public function setMaxJobs(int $maxJobs): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setMaxJobs');
+    }
+
+    public function resetMaxJobs(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'resetMaxJobs');
+    }
+
+    public function wait($index = null): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'wait');
+    }
+
+    public function enableAsync(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'enableAsync');
+    }
+
+    public function countActiveJobs($index = null): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'countActiveJobs');
+    }
+
+    public function splitLines(?string $output): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'splitLines');
+    }
+
+    public function getErrorOutput(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getErrorOutput');
+    }
+
+    public static function getTimeout(): int
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getTimeout');
+    }
+
+    public static function setTimeout(int $timeout): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setTimeout');
+    }
+
+    public static function escape($argument): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'escape');
+    }
+
+    public function requiresGitDirEnv($command): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'requiresGitDirEnv');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php
new file mode 100644
index 00000000..3cf20768
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php
@@ -0,0 +1,85 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\RemoteFilesystem.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class RemoteFilesystem
+{
+    public function __construct(IOInterface $io, Config $config, array $options = [], bool $disableTls = false, ?AuthHelper $authHelper = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public function copy(string $originUrl, string $fileUrl, string $fileName, bool $progress = true, array $options = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'copy');
+    }
+
+    public function getContents(string $originUrl, string $fileUrl, bool $progress = true, array $options = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getContents');
+    }
+
+    public function getOptions()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getOptions');
+    }
+
+    public function setOptions(array $options)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setOptions');
+    }
+
+    public function isTlsDisabled()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'isTlsDisabled');
+    }
+
+    public function getLastHeaders()
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getLastHeaders');
+    }
+
+    public static function findStatusCode(array $headers)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findStatusCode');
+    }
+
+    public function findStatusMessage(array $headers)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'findStatusMessage');
+    }
+
+    protected function get(string $originUrl, string $fileUrl, array $additionalOptions = [], ?string $fileName = null, bool $progress = true)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'get');
+    }
+
+    protected function getRemoteContents(string $originUrl, string $fileUrl, $context, ?array &$responseHeaders = null, ?int $maxFileSize = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getRemoteContents');
+    }
+
+    protected function callbackGet(int $notificationCode, int $severity, ?string $message, int $messageCode, int $bytesTransferred, int $bytesMax)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'callbackGet');
+    }
+
+    protected function promptAuthAndRetry($httpStatus, ?string $reason = null, array $headers = [])
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'promptAuthAndRetry');
+    }
+
+    protected function getOptionsForUrl(string $originUrl, array $additionalOptions)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getOptionsForUrl');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php
new file mode 100644
index 00000000..c113296d
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php
@@ -0,0 +1,82 @@
+<?php
+
+// Generated by scripts/plugin-stub-generator; do not edit by hand.
+// Guard for Composer\Util\Svn.
+// The Rust side owns this class and the worker has no proxy for it, so this
+// declaration shadows the real one: the constants and the hierarchy stay, while
+// constructing it or calling anything on it raises an explicit error.
+
+namespace Composer\Util;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+class Svn
+{
+    private const MAX_QTY_AUTH_TRIES = 5;
+
+    public function __construct(string $url, IOInterface $io, Config $config, ?ProcessExecutor $process = null)
+    {
+        \ShirabeUnsupportedClass::fail(self::class, '__construct');
+    }
+
+    public static function cleanEnv(): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'cleanEnv');
+    }
+
+    public function execute(array $command, string $url, ?string $cwd = null, ?string $path = null, bool $verbose = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'execute');
+    }
+
+    public function executeLocal(array $command, string $path, ?string $cwd = null, bool $verbose = false): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'executeLocal');
+    }
+
+    public function setCacheCredentials(bool $cacheCredentials): void
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'setCacheCredentials');
+    }
+
+    protected function doAuthDance(): Svn
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'doAuthDance');
+    }
+
+    protected function getCommand(array $cmd, string $url, ?string $path = null): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCommand');
+    }
+
+    protected function getCredentialArgs(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getCredentialArgs');
+    }
+
+    protected function getPassword(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getPassword');
+    }
+
+    protected function getUsername(): string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getUsername');
+    }
+
+    protected function hasAuth(): bool
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'hasAuth');
+    }
+
+    protected function getAuthCacheArgs(): array
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'getAuthCacheArgs');
+    }
+
+    public function binaryVersion(): ?string
+    {
+        \ShirabeUnsupportedClass::fail(self::class, 'binaryVersion');
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/worker.php b/crates/shirabe-php-rpc/php/worker.php
index d5fe67d4..ce75f9d1 100644
--- a/crates/shirabe-php-rpc/php/worker.php
+++ b/crates/shirabe-php-rpc/php/worker.php
@@ -30,6 +30,23 @@ interface ShirabeRustStub
     public function __shirabeBind(int $rhandle, int $epoch): void;
 }
 
+/**
+ * Raised by the guard classes (php/guards/): classes whose entity lives on the Rust side but that
+ * this worker has no proxy for. Their declaration shadows the real Composer one, so running the
+ * real implementation here — on an instance the Rust side never sees — fails loudly instead.
+ */
+final class ShirabeUnsupportedClass
+{
+    public static function fail(string $class, string $member): void
+    {
+        throw new RuntimeException(
+            "{$class}::{$member}() is not available in the plugin runtime: the Rust side owns "
+            . 'this class and there is no proxy for it here, so the real implementation would '
+            . 'run on an instance the Rust side never sees.'
+        );
+    }
+}
+
 /** Interns proxy stubs so the same Rust handle always yields the same stub instance. */
 final class ShirabeRustObjectRegistry
 {
@@ -44,7 +61,9 @@ final class ShirabeRustObjectRegistry
                 return $existing;
             }
         }
-        if (!class_exists($class)) {
+        // A guard class exists for every proxied FQCN without a stub, so class_exists() alone no
+        // longer tells the two apart; only a stub can be bound to a Rust handle.
+        if (!class_exists($class) || !is_a($class, ShirabeRustStub::class, true)) {
             throw new RuntimeException(
                 "no proxy stub class is available for {$class}"
             );
@@ -143,6 +162,7 @@ final class ShirabeRpcRuntime
     /** @var resource */
     public static $socket;
     public static ?string $stubsDir = null;
+    public static ?string $guardsDir = null;
     /** @var ?callable(string): void */
     public static $stubAutoloader = null;
     /** @var array<string, callable(array): mixed> */
@@ -439,18 +459,20 @@ if ($client === false) {
 stream_set_write_buffer($client, 0);
 ShirabeRpcRuntime::$socket = $client;
 ShirabeRpcRuntime::$stubsDir = $argv[2] ?? null;
+ShirabeRpcRuntime::$guardsDir = $argv[3] ?? null;
 
 // Proxy stub classes take priority over any other autoloader (including autoloaders that a
 // script or the composer runtime registers later), so a proxied FQCN can never be shadowed by
 // the real implementation. `__shirabe_require` re-prepends this closure after loading code
-// that registers its own prepending autoloader.
+// that registers its own prepending autoloader. The guards come after the stubs: they cover the
+// Rust-owned classes no stub proxies, so the two directories never hold the same FQCN.
 ShirabeRpcRuntime::$stubAutoloader = static function (string $class): void {
-    if (ShirabeRpcRuntime::$stubsDir === null) {
-        return;
-    }
-    $file = ShirabeRpcRuntime::$stubsDir . '/' . str_replace('\\', '/', $class) . '.php';
-    if (is_file($file)) {
-        require $file;
+    $relative = '/' . str_replace('\\', '/', $class) . '.php';
+    foreach ([ShirabeRpcRuntime::$stubsDir, ShirabeRpcRuntime::$guardsDir] as $dir) {
+        if ($dir !== null && is_file($dir . $relative)) {
+            require $dir . $relative;
+            return;
+        }
     }
 };
 spl_autoload_register(ShirabeRpcRuntime::$stubAutoloader, true, true);
diff --git a/crates/shirabe-php-rpc/src/lib.rs b/crates/shirabe-php-rpc/src/lib.rs
index 34c3961d..d818b364 100644
--- a/crates/shirabe-php-rpc/src/lib.rs
+++ b/crates/shirabe-php-rpc/src/lib.rs
@@ -1035,6 +1035,13 @@ const RUNTIME_FILES: &[(&str, &str)] = &[
     ),
 ];
 
+/// Guard classes made autoloadable inside the worker, behind the stubs: they shadow the real
+/// Composer class of every Rust-owned FQCN no stub proxies, so the worker cannot fall through to
+/// the real implementation and run an instance the Rust side never sees. Generated by
+/// `scripts/plugin-stub-generator/generate-stubs`; too many to spell out here, so `build.rs`
+/// builds the list from the directory itself.
+const GUARD_FILES: &[(&str, &str)] = include!(concat!(env!("OUT_DIR"), "/guard-files.rs"));
+
 struct Worker {
     stream: UnixStream,
     // Also queried for its exit status when a socket read/write fails, to tell a dead worker
@@ -1106,9 +1113,15 @@ fn spawn_worker() -> anyhow::Result<Worker> {
     std::fs::write(&script_path, GLUE_SCRIPT)?;
 
     let stubs_dir = tempdir.path().join("stubs");
-    for (relative_path, contents) in STUB_FILES.iter().chain(RUNTIME_FILES) {
-        let path = stubs_dir.join(relative_path);
-        std::fs::create_dir_all(path.parent().expect("stub paths have a parent"))?;
+    let guards_dir = tempdir.path().join("guards");
+    let files = STUB_FILES
+        .iter()
+        .chain(RUNTIME_FILES)
+        .map(|entry| (&stubs_dir, entry))
+        .chain(GUARD_FILES.iter().map(|entry| (&guards_dir, entry)));
+    for (dir, (relative_path, contents)) in files {
+        let path = dir.join(relative_path);
+        std::fs::create_dir_all(path.parent().expect("generated class paths have a parent"))?;
         std::fs::write(&path, contents)?;
     }
 
@@ -1141,7 +1154,8 @@ fn spawn_worker() -> anyhow::Result<Worker> {
     command
         .arg(&script_path)
         .arg(WORKER_SOCKET_FD.to_string())
-        .arg(&stubs_dir);
+        .arg(&stubs_dir)
+        .arg(&guards_dir);
     // SAFETY: the closure only calls async-signal-safe syscalls, as required between fork and
     // exec. It owns the child end, so the descriptor stays alive until the exec happens.
     unsafe {
diff --git a/crates/shirabe-php-rpc/tests/generated_stubs.rs b/crates/shirabe-php-rpc/tests/generated_stubs.rs
index 0980745e..5648b44c 100644
--- a/crates/shirabe-php-rpc/tests/generated_stubs.rs
+++ b/crates/shirabe-php-rpc/tests/generated_stubs.rs
@@ -1,6 +1,6 @@
-//! Freshness check for the generated proxy stubs: `generate-stubs --check` verifies that the
-//! committed stub files and the `STUB_FILES` list in `lib.rs` match what the generator emits
-//! from the current Composer checkout and classifier report.
+//! Freshness check for the generated proxy stubs and guard classes: `generate-stubs --check`
+//! verifies that the committed stub and guard files, and the `STUB_FILES` list in `lib.rs`, match
+//! what the generator emits from the current Composer checkout and classifier report.
 //!
 //! The generator needs a PHP interpreter, its composer vendor directory and the classifier
 //! report; when any of those is missing the test returns early, following the non-mock test
-- 
cgit v1.3.1-4-g156e