Add plugin dependency validation and finish lifecycle

[waynemwashuma]

Objective

Introduces explicit plugin dependency declarations and lifecycle validation across the engine. This ensures plugins fail early when required plugins are missing and provides a final initialization stage after all plugins have been registered.

Solution

The plugin system now allows plugins to declare their dependencies through requires() and perform post-registration setup through finish().

App.run() registers all plugins, validates their dependencies, invokes their finish callbacks, and then applies queued hooks, aliases, and resources.

Root Cause

Plugin dependencies were previously implicit. A plugin could be registered without the plugins it relied on, causing failures later during system execution or resource access.

The registry also did not create a stack trace for duplicate plugins or expose a lifecycle stage for initialization that depends on all plugin registrations being complete.

Why This Approach

This solution was chosen because:

• Dependencies remain colocated with the plugins that require them.
• Validation occurs after registration, allowing plugins to register additional plugins dynamically.
• Missing dependencies are reported before systems begin running.
• Registration traces make duplicate-plugin errors easier to diagnose.
• The finish stage supports setup that requires the complete plugin graph.

Showcase

Before

class PhysicsPlugin extends Plugin {
  register(app) {
    // Assumes the required plugins are present.
  }
}

Missing dependencies were not detected during application initialization.

After

class PhysicsPlugin extends Plugin {
  requires() {
    return [
      typeid(CorePlugin),
      typeid(ReflectPlugin),
      typeid(MathPlugin)
    ]
  }

  finish(app) {
    // Runs after all plugins are registered and validated.
  }
}

Running an application without a declared dependency now produces an error identifying the requiring plugin and the missing plugin.

Migration Guide

Custom plugins can declare their dependencies by implementing requires():

requires() {
  return [typeid(RequiredPlugin)]
}

Plugins that require post-registration initialization can implement finish(app).

Applications must register every dependency declared by their plugins before calling run(). Duplicate plugin registrations must also be removed because they now throw an error.

Checklist

• I have updated the documentation accordingly.
• I have added tests to cover my changes.