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>

121 files changed, 8061 insertions, 91 deletions

diff --git a/README.md b/README.md
index 9ef03103..12638649 100644
--- a/README.md
+++ b/README.md
@@ -11,10 +11,7 @@ It aims at 100% compatibility with Composer, including the plugin API.
 
 ## Plugins
 
-Shirabe runs Composer plugins using the system-provided real PHP. The plugin API is partially implemented. The following plugins are verified to work:
-
-* [composer/installers](https://github.com/composer/installers)
-* [phpstan/extension-installer](https://github.com/phpstan/extension-installer)
+Shirabe runs Composer plugins using the system-provided real PHP. The plugin API is partially implemented.
 
 
 ## Requirements
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
diff --git a/crates/shirabe/src/installer.rs b/crates/shirabe/src/installer.rs
index 9b4a84e8..ee60f59f 100644
--- a/crates/shirabe/src/installer.rs
+++ b/crates/shirabe/src/installer.rs
@@ -273,7 +273,7 @@ impl Installer {
                 self.dev_mode,
                 vec![],
                 IndexMap::new(),
-            );
+            )?;
         }
 
         self.download_manager
@@ -469,7 +469,7 @@ impl Installer {
                 self.dev_mode,
                 vec![],
                 IndexMap::new(),
-            );
+            )?;
         }
 
         let audit_config = self.get_audit_config()?.clone();
diff --git a/crates/shirabe/tests/plugin/e2e_extension_installer_test.rs b/crates/shirabe/tests/plugin/e2e_extension_installer_test.rs
index 9a95888c..0465757a 100644
--- a/crates/shirabe/tests/plugin/e2e_extension_installer_test.rs
+++ b/crates/shirabe/tests/plugin/e2e_extension_installer_test.rs
@@ -117,6 +117,10 @@ fn run_install(work: &Path, program: &str, args: &[&str]) -> InstallRun {
     }
 }
 
