Concurrent PHP,
done right.

// Class-based actors with lifecycle hooks
// and PSR-11 dependency injection.

final class OrderProcessor extends AbstractActor
{
    public function __construct(
        private readonly PaymentGateway $payments,
        private readonly Inventory $inventory,
    ) {}

    public function onPreStart(ActorContext $ctx): void
    {
        $ctx->log()->info('OrderProcessor started');
    }

    public function handle(
        ActorContext $ctx, object $message,
    ): Behavior {
        if ($message instanceof ProcessOrder) {
            $this->payments->charge($message->order);
            $this->inventory->reserve($message->items);
            $message->replyTo->tell(new OrderConfirmed(
                orderId: $message->orderId,
            ));
        }

        return Behavior::same();
    }
}

// Spawn from your DI container
$ref = $system->spawn(
    Props::fromContainer($container, OrderProcessor::class),
    'order-processor',
);

// Actors can buffer messages during initialization.
// When ready, unstash and process them in order.

$initializing = Behavior::receive(
    static function (ActorContext $ctx, object $msg)
        use ($ready): Behavior
    {
        if ($msg instanceof DatabaseReady) {
            // Connection established. Process buffered work.
            $ctx->unstashAll();
            return $ready;
        }

        // Not ready yet. Buffer this message.
        $ctx->stash();
        return Behavior::same();
    },
);

$ref = $system->spawn(Props::fromBehavior($initializing), 'db-writer');

// These arrive before the database is ready.
// They're stashed, then replayed in order.
$ref->tell(new WriteRecord($data1));
$ref->tell(new WriteRecord($data2));
$ref->tell(new DatabaseReady($connection));

// One machine, all CPU cores. Actors span processes transparently.
// Same ActorRef API -- senders don't know if it's local or remote.

$cluster = ClusterBootstrap::create(
    ClusterConfig::withWorkers(16),
)
->onWorkerStart(function (ClusterNode $node): void {
    // Each worker runs an independent ActorSystem.
    // The hash ring decides which worker owns which actor.
    $node->spawn(
        Props::fromBehavior($orderBehavior),
        'order-processor',
    );
})
->run();

// Cross-worker messaging uses Unix domain sockets.
// 255K msgs/sec per worker pair. Zero config.