class MyTest
{
    use ProphecyTrait;
    use ProphecyTraitReadonlyHack {
        ProphecyTraitReadonlyHack::prophesize insteadof ProphecyTrait;
    }

    // ...
}

// ProphecyTraitReadonlyHack.php

use MyApp\Prophecy\Prophet;
use MyApp\Prophecy\ClassCodeGenerator;
use Prophecy\Doubler\Generator\ClassCodeGenerator as OriginalClassCodeGenerator;
use Prophecy\PhpUnit\ProphecyTrait;
use Prophecy\Prophecy\ObjectProphecy;

/**
 * Read-only classes throw an error when using Prophecy. This trait overrides
 * Prophecy's {@link OriginalClassCodeGenerator ClassCodeGenerator} with its own
 * {@link ClassCodeGenerator}, which fixes the issue.
 *
 * @mixin ProphecyTrait
 */
trait ProphecyTraitReadonlyHack
{
    private ?Prophet $modifiedProphet = null;

    protected function prophesize(?string $classOrInterface = null): ObjectProphecy
    {
        return $this->getModifiedProphet()->prophesize($classOrInterface);
    }

    private function getModifiedProphet(): Prophet
    {
        if (!$this->modifiedProphet) {
            $this->prophet = new Prophet();
        }

        return $this->prophet;
    }
}

// Prophet.php

use MyApp\Prophecy\ClassCodeGenerator;
use MyApp\Utils\ClassUtils;
use Prophecy\Doubler\Doubler;
use Prophecy\Doubler\Generator\ClassCreator;
use Prophecy\Prophecy\RevealerInterface;
use Prophecy\Prophet as OriginalProphet;
use Prophecy\Util\StringUtil;

class Prophet extends OriginalProphet
{
    public function __construct(
        Doubler $doubler = null,
        RevealerInterface $revealer = null,
        StringUtil $util = null,
    ) {
        parent::__construct($doubler, $revealer, $util);

        // ClassUtils = Reflection helper

        $doubler = ClassUtils::getPropertyValue($this, 'doubler');

        ClassUtils::setPropertyValue(
            $this,
            'creator',
            new ClassCreator(new ClassCodeGenerator()),
        );

        ClassUtils::setPropertyValue($this, 'doubler', $doubler);
    }
}

// ClassCodeGenerator.php

use Prophecy\Doubler\Generator\ClassCodeGenerator as OriginalClassCodeGenerator;
use Prophecy\Doubler\Generator\Node;

class ClassCodeGenerator extends OriginalClassCodeGenerator
{
    public function generate($classname, Node\ClassNode $class): string
    {
        $code = parent::generate($classname, $class);

        if (str_contains($code, 'readonly class')
            && str_contains($code, 'private $objectProphecyClosure;')
        ) {
            $code = str_replace(
                '->objectProphecyClosure',
                '->objectProphecyClosureContainer->closure',
                $code,
            );

            $code = str_replace(
                'private $objectProphecyClosure;',
                'private \MyApp\Prophecy\ObjectProphecyClosureContainer $objectProphecyClosureContainer;',
                $code,
            );

            // Replace: __construct(...) { ... }
            // With: __construct(...) { $this->objectProphecyClosure = new ObjectProphecyClosureContainer; ... }
            $code = preg_replace(
                '/__construct\([^)]*\) \{/',
                '__construct($1) { $this->objectProphecyClosureContainer = new \Bite\Test\App\TestBundle\Prophecy\ObjectProphecyClosureContainer; ',
                $code
            );
        }

        return $code;
    }
}

// ObjectProphecyClosureContainer.php

class ObjectProphecyClosureContainer
{
    public mixed $closure = null;
}

// ClassUtils.php

use ReflectionClass;
use ReflectionException;
use ReflectionProperty;

class ClassUtils
{
    public static function getPropertyValue(
        object $subject,
        string $propertyName,
    ): mixed {
        $property = self::findProperty($subject, $propertyName);

        return $property->getValue($subject);
    }

    public static function setPropertyValue(
        object $subject,
        string $propertyName,
        mixed $value,
    ): void {
        $property = self::findProperty($subject, $propertyName);

        $property->setValue($subject, $value);
    }

    private static function findProperty(
        object $subject,
        string $propertyName,
    ): ReflectionProperty {
        $class = new ReflectionClass($subject);
        $iterateClass = $class;

        while ($iterateClass) {
            if ($iterateClass->hasProperty($propertyName)) {
                return $iterateClass->getProperty($propertyName);
            }

            $iterateClass = $iterateClass->getParentClass();
        }

        throw new ReflectionException(sprintf(
            'Property %s::$%s does not exist',
            $class->getName(),
            $propertyName
        ));
    }
}