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

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

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

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

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

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../php/guards/Composer/Util/AuthHelper.php        |  45 +++++
 .../php/guards/Composer/Util/Bitbucket.php         |  42 ++++
 .../php/guards/Composer/Util/ConfigValidator.php   |  27 +++
 .../php/guards/Composer/Util/Filesystem.php        | 167 ++++++++++++++++
 .../php/guards/Composer/Util/Git.php               | 100 ++++++++++
 .../php/guards/Composer/Util/GitHub.php            |  52 +++++
 .../php/guards/Composer/Util/GitLab.php            |  40 ++++
 .../guards/Composer/Util/Http/CurlDownloader.php   |  37 ++++
 .../php/guards/Composer/Util/Http/CurlResponse.php |  22 +++
 .../php/guards/Composer/Util/Http/Response.php     |  57 ++++++
 .../php/guards/Composer/Util/HttpDownloader.php    |  86 ++++++++
 .../php/guards/Composer/Util/Loop.php              |  39 ++++
 .../php/guards/Composer/Util/Perforce.php          | 219 +++++++++++++++++++++
 .../php/guards/Composer/Util/Platform.php          |  92 +++++++++
 .../php/guards/Composer/Util/ProcessExecutor.php   | 114 +++++++++++
 .../php/guards/Composer/Util/RemoteFilesystem.php  |  85 ++++++++
 .../php/guards/Composer/Util/Svn.php               |  82 ++++++++
 17 files changed, 1306 insertions(+)
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php
 create mode 100644 crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php

(limited to 'crates/shirabe-php-rpc/php/guards/Composer/Util')

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');
+    }
+}
-- 
cgit v1.3.1-4-g156e