+// TODO(plugin): the plugin's post-install listener does `new Composer\Util\Filesystem()`, and
+// the guard class the worker loads for that FQCN raises an explicit error: the Rust side owns
+// Filesystem and has no proxy for plugin-constructed instances of it.
+#[ignore = "Filesystem is Rust-owned and has no proxy the plugin can construct; see the TODO(plugin) above"]
 #[test]
 fn test_extension_installer_install_matches_upstream_composer() {
     if !php_runtime_available() {
diff --git a/crates/shirabe/tests/plugin/e2e_installers_test.rs b/crates/shirabe/tests/plugin/e2e_installers_test.rs
index 67c51b5c..9d8693fb 100644
--- a/crates/shirabe/tests/plugin/e2e_installers_test.rs
+++ b/crates/shirabe/tests/plugin/e2e_installers_test.rs
@@ -99,6 +99,11 @@ fn edit(path: &Path, from: &str, to: &str) {
     std::fs::write(path, text.replace(from, to)).unwrap();
 }
 
+// TODO(plugin): the plugin's Installer extends Composer\Installer\LibraryInstaller, whose
+// constructor the guard class the worker loads rejects with an explicit error: the Rust side owns
+// LibraryInstaller and has no proxy a plugin can subclass. The same applies to the two tests
+// below.
+#[ignore = "LibraryInstaller is Rust-owned and has no proxy a plugin can subclass; see the TODO(plugin) above"]
 #[test]
 fn test_composer_installers_matches_upstream_composer() {
     if !php_runtime_available() || !plugin_fetched() {
@@ -139,6 +144,7 @@ fn test_composer_installers_matches_upstream_composer() {
 /// The rest of the installer contract: `update` reinstalls a package in place, a second `install`
 /// runs over an already-installed tree, and `remove` reaches the plugin's own `uninstall()`
 /// override — the one that chains onto the promise `LibraryInstaller::uninstall` returns.
+#[ignore = "LibraryInstaller is Rust-owned and has no proxy a plugin can subclass; see the TODO(plugin) above"]
 #[test]
 fn test_composer_installers_update_and_remove_match_upstream_composer() {
     if !php_runtime_available() || !plugin_fetched() {
@@ -203,6 +209,7 @@ fn test_composer_installers_update_and_remove_match_upstream_composer() {
 /// The plugin's configuration surface: `installer-paths` in the root package's extra (both the
 /// `type:` and the package-name matcher, with `{$name}` templating) and `installer-name` in the
 /// installed package's own extra. Both are read back through the package proxy.
+#[ignore = "LibraryInstaller is Rust-owned and has no proxy a plugin can subclass; see the TODO(plugin) above"]
 #[test]
 fn test_composer_installers_custom_paths_match_upstream_composer() {
     if !php_runtime_available() || !plugin_fetched() {
diff --git a/crates/shirabe/tests/plugin/e2e_normalize_test.rs b/crates/shirabe/tests/plugin/e2e_normalize_test.rs
index ccfdb596..9fb49bab 100644
--- a/crates/shirabe/tests/plugin/e2e_normalize_test.rs
+++ b/crates/shirabe/tests/plugin/e2e_normalize_test.rs
@@ -1,7 +1,7 @@
 //! ergebnis/composer-normalize E2E compatibility check: upstream Composer and Shirabe each
-//! install the pinned plugin (with its real dependency tree) and the `list`/`help` renderings
-//! of its command are compared; the execution comparison is present but ignored until the
-//! worker can construct a second native Composer instance.
+//! install the pinned plugin (with its real dependency tree); the `list`/`help` renderings of its
+//! command are compared, as is running the command. Both comparisons are ignored, each for the
+//! reason recorded on it.
 //!
 //! Prerequisites: the PHP runtime, the Composer checkout, and the pinned packages in
 //! `fixtures/e2e-normalize/ext/` — run `fixtures/e2e-normalize/fetch` once to populate it.
@@ -60,6 +60,10 @@ fn normalize_lines(stdout: &str) -> Vec<&str> {
         .collect()
 }
 
+// TODO(plugin): NormalizePlugin::getCommands() does `new Composer\Factory()`, and the guard
+// class the worker loads for that FQCN raises an explicit error: Factory has no counterpart the
+// worker can run, so the plugin's command never reaches the command list.
+#[ignore = "the plugin's command provider constructs Composer\\Factory, which the worker has no counterpart for; see the TODO(plugin) above"]
 #[test]
 fn test_normalize_listing_matches_upstream_composer() {
     if !php_runtime_available() {
diff --git a/docs/dev/php-rpc.md b/docs/dev/php-rpc.md
index b1c992d7..f91b8e54 100644
--- a/docs/dev/php-rpc.md
+++ b/docs/dev/php-rpc.md
@@ -185,7 +185,7 @@ allocates the Rust entity behind a `new SomeProxiedClass(...)` written by plugin
 answers with `[rhandle, epoch]`. Classes whose entity Rust cannot build are an explicit error
 naming the class.
 
-## Proxy stubs and runtime classes
+## Proxy stubs, runtime classes and guards
 
 `php/stubs/` holds the proxy stub classes (`Composer\Script\Event`, `Composer\PartialComposer`,
 `Composer\Composer`, the `Composer\IO\{BaseIO,ConsoleIO,BufferIO,NullIO}` hierarchy, the
@@ -215,8 +215,14 @@ by `scripts/plugin-stub-generator/generate-stubs` and must not be edited by hand
   here) is a faithful in-process port of the real base class and crosses the wire as a P-table
   entity (`__shirabeRustHandleDescriptor()` returns null in native mode).
 
-Both sets are written into the same autoload directory at worker spawn and resolved with
-highest priority, so these FQCNs can never be shadowed by the real implementation;
+`php/guards/` holds the guard classes: one per Composer class whose entity lives on the Rust side
+and that neither a stub nor a runtime class shadows. A guard keeps the FQCN, the hierarchy and the
+constants of the real class, and raises an explicit error from its constructor and every method,
+so code running here can never work on a second instance the Rust side never sees. They are
+generated by the same tool as the stubs.
+
+The three sets are written into two autoload directories at worker spawn (guards behind stubs) and
+resolved with highest priority, so these FQCNs can never be shadowed by the real implementation;
 `__shirabe_require` restores that priority after loading code that prepends its own autoloader.
 Stubs are interned per rhandle (`WeakReference`-based registry) so identity (`===`) holds, and
 their destructors send `ReleaseRustHandle`. Reviving a stub for an existing entity bypasses its
diff --git a/docs/dev/plugin-class-classification.md b/docs/dev/plugin-class-classification.md
index c77eca52..7046ea48 100644
--- a/docs/dev/plugin-class-classification.md
+++ b/docs/dev/plugin-class-classification.md
@@ -42,6 +42,12 @@ exactly one category.
 | `php-native` | PHP | the real, unmodified PHP source | none — Rust may or may not have its own port for internal use, and that port is free to diverge in shape |
 | `unsupported` | n/a | nothing; any reference raises an explicit error | none, until explicitly promoted |
 
+A Rust-owned class the child has no artifact for — every `unsupported` one, and
+every `rust-proxy`/`rust-snapshot` one whose stub is not written yet — is
+shadowed there by a generated *guard* class instead of the real Composer source:
+same FQCN, hierarchy and constants, every constructor and method an explicit
+error. See `docs/dev/plugin-stub-generation.md`.
+
 #### rust-proxy
 
 The living services: `Composer`, `Config`, `RepositoryManager`,
diff --git a/docs/dev/plugin-stub-generation.md b/docs/dev/plugin-stub-generation.md
index 68dde156..e2b6d848 100644
--- a/docs/dev/plugin-stub-generation.md
+++ b/docs/dev/plugin-stub-generation.md
@@ -1,4 +1,4 @@
-# Plugin proxy stub generation
+# Plugin proxy stub and guard generation
 
 ## Purpose
 
@@ -12,13 +12,21 @@ Composer sources keeps every stub signature mechanically faithful to the real
 class and turns "the stub is missing something the real class has" into a
 generation failure instead of silent breakage.
 
+The same tool emits the **guard classes** under
+`crates/shirabe-php-rpc/php/guards/`, one for every Rust-owned class no stub and
+no `php/runtime/` class shadows. Without them the worker's autoloader falls
+through to the real Composer implementation, and code running there works on a
+second instance the Rust side never sees — silent breakage in place of the
+explicit error an unimplemented plugin API is supposed to raise. `build.rs`
+embeds the guards, building the list from the directory itself.
+
 ## Running
 
 ```
 cd scripts/plugin-stub-generator
 composer install            # once; vendor/ is git-ignored
-./generate-stubs            # rewrites crates/shirabe-php-rpc/php/stubs/
-./generate-stubs --check    # verifies committed stubs are fresh; exit 1 otherwise
+./generate-stubs            # rewrites the stubs/ and guards/ directories
+./generate-stubs --check    # verifies committed files are fresh; exit 1 otherwise
 ```
 
 Inputs:
@@ -36,10 +44,19 @@ Inputs:
   interfaces from vendor packages (e.g. `Psr\Log\LoggerInterface`) resolve too.
 * the classifier report (`scripts/plugin-class-classifier/report.json`, override
   with `--report=`). Run `scripts/plugin-class-classifier/classify` first; the
-  report is git-ignored. Every target must be classified `rust-proxy` or
-  `contract`, and a report with classification violations is rejected.
+  report is git-ignored. Every stub target must be classified `rust-proxy` or
+  `contract`, and a report with classification violations is rejected. The guard
+  set is read from the report alone: every `rust-proxy`, `rust-snapshot` and
+  `unsupported` class that is not a stub target, a `php/runtime/` class or an
+  exemption.
+* `guard-exemptions.list` — the Rust-owned FQCNs that stay resolvable to the real
+  Composer class, each with the worker-side mechanism that makes a native
+  instance correct (the materialized-value codec for `Composer\Package\Link`,
+  the dual-mode `Composer\EventDispatcher\Event` for
+  `Composer\Plugin\PreCommandRunEvent`). An entry that needs no guard anyway
+  fails the run.
 
-The freshness check runs in `cargo test` as
+The freshness check for both sets runs in `cargo test` as
 `crates/shirabe-php-rpc/tests/generated_stubs.rs`; it returns early when PHP,
 the generator's vendor directory or the classifier report is unavailable.
 
@@ -93,6 +110,27 @@ the generator's vendor directory or the classifier report is unavailable.
   order, restricted to names the emitted stub references; signatures declared
   elsewhere (interface files) are re-spelled through that import table.
 
+## What a guard looks like
+
+A guard reproduces the real class's declaration — `abstract`/`final`, `extends`,
+`implements`, the constants and public static properties verbatim — so that
+references satisfied by the declaration alone keep working: `instanceof`,
+`catch`, `X::class`, `Link::TYPE_REQUIRE`. Everything executable raises
+`ShirabeUnsupportedClass::fail()`, which names the class and the member:
+
+* the constructor (the class's own, or the one it would inherit; a class whose
+  hierarchy declares none gets a no-argument one, so the implicit constructor
+  cannot be reached either),
+* every public and protected method the guard would otherwise inherit from real
+  code: its own, its traits', and those of ancestors up to the first one that is
+  itself guarded or shadowed by a stub. Private methods are reachable only from
+  the code the guard replaces, and a destructor that throws would fire during
+  unwinding, so neither is emitted.
+
+Abstract methods of an abstract guard stay abstract. A method an ancestor
+declares `final` cannot be redeclared, so it keeps running the real
+implementation; the guard's header names each one.
+
 ## Coverage assertions
 
 Generation fails — instead of emitting something quietly wrong — on:
@@ -107,7 +145,7 @@ Generation fails — instead of emitting something quietly wrong — on:
 * a target whose FQCN is also provided by `php/runtime/`.
 
 `generate-stubs` (in both modes) additionally fails when a `.php` file exists
-under the stubs directory that no target produces, or when `STUB_FILES` /
+under the stubs or guards directory that no target produces, or when `STUB_FILES` /
 `RUNTIME_FILES` in `crates/shirabe-php-rpc/src/lib.rs` does not embed every
 generated stub / runtime file. It also cross-checks the handoff property table
 for `Composer\Console\Application` (declared in `generate-stubs` itself) against
diff --git a/scripts/plugin-stub-generator/generate-stubs b/scripts/plugin-stub-generator/generate-stubs
index 5db83a27..c58e6a92 100755
--- a/scripts/plugin-stub-generator/generate-stubs
+++ b/scripts/plugin-stub-generator/generate-stubs
@@ -7,6 +7,8 @@ require __DIR__ . '/vendor/autoload.php';
 
 use Shirabe\PluginStubGenerator\GenerationError;
 use Shirabe\PluginStubGenerator\Generator;
+use Shirabe\PluginStubGenerator\GuardGenerator;
+use Shirabe\PluginStubGenerator\NamePrinter;
 use Shirabe\PluginStubGenerator\Project;
 use Shirabe\PluginStubGenerator\Report;
 
@@ -14,6 +16,7 @@ $repoRoot = dirname(__DIR__, 2);
 $composerRoot = $repoRoot . '/composer';
 $reportPath = $repoRoot . '/scripts/plugin-class-classifier/report.json';
 $stubsDir = $repoRoot . '/crates/shirabe-php-rpc/php/stubs';
+$guardsDir = $repoRoot . '/crates/shirabe-php-rpc/php/guards';
 $libRs = $repoRoot . '/crates/shirabe-php-rpc/src/lib.rs';
 $check = false;
 
@@ -24,21 +27,31 @@ foreach (array_slice($argv, 1) as $arg) {
         $reportPath = substr($arg, strlen('--report='));
     } elseif (str_starts_with($arg, '--stubs-dir=')) {
         $stubsDir = substr($arg, strlen('--stubs-dir='));
+    } elseif (str_starts_with($arg, '--guards-dir=')) {
+        $guardsDir = substr($arg, strlen('--guards-dir='));
     } elseif ($arg === '--check') {
         $check = true;
     } else {
-        fwrite(STDERR, "usage: generate-stubs [--composer-root=DIR] [--report=FILE] [--stubs-dir=DIR] [--check]\n");
+        fwrite(STDERR, "usage: generate-stubs [--composer-root=DIR] [--report=FILE] [--stubs-dir=DIR]"
+            . " [--guards-dir=DIR] [--check]\n");
         exit(2);
     }
 }
 
-$targets = [];
-foreach (file(__DIR__ . '/targets.list', FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) as $line) {
-    $line = trim($line);
-    if ($line !== '' && !str_starts_with($line, '#')) {
-        $targets[] = $line;
+/** @return list<string> */
+$readList = static function (string $path): array {
+    $entries = [];
+    foreach (file($path, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) as $line) {
+        $line = trim($line);
+        if ($line !== '' && !str_starts_with($line, '#')) {
+            $entries[] = $line;
+        }
     }
-}
+    return $entries;
+};
+
+$targets = $readList(__DIR__ . '/targets.list');
+$exemptions = $readList(__DIR__ . '/guard-exemptions.list');
 
 // Hand-written dual-mode classes (php/runtime/) resolve through the same worker autoloader as
 // the generated stubs; the generator must know them so they can serve as stub base classes and
@@ -61,9 +74,45 @@ if (is_dir($runtimeDir)) {
 sort($runtimeProvided);
 sort($runtimeFiles);
 
+$problems = [];
+$report = Report::load($reportPath);
+$project = new Project($composerRoot);
+
+// Every class the Rust side owns and neither a stub nor a runtime class shadows gets a guard, so
+// that the worker cannot fall through to the real implementation and run a second instance.
+// Exempt entries stay real because the worker has a mechanism that makes a native instance
+// correct; each one is justified where it is listed.
+$exempt = array_flip($exemptions);
+$guardTargets = [];
+foreach ($report->inCategories(['rust-proxy', 'rust-snapshot', 'unsupported']) as $fqcn) {
+    if (in_array($fqcn, $targets, true) || in_array($fqcn, $runtimeProvided, true)) {
+        continue;
+    }
+    if (isset($exempt[$fqcn])) {
+        unset($exempt[$fqcn]);
+        continue;
+    }
+    if ($report->kind($fqcn) !== 'class') {
+        $problems[] = "$fqcn is a {$report->kind($fqcn)} in a Rust-owned category; a guard can only"
+            . ' shadow a class';
+        continue;
+    }
+    $guardTargets[] = $fqcn;
+}
+foreach (array_keys($exempt) as $fqcn) {
+    $problems[] = "stale guard exemption in guard-exemptions.list: $fqcn needs no guard";
+}
+
 try {
-    $generator = new Generator($composerRoot, Report::load($reportPath), $targets, $runtimeProvided);
+    $generator = new Generator($composerRoot, $report, $targets, $runtimeProvided);
     $files = $generator->generate();
+    $guardGenerator = new GuardGenerator(
+        $project,
+        new NamePrinter(),
+        $guardTargets,
+        array_merge($targets, $runtimeProvided),
+    );
+    $guardFiles = $guardGenerator->generate();
 } catch (GenerationError $e) {
     foreach ($e->errors as $error) {
         fwrite(STDERR, "error: $error\n");
@@ -71,8 +120,6 @@ try {
     exit(1);
 }
 
-$problems = [];
-
 // Handoff classification of Composer\Console\Application's declared properties. The worker-side
 // runtime definition (php/runtime/Composer/Console/Application.php) hands off exactly the state
 // a plugin-visible application exposes; a property the upstream class declares and this table
@@ -87,7 +134,7 @@ $applicationPropertyTable = [
     'hasPluginCommands' => 'rust-local',    // Rust-side runtime state, never shared
     'logo' => 'static-config',              // static rendering data, the worker never needs it
 ];
-$applicationFile = (new Project($composerRoot))->sourceFor('Composer\\Console\\Application');
+$applicationFile = $project->sourceFor('Composer\\Console\\Application');
 $declaredProperties = [];
 foreach ($applicationFile->classLike->getProperties() as $property) {
     foreach ($property->props as $prop) {
@@ -105,14 +152,23 @@ foreach ($applicationPropertyTable as $name => $_) {
     }
 }
 
-$iterator = new RecursiveIteratorIterator(
-    new RecursiveDirectoryIterator($stubsDir, FilesystemIterator::SKIP_DOTS)
-);
-foreach ($iterator as $entry) {
-    if ($entry->isFile() && str_ends_with($entry->getFilename(), '.php')) {
-        $relative = substr($entry->getPathname(), strlen($stubsDir) + 1);
-        if (!isset($files[$relative])) {
-            $problems[] = "stale stub not covered by targets.list: $stubsDir/$relative";
+$generatedSets = [
+    [$stubsDir, $files, 'targets.list'],
+    [$guardsDir, $guardFiles, 'the classifier report'],
+];
+foreach ($generatedSets as [$dir, $generated, $source]) {
+    if (!is_dir($dir)) {
+        continue;
+    }
+    $iterator = new RecursiveIteratorIterator(
+        new RecursiveDirectoryIterator($dir, FilesystemIterator::SKIP_DOTS)
+    );
+    foreach ($iterator as $entry) {
+        if ($entry->isFile() && str_ends_with($entry->getFilename(), '.php')) {
+            $relative = substr($entry->getPathname(), strlen($dir) + 1);
+            if (!isset($generated[$relative])) {
+                $problems[] = "stale file not covered by $source: $dir/$relative";
+            }
         }
     }
 }
@@ -131,24 +187,26 @@ foreach ($runtimeFiles as $relative) {
     }
 }
 
-if ($check) {
-    foreach ($files as $relative => $content) {
-        $current = @file_get_contents("$stubsDir/$relative");
-        if ($current === false) {
-            $problems[] = "missing stub (regenerate): $stubsDir/$relative";
-        } elseif ($current !== $content) {
-            $problems[] = "stale stub (regenerate): $stubsDir/$relative";
+foreach ([[$stubsDir, $files, 'stubs'], [$guardsDir, $guardFiles, 'guards']] as [$dir, $generated, $what]) {
+    if ($check) {
+        foreach ($generated as $relative => $content) {
+            $current = @file_get_contents("$dir/$relative");
+            if ($current === false) {
+                $problems[] = "missing file (regenerate): $dir/$relative";
+            } elseif ($current !== $content) {
+                $problems[] = "stale file (regenerate): $dir/$relative";
+            }
         }
+        continue;
     }
-} else {
-    foreach ($files as $relative => $content) {
-        $path = "$stubsDir/$relative";
+    foreach ($generated as $relative => $content) {
+        $path = "$dir/$relative";
         if (!is_dir(dirname($path))) {
             mkdir(dirname($path), 0777, true);
         }
         file_put_contents($path, $content);
     }
-    fwrite(STDERR, count($files) . " stubs written to $stubsDir\n");
+    fwrite(STDERR, count($generated) . " $what written to $dir\n");
 }
 
 foreach ($problems as $problem) {
diff --git a/scripts/plugin-stub-generator/guard-exemptions.list b/scripts/plugin-stub-generator/guard-exemptions.list
new file mode 100644
index 00000000..90adcb20
--- /dev/null
+++ b/scripts/plugin-stub-generator/guard-exemptions.list
@@ -0,0 +1,14 @@
+# Classes the Rust side owns that the worker still resolves to the real Composer implementation,
+# so no guard is emitted for them. An entry belongs here only when the worker has a mechanism that
+# makes a natively constructed instance correct; without one the class must be guarded, or code
+# running here would silently work on an instance the Rust side never sees. One FQCN per line,
+# each with the mechanism that justifies it.
+
+# The wire codec revives values of this class from the object record serialize() writes for them
+# (php/runtime/Shirabe/MaterializedValue.php), so the real declaration has to stay loadable.
+Composer\Package\Link
+
+# Real Composer\Command code running in this worker constructs one (BaseCommand::initialize), and
+# the dual-mode Composer\EventDispatcher\Event (php/runtime/) carries a natively constructed event
+# to the Rust side as a P-table entity.
+Composer\Plugin\PreCommandRunEvent
diff --git a/scripts/plugin-stub-generator/src/Generator.php b/scripts/plugin-stub-generator/src/Generator.php
index dd62da60..0b8ef037 100644
--- a/scripts/plugin-stub-generator/src/Generator.php
+++ b/scripts/plugin-stub-generator/src/Generator.php
@@ -159,7 +159,7 @@ final class Generator
             return [];
         }
         $surface = [];
-        $parentFqcn = $class->extends === null ? null : $this->resolvedName($class->extends);
+        $parentFqcn = $class->extends === null ? null : SourceFile::resolvedName($class->extends);
         if ($parentFqcn !== null) {
             $surface = $this->surfaces[$parentFqcn] ?? $this->surfaceFromRealClass($parentFqcn);
         }
@@ -195,7 +195,7 @@ final class Generator
                 . '; only rust-proxy and contract classes can become proxy stubs';
         }
 
-        $parentFqcn = $class->extends === null ? null : $this->resolvedName($class->extends);
+        $parentFqcn = $class->extends === null ? null : SourceFile::resolvedName($class->extends);
         $isRoot = $parentFqcn === null;
         if ($parentFqcn !== null && !isset($this->targetSet[$parentFqcn])) {
             if (isset($this->runtimeSet[$parentFqcn])) {
@@ -348,7 +348,7 @@ final class Generator
         $header = "// Generated by scripts/plugin-stub-generator; do not edit by hand.\n"
             . "// Proxy stub for $fqcn: the public surface forwards to the Rust-side entity over RPC.";
         $text = "<?php\n\n$header\n\nnamespace {$file->namespace};\n\n";
-        $uses = $this->usedImports($file, $decl . "\n" . $body);
+        $uses = $file->importsUsedBy($decl . "\n" . $body);
         if ($uses !== '') {
             $text .= $uses . "\n\n";
         }
@@ -446,11 +446,11 @@ final class Generator
             }
             $out[] = $file;
             foreach ($file->classLike->extends as $parent) {
-                $visit($this->resolvedName($parent));
+                $visit(SourceFile::resolvedName($parent));
             }
         };
         foreach ($class->implements as $interface) {
-            $visit($this->resolvedName($interface));
+            $visit(SourceFile::resolvedName($interface));
         }
         return $out;
     }
@@ -527,23 +527,4 @@ final class Generator
         }
         return $fingerprint;
     }
-
-    /** The original file's imports, restricted to names the emitted stub actually uses. */
-    private function usedImports(SourceFile $file, string $emittedText): string
-    {
-        $kept = [];
-        foreach ($file->aliases as $alias => $fqcn) {
-            if (preg_match('/(?<![\\\\$\w])' . preg_quote($alias, '/') . '\b/', $emittedText) === 1) {
-                $kept[] = 'use ' . $fqcn
-                    . (str_ends_with($fqcn, '\\' . $alias) || $fqcn === $alias ? '' : " as $alias") . ';';
-            }
-        }
-        return implode("\n", $kept);
-    }
-
-    private function resolvedName(Name $name): string
-    {
-        $resolved = $name->getAttribute('resolvedName');
-        return $resolved instanceof Name ? $resolved->toString() : $name->toString();
-    }
 }
diff --git a/scripts/plugin-stub-generator/src/GuardGenerator.php b/scripts/plugin-stub-generator/src/GuardGenerator.php
new file mode 100644
index 00000000..e471f1a3
--- /dev/null
+++ b/scripts/plugin-stub-generator/src/GuardGenerator.php
@@ -0,0 +1,215 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Shirabe\PluginStubGenerator;
+
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassMethod;
+
+/**
+ * Emits the guard classes: same FQCN, same hierarchy and constants as the real Composer class,
+ * but every constructor and method raises an explicit error. They cover the classes whose entity
+ * the Rust side owns and that have no proxy stub, so the worker's autoloader can no longer fall
+ * through to the real implementation and run a second instance the Rust side never sees.
+ *
+ * A declaration-only reference (`instanceof`, `X::class`, a constant) keeps working; only running
+ * the code fails.
+ */
+final class GuardGenerator
+{
+    /** @var list<string> */
+    private array $errors = [];
+
+    /** @var array<string, true> */
+    private array $guardSet = [];
+
+    /** @var array<string, true> */
+    private array $providedSet = [];
+
+    /** @var list<string> `Ancestor::member` entries the class being emitted cannot redeclare */
+    private array $inheritedFinals = [];
+
+    /**
+     * @param list<string> $targets  FQCNs to emit a guard for
+     * @param list<string> $provided FQCNs the worker resolves to a proxy stub or a hand-written
+     *                               runtime class; a guard never reproduces their members, since
+     *                               those declarations already shadow the real class
+     */
+    public function __construct(
+        private readonly Project $project,
+        private readonly NamePrinter $printer,
+        private readonly array $targets,
+        array $provided,
+    ) {
+        foreach ($targets as $fqcn) {
+            $this->guardSet[$fqcn] = true;
+        }
+        foreach ($provided as $fqcn) {
+            $this->providedSet[$fqcn] = true;
+        }
+    }
+
+    /** @return array<string, string> relative guard path => file content */
+    public function generate(): array
+    {
+        $files = [];
+        foreach ($this->targets as $fqcn) {
+            $files[str_replace('\\', '/', $fqcn) . '.php'] = $this->emitClass($fqcn);
+        }
+        if ($this->errors !== []) {
+            throw new GenerationError($this->errors);
+        }
+        return $files;
+    }
+
+    private function emitClass(string $fqcn): string
+    {
+        $file = $this->project->sourceFor($fqcn);
+        $class = $file->classLike;
+        if (!$class instanceof Class_) {
+            $this->errors[] = "$fqcn is not a class";
+            return '';
+        }
+
+        // Constants and public static properties are compile-time data with no instance behind
+        // them; they are copied verbatim, visibility included, so that the references a guard is
+        // meant to keep working (`Link::TYPE_REQUIRE` and friends) resolve to the real values.
+        $data = [];
+        foreach ($class->getConstants() as $constant) {
+            $data[] = $file->verbatim($constant->getStartLine(), $constant->getEndLine());
+        }
+        foreach ($class->getProperties() as $property) {
+            if ($property->isPublic() && $property->isStatic()) {
+                $data[] = $file->verbatim($property->getStartLine(), $property->getEndLine());
+            }
+        }
+
+        $methods = [];
+        $this->inheritedFinals = [];
+        $closure = $this->methodClosure($fqcn);
+        if (!isset($closure['__construct'])) {
+            // Nothing in the hierarchy declares one, so PHP would hand out the implicit
+            // constructor. The guard declares its own to close that door.
+            $methods[] = "    public function __construct()\n    {\n"
+                . "        \\ShirabeUnsupportedClass::fail(self::class, '__construct');\n    }";
+        }
+        foreach ($closure as $lowerName => [$method, $declaringFile]) {
+            if ($method->isPrivate() || $lowerName === '__destruct') {
+                // A private method is reachable only from the code the guard replaces, and a
+                // destructor that throws would fire while an exception is already unwinding.
+                continue;
+            }
+            $methods[] = $this->renderMethod($class, $method, $declaringFile);
+        }
+
+        $decl = ($class->isAbstract() ? 'abstract ' : '') . ($class->isFinal() ? 'final ' : '')
+            . 'class ' . $class->name?->toString();
+        if ($class->extends !== null) {
+            $decl .= ' extends ' . $this->printer->renderName($class->extends, $file);
+        }
+        $interfaces = array_map(fn (Name $n): string => $this->printer->renderName($n, $file), $class->implements);
+        if ($interfaces !== []) {
+            $decl .= ' implements ' . implode(', ', $interfaces);
+        }
+
+        $body = implode("\n\n", array_merge($data === [] ? [] : [implode("\n", $data)], $methods));
+
+        $header = "// Generated by scripts/plugin-stub-generator; do not edit by hand.\n"
+            . "// Guard for $fqcn.\n"
+            . "// The Rust side owns this class and the worker has no proxy for it, so this\n"
+            . "// declaration shadows the real one: the constants and the hierarchy stay, while\n"
+            . "// constructing it or calling anything on it raises an explicit error.";
+        foreach ($this->inheritedFinals as $member) {
+            $header .= "\n// $member() is final, so it keeps running the real implementation here.";
+        }
+        $text = "<?php\n\n$header\n\nnamespace {$file->namespace};\n\n";
+        $uses = $file->importsUsedBy($decl . "\n" . $body);
+        if ($uses !== '') {
+            $text .= $uses . "\n\n";
+        }
+        return $text . $decl . "\n{\n" . ($body === '' ? '' : $body . "\n") . "}\n";
+    }
+
+    /**
+     * Every method a guard must redeclare: its own (traits included), plus the ones it would
+     * otherwise inherit from real ancestors. The walk stops at an ancestor that is guarded or
+     * shadowed by a stub, since that declaration carries the members from there on up.
+     *
+     * @return array<string, array{ClassMethod, SourceFile}> lowercased name => method and the
+     *                                                       file its signature is written in
+     */
+    private function methodClosure(string $fqcn): array
+    {
+        $file = $this->project->sourceFor($fqcn);
+        $class = $file->classLike;
+        $methods = [];
+        foreach ($class->getMethods() as $method) {
+            $methods[strtolower($method->name->toString())] ??= [$method, $file];
+        }
+        foreach ($class->getTraitUses() as $traitUse) {
+            foreach ($traitUse->traits as $trait) {
+                foreach ($this->methodClosure(SourceFile::resolvedName($trait)) as $name => $entry) {
+                    $methods[$name] ??= $entry;
+                }
+            }
+        }
+        $parent = $class instanceof Class_ && $class->extends !== null
+            ? SourceFile::resolvedName($class->extends)
+            : null;
+        // A PHP builtin ancestor (FilterIterator, ...) has no source file to read; its methods
+        // work on internal state that only its own constructor sets up, which the guard blocks.
+        $isInternal = $parent !== null && class_exists($parent, false)
+            && (new \ReflectionClass($parent))->isInternal();
+        if ($parent !== null && !$isInternal
+            && !isset($this->guardSet[$parent]) && !isset($this->providedSet[$parent])) {
+            foreach ($this->methodClosure($parent) as $name => $entry) {
+                if (isset($methods[$name])) {
+                    continue;
+                }
+                if ($entry[0]->isFinal()) {
+                    // PHP refuses the redeclaration, so this member keeps running the real
+                    // implementation; emitClass records it in the guard's header.
+                    $this->inheritedFinals[] = $parent . '::' . $entry[0]->name->toString();
+                    continue;
+                }
+                $methods[$name] = $entry;
+            }
+        }
+        return $methods;
+    }
+
+    private function renderMethod(Class_ $class, ClassMethod $method, SourceFile $target): string
+    {
+        $name = $method->name->toString();
+        $params = [];
+        foreach ($method->params as $param) {
+            $rendered = '';
+            if ($param->type !== null) {
+                $rendered = $this->printer->renderType($param->type, $target) . ' ';
+            }
+            // A promoted constructor property declares state the guard has no use for; the
+            // parameter itself is kept so the signature a caller sees does not change.
+            $rendered .= ($param->byRef ? '&' : '') . ($param->variadic ? '...' : '') . '$' . $param->var->name;
+            if ($param->default !== null) {
+                $rendered .= ' = ' . $this->printer->renderExpr($param->default, $target);
+            }
+            $params[] = $rendered;
+        }
+
+        $abstract = $method->isAbstract() && $class->isAbstract();
+        $returnType = $this->printer->renderType($method->returnType, $target);
+        $signature = ($abstract ? 'abstract ' : '') . ($method->isFinal() ? 'final ' : '')
+            . ($method->isPublic() ? 'public' : 'protected')
+            . ($method->isStatic() ? ' static' : '')
+            . ' function ' . ($method->byRef ? '&' : '') . $name . '(' . implode(', ', $params) . ')'
+            . ($returnType === '' ? '' : ": $returnType");
+        if ($abstract) {
+            return "    $signature;";
+        }
+        return "    $signature\n    {\n"
+            . "        \\ShirabeUnsupportedClass::fail(self::class, '$name');\n    }";
+    }
+
+}
diff --git a/scripts/plugin-stub-generator/src/Report.php b/scripts/plugin-stub-generator/src/Report.php
index 92e0565e..758a1768 100644
--- a/scripts/plugin-stub-generator/src/Report.php
+++ b/scripts/plugin-stub-generator/src/Report.php
@@ -7,8 +7,11 @@ namespace Shirabe\PluginStubGenerator;
 /** The classifier report (scripts/plugin-class-classifier/report.json). */
 final class Report
 {
-    /** @param array<string, string> $categories fqcn => category */
-    private function __construct(private readonly array $categories)
+    /**
+     * @param array<string, string> $categories fqcn => category
+     * @param array<string, string> $kinds      fqcn => class / interface / trait / enum
+     */
+    private function __construct(private readonly array $categories, private readonly array $kinds)
     {
     }
 
@@ -24,14 +27,38 @@ final class Report
             throw new GenerationError(["$path records classification violations; fix the classifier lists first"]);
         }
         $categories = [];
+        $kinds = [];
         foreach ($data['classes'] as $class) {
             $categories[$class['fqcn']] = $class['category'];
+            $kinds[$class['fqcn']] = $class['kind'];
         }
-        return new self($categories);
+        return new self($categories, $kinds);
     }
 
     public function category(string $fqcn): ?string
     {
         return $this->categories[$fqcn] ?? null;
     }
+
+    public function kind(string $fqcn): ?string
+    {
+        return $this->kinds[$fqcn] ?? null;
+    }
+
+    /**
+     * The FQCNs of the given categories, in report order.
+     *
+     * @param  list<string> $categories
+     * @return list<string>
+     */
+    public function inCategories(array $categories): array
+    {
+        $out = [];
+        foreach ($this->categories as $fqcn => $category) {
+            if (in_array($category, $categories, true)) {
+                $out[] = $fqcn;
+            }
+        }
+        return $out;
+    }
 }
diff --git a/scripts/plugin-stub-generator/src/SourceFile.php b/scripts/plugin-stub-generator/src/SourceFile.php
index 771e83a8..e20bf00f 100644
--- a/scripts/plugin-stub-generator/src/SourceFile.php
+++ b/scripts/plugin-stub-generator/src/SourceFile.php
@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Shirabe\PluginStubGenerator;
 
+use PhpParser\Node\Name;
 use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\Node\Stmt\GroupUse;
 use PhpParser\Node\Stmt\Namespace_;
@@ -83,4 +84,24 @@ final class SourceFile
     {
         return implode("\n", array_slice($this->lines, $startLine - 1, $endLine - $startLine + 1));
     }
+
+    /** This file's imports, restricted to the names the emitted text actually uses. */
+    public function importsUsedBy(string $emittedText): string
+    {
+        $kept = [];
+        foreach ($this->aliases as $alias => $fqcn) {
+            if (preg_match('/(?<![\\\\$\w])' . preg_quote($alias, '/') . '\b/', $emittedText) === 1) {
+                $kept[] = 'use ' . $fqcn
+                    . (str_ends_with($fqcn, '\\' . $alias) || $fqcn === $alias ? '' : " as $alias") . ';';
+            }
+        }
+        return implode("\n", $kept);
+    }
+
+    /** The FQCN a Name node resolved to, the NameResolver having left the node itself alone. */
+    public static function resolvedName(Name $name): string
+    {
+        $resolved = $name->getAttribute('resolvedName');
+        return $resolved instanceof Name ? $resolved->toString() : $name->toString();
+    }
 }