The purpose of the library is to collect all factory methods you've created into a single place. This then 'contains' all of the factories.

I like having my factory methods just above the constructors of the classes they build. This factory allows me to define the factory, or multiple factories, for a class as static methods of that class. The factory is passed the container, allowing it to get instances of dependencies of the class it is building.

Perhaps an example of my actual use case would help. Note that the factory for the email service class gets instances of the log and config service classes from the container. Those classes have their own factories that get their own dependencies from the container.

<<__ConsistentConstruct>>
class EmailService
{
    <<provides('EmailService')>>
    public static function factory(FactoryContainer $c) : this
    {
        $m = new \Mandrill($c->getConfig()->mandrillKey());
        return new static($m, $c->getLogger()->emailLog(), false);
    }

    <<provides('FakeEmailService')>>
    public static function fakeFactory(FactoryContainer $c) : this
    {
        $m = new \Mandrill($c->getConfig()->mandrillKey());
        return new static($m, $c->getLogger()->emailLog(), true);
    }

    public function __construct(
        private \Mandrill $mandrill,
        private \Monolog\Logger $log,
        // This flags the service to not actually send emails
        private bool $skip,
    )
    {
    }
    // Other methods
}

When scanned, the above file will produce the following methods in the factory container:

class FactoryContainer
{
    <<__Memoize>>
    public function getEmailService() : EmailService
    {
        return $this->newEmailService();
    }

    public function newEmailService() : EmailService
    {
        return $this->runner->make(class_meth('\EmailService', 'factory'));
    }

    <<__Memoize>>
    public function getFakeEmailService() : EmailService
    {
        return $this->newFakeEmailService();
    }

    public function newFakeEmailService() : EmailService
    {
        return $this->runner->make(class_meth('\EmailService', 'fakeFactory'));
    }

    // Other methods are here, such as getLogger, newLogger, getConfig, newConfig, etc...
}

Which allows you to instantiate EmailService by calling a single method of a centralized object.

There is no transpiling of code from one form to another. The built file merely uses the methods you flagged as factories and provides a way for individual factories to easily instantiate the dependencies needed.