Plugin Architecture

// Transient binding - new instance every time
public function transient(string $abstract, mixed $concrete = null): void

// Singleton binding - same instance every time
public function singleton(string $abstract, mixed $concrete = null): void

// Register an existing instance
public function instance(string $abstract, mixed $instance): void

private function resolveDependencies(array $params, array $providedParams): array
{
    $dependencies = [];

    foreach ($params as $param) {
        $name = $param->getName();

        // Use provided parameter if available
        if (array_key_exists($name, $providedParams)) {
            $dependencies[] = $providedParams[$name];
            continue;
        }

        $type = $param->getType();

        // Handle anything that is not a named or built-in type.
        if (! $type instanceof ReflectionNamedType || $type->isBuiltin()) {
            $dependencies[] = $this->resolveNonTyped($param);
            continue;
        }

        // Resolve typed dependency.
        $className = $type->getName();

        // If class is registered with the container, resolve it.
        if ($this->has($className)) {
            $dependencies[] = $this->resolve($className);
            continue;
        }

        // If the class exists, resolve it.
        if (class_exists($className)) {
            $dependencies[] = $this->make($className);
        }
    }

    return $dependencies;
}

abstract class ServiceProvider
{
    public function __construct(protected readonly Container $container)
    {}

    public function register(): void
    {
        // Default empty implementation - override if needed.
    }
}

final class ContentServiceProvider extends ServiceProvider implements Bootable
{
    public function register(): void
    {
        $this->container->singleton(Album::class);
        $this->container->singleton(Artist::class);
        $this->container->singleton(Genre::class);
    }

    public function boot(): void
    {
        $this->container->get(Album::class)->boot();
        $this->container->get(Artist::class)->boot();
        $this->container->get(Genre::class)->boot();
    }
}

public function __construct(protected readonly Container $container)
{
    // Register default bindings and service providers.
    $this->registerDefaultBindings();
    $this->registerDefaultProviders();

    // Allow third-party devs to register service providers.
    if (static::NAMESPACE !== '') {
        do_action(static::NAMESPACE . '/register', $this);
    }
}

protected function registerDefaultProviders(): void
{
    foreach (static::PROVIDERS as $provider) {
        $this->register($provider);
    }
}

final class Plugin extends Application
{
    protected const NAMESPACE = 'bifrost/music';

    protected const PROVIDERS = [
        ContentServiceProvider::class,
        EditorServiceProvider::class
    ];
}

public static function init(): void
{
    plugin();
}

function plugin(): Application
{
    static $plugin;

    if (! $plugin instanceof Plugin) {
        $plugin = new Plugin(new ServiceContainer());
    }

    return $plugin;
}

public static function boot(): void
{
    plugin()->boot();
}

public function boot(): void
{
    foreach ($this->serviceProviders as $provider) {
        if ($provider instanceof Bootable) {
            $provider->boot();
        }
    }

    // Allow third-party devs access to hook in after booting.
    if (static::NAMESPACE !== '') {
        do_action(static::NAMESPACE . '/booted', $this);
    }
}

interface Bootable
{
    public function boot(): void;
}

public function boot(): void
{
    // Register post types.
    add_action('init', $this->register(...));

    // Filter the "enter title here" text.
    add_filter('enter_title_here', $this->enterTitleHere(...), 10, 2);

    // Filter the bulk and post updated messages.
    add_filter('bulk_post_updated_messages', $this->bulkPostUpdatedMessages(...), 5, 2);
    add_filter('post_updated_messages', $this->postUpdatedMessages(...), 5);
}

do_action('bifrost/music/register', $this);

add_action('bifrost/music/register', function($app) {
    $app->register(MyCustomServiceProvider::class);
});

do_action('bifrost/music/booted', $this);

add_action('bifrost/music/booted', function($app) {
    // All services are now available
    $container = $app->container();
});