@downdraft/engine 0.0.0 → 0.1.0

package/core/src/module/host.ts

@@ -0,0 +1,451 @@
+import type { ComponentId } from "../ecs/component";
+import { getComponentId } from "../ecs/component";
+import type { ResourceToken } from "../ecs/resource";
+import type { Stage, System, SystemFn } from "../ecs/system";
+import type { World } from "../ecs/world";
+import { createLogger } from "../util/logger";
+import type { CrossThreadToken, ModuleThreadInfo, ThreadTag } from "./cross-thread";
+import { assertNoDuplicate, assertRequired, isStrict, warnLeak } from "./diagnostics";
+import type { Module, ModuleContext, ModuleDevToolsAPI, SABChannel } from "./module";
+import { ModuleRegistry } from "./registry";
+import { TsModuleLoader } from "./ts-loader";
+
+const log = createLogger();
+
+interface ActiveModule {
+  plugin: Module;
+  disposeFns: Array<() => void>;
+  sabChannels: Map<string, SharedArrayBuffer>;
+  providedKeys: Set<string>;
+  /** Names of systems this module registered — removed from the schedule on unload. */
+  systemNames: string[];
+}
+
+interface ResourceEntry {
+  token: ResourceToken<unknown>;
+  value: unknown;
+}
+
+export class ModuleHost implements ModuleContext {
+  private world: World;
+  private registry: ModuleRegistry;
+  private tsLoader: TsModuleLoader;
+  private active: Map<string, ActiveModule> = new Map();
+  private pending: Map<string, Module> = new Map();
+  private migrations: Map<number, (data: unknown) => unknown> = new Map();
+  private _devtools: ModuleDevToolsAPI | null = null;
+  /** Typed resource store: tokenKey → { token, value } */
+  private resources: Map<string, ResourceEntry> = new Map();
+  /** Reverse map: tokenKey → provider plugin name */
+  private providers: Map<string, string> = new Map();
+
+  constructor(world: World, registry?: ModuleRegistry) {
+    this.world = world;
+    this.registry = registry ?? new ModuleRegistry();
+    this.tsLoader = new TsModuleLoader(this.registry);
+  }
+
+  /**
+   * Inject the DevTools API. Called by the game bootstrap after
+   * `initDevTools()` so plugins can self-register debug panels via
+   * `ctx.devtools.registerPanel(...)` during their `register()` lifecycle.
+   */
+  setDevToolsAPI(api: ModuleDevToolsAPI): void {
+    this._devtools = api;
+  }
+
+  get devtools(): ModuleDevToolsAPI {
+    // Return the injected API, or a no-op stub if not set (so plugins that
+    // call ctx.devtools.registerPanel() don't crash if devtools isn't wired).
+    return this._devtools ?? NoopDevToolsAPI;
+  }
+
+  getRegistry(): ModuleRegistry {
+    return this.registry;
+  }
+
+  async loadModule(pluginPath: string): Promise<Module> {
+    const plugin = await this.tsLoader.load(pluginPath);
+    this.activateModule(plugin);
+    return plugin;
+  }
+
+  /**
+   * Register and immediately activate a plugin.
+   * For batch registration with dependency-ordered activation,
+   * use `registerModuleDeferred()` + `activateAll()` instead.
+   */
+  registerModule(plugin: Module): void {
+    this.registry.register(plugin);
+    this.validateModule(plugin);
+    this.activateModule(plugin);
+  }
+
+  /**
+   * Register a plugin without activating it.
+   * Call `activateAll()` after all plugins are registered
+   * to activate them in dependency-resolved order (topological sort).
+   */
+  registerModuleDeferred(plugin: Module): void {
+    this.registry.register(plugin);
+    this.pending.set(plugin.name, plugin);
+  }
+
+  /**
+   * Activate all plugins registered via `registerModuleDeferred()`
+   * in dependency-resolved order (topological sort).
+   * Plugins with no dependencies are activated first.
+   *
+   * In DOWNDRAFT_STRICT mode, validates the full dependency graph
+   * (provides/requires) before activating any plugin.
+   */
+  activateAll(): void {
+    this.validateGraph();
+    const order = this.registry.resolveOrder();
+    for (let i = 0; i < order.length; i++) {
+      const name = order[i];
+      if (this.pending.has(name) && !this.active.has(name)) {
+        const plugin = this.pending.get(name)!;
+        this.pending.delete(name);
+        this.activateModule(plugin);
+      }
+    }
+  }
+
+  /**
+   * Register and activate multiple plugins in dependency-resolved order.
+   * This is the standard batch registration pattern — equivalent to
+   * calling `registerModuleDeferred()` for each plugin followed by
+   * `activateAll()`. Use this when multiple plugins have interdependencies
+   * (via `provides`/`requires` typed tokens).
+   */
+  useModules(plugins: Module[]): void {
+    for (let i = 0; i < plugins.length; i++) {
+      this.registerModuleDeferred(plugins[i]);
+    }
+    this.activateAll();
+  }
+
+  /**
+   * Validate a single plugin's requires against already-active providers.
+   * Used for immediate-activation (registerModule) path.
+   */
+  private validateModule(plugin: Module): void {
+    if (!isStrict()) return;
+    if (!plugin.requires) return;
+    const selfProvides = new Set(plugin.provides?.map((t) => t.key) ?? []);
+    plugin.requires.forEach((token) => {
+      if (!this.providers.has(token.key) && !selfProvides.has(token.key)) {
+        assertRequired(this.providers, token, plugin.name);
+      }
+    });
+  }
+
+  /**
+   * Validate the full dependency graph across all pending + active plugins.
+   * Called before batch activation in activateAll().
+   */
+  private validateGraph(): void {
+    if (!isStrict()) return;
+    // Build a complete providers map from all pending + active plugins
+    const allProviders = new Map<string, string>();
+    for (const [name, active] of this.active.entries()) {
+      (active.plugin.provides ?? []).forEach((token) => {
+        allProviders.set(token.key, name);
+      });
+    }
+    for (const [name, plugin] of this.pending.entries()) {
+      (plugin.provides ?? []).forEach((token) => {
+        if (allProviders.has(token.key)) {
+          throw new Error(
+            `Module "${name}" provides "${token.key}" but it is already provided by "${allProviders.get(token.key)}". ` +
+              `Duplicate provides are not allowed.`,
+          );
+        }
+        allProviders.set(token.key, name);
+      });
+    }
+    // Check all requires
+    for (const [name, plugin] of this.pending.entries()) {
+      if (!plugin.requires) continue;
+      plugin.requires.forEach((token) => {
+        if (!allProviders.has(token.key)) {
+          assertRequired(allProviders, token, name);
+        }
+      });
+    }
+  }
+
+  private activateModule(plugin: Module): void {
+    const active: ActiveModule = {
+      plugin,
+      disposeFns: [],
+      sabChannels: new Map(),
+      providedKeys: new Set(),
+      systemNames: [],
+    };
+    this.active.set(plugin.name, active);
+    this.currentModuleName = plugin.name;
+    try {
+      plugin.register(this);
+    } catch (err) {
+      // Roll back partial activation: the module must not stay "active"
+      // with half-wired resources. Clean up anything it provided or
+      // registered for disposal, then re-throw so the caller sees it.
+      for (const key of active.providedKeys.values()) {
+        this.resources.delete(key);
+        this.providers.delete(key);
+      }
+      for (let i = active.disposeFns.length - 1; i >= 0; i--) {
+        try {
+          active.disposeFns[i]();
+        } catch (disposeErr) {
+          log.error("ModuleHost", `Dispose error rolling back plugin "${plugin.name}": ${disposeErr}`);
+        }
+      }
+      // Remove systems the module registered before throwing.
+      active.systemNames.forEach((sysName) => {
+        this.world.schedule.removeSystem(sysName);
+      });
+      this.active.delete(plugin.name);
+      throw err;
+    } finally {
+      // Clear the attribution context — any provide/onDispose/registerSystem
+      // call made outside a register() lifecycle (async callbacks, game code)
+      // must not be silently attributed to this module.
+      this.currentModuleName = "";
+    }
+  }
+
+  unloadModule(name: string): void {
+    const active = this.active.get(name);
+    if (!active) return;
+    // Leak detection: warn if plugin provided resources / SAB channels
+    // but registered no dispose fns.
+    if (isStrict()) {
+      warnLeak(name, {
+        providedCount: active.providedKeys.size,
+        sabCount: active.sabChannels.size,
+        disposeFnCount: active.disposeFns.length,
+      });
+    }
+    // Clean up provided resources
+    for (const key of active.providedKeys.values()) {
+      this.resources.delete(key);
+      this.providers.delete(key);
+    }
+    for (let i = active.disposeFns.length - 1; i >= 0; i--) {
+      try {
+        active.disposeFns[i]();
+      } catch (err) {
+        log.error("ModuleHost", `Dispose error in plugin "${name}": ${err}`);
+      }
+    }
+    // Remove the module's systems from the world schedule — otherwise they
+    // keep running after unload (e.g. duplicated per hot-reload swap).
+    active.systemNames.forEach((sysName) => {
+      this.world.schedule.removeSystem(sysName);
+    });
+    this.active.delete(name);
+    this.pending.delete(name);
+    this.registry.unregister(name);
+  }
+
+  getModule(name: string): Module | undefined {
+    return this.registry.get(name);
+  }
+
+  listModules(): string[] {
+    return this.registry.getAll().map((p) => p.name);
+  }
+
+  /**
+   * Produce a thread-tagged snapshot of all active modules for the
+   * cross-thread report + doctor panel. `thread` identifies which side
+   * this host lives on ("sim" | "renderer").
+   *
+   * Tokens created via `crossThreadToken()` carry a `__thread` tag; the
+   * snapshot records it in `tokenThreads` so `buildCrossThreadReport()`
+   * can flag tokens provided on the wrong thread.
+   */
+  snapshot(thread: ThreadTag): ModuleThreadInfo[] {
+    const out: ModuleThreadInfo[] = [];
+    for (const [name, active] of this.active.entries()) {
+      const plugin = active.plugin;
+      const tokenThreads: Record<string, ThreadTag> = {};
+      const collectTags = (tokens?: ResourceToken<unknown>[]) => {
+        (tokens ?? []).forEach((t) => {
+          const tag = (t as CrossThreadToken<unknown>).__thread;
+          if (tag) tokenThreads[t.key] = tag;
+        });
+      };
+      collectTags(plugin.provides);
+      collectTags(plugin.requires);
+      out.push({
+        name,
+        version: plugin.version,
+        thread,
+        provides: (plugin.provides ?? []).map((t) => t.key),
+        requires: (plugin.requires ?? []).map((t) => t.key),
+        active: true,
+        tokenThreads: Object.keys(tokenThreads).length > 0 ? tokenThreads : undefined,
+      });
+    }
+    return out;
+  }
+
+  disposeAll(): void {
+    const order = this.registry.resolveOrder();
+    for (let i = order.length - 1; i >= 0; i--) {
+      this.unloadModule(order[i]);
+    }
+    // Clean up unattributed registrations (made outside a register()
+    // lifecycle — they were tracked globally so they don't leak).
+    this.unattributedSystemNames.forEach((sysName) => {
+      this.world.schedule.removeSystem(sysName);
+    });
+    this.unattributedSystemNames.length = 0;
+    for (let i = this.unattributedDisposeFns.length - 1; i >= 0; i--) {
+      try {
+        this.unattributedDisposeFns[i]();
+      } catch (err) {
+        log.error("ModuleHost", `Unattributed dispose error: ${err}`);
+      }
+    }
+    this.unattributedDisposeFns.length = 0;
+  }
+
+  registerComponent<T>(name: string, _schema: T): ComponentId {
+    return getComponentId(name);
+  }
+
+  registerSystem(stage: Stage, system: SystemFn): void {
+    if (!this.currentModuleName) {
+      log.warn("ModuleHost", "registerSystem called outside a module register() lifecycle — the system will not be attributed to any module");
+    }
+    this.systemCounter++;
+    const name = `module:${this.currentModuleName || "unattributed"}:${this.systemCounter}`;
+    this.world.schedule.add({
+      name,
+      stage,
+      fn: system,
+      queries: [],
+    });
+    const active = this.active.get(this.currentModuleName);
+    if (active) {
+      active.systemNames.push(name);
+    } else {
+      this.unattributedSystemNames.push(name);
+    }
+  }
+
+  registerSystemObject(system: System): void {
+    if (!this.currentModuleName) {
+      log.warn("ModuleHost", `registerSystemObject("${system.name}") called outside a module register() lifecycle — the system will not be attributed to any module`);
+    }
+    this.world.schedule.add(system);
+    const active = this.active.get(this.currentModuleName);
+    if (active) {
+      active.systemNames.push(system.name);
+    } else {
+      this.unattributedSystemNames.push(system.name);
+    }
+  }
+
+  allocateSABChannel(name: string, size: number): SABChannel {
+    if (!this.currentModuleName) {
+      log.warn("ModuleHost", `allocateSABChannel("${name}") called outside a module register() lifecycle — the channel is untracked and won't be cleaned up on unload`);
+    }
+    const buffer = new SharedArrayBuffer(size);
+    const active = this.active.get(this.currentModuleName);
+    if (active) {
+      active.sabChannels.set(name, buffer);
+    }
+    return { name, buffer };
+  }
+
+  provide<T>(token: ResourceToken<T>, value: T): void {
+    if (!this.currentModuleName) {
+      log.warn("ModuleHost", `provide("${token.key}") called outside a module register() lifecycle — the resource won't be cleaned up on unload`);
+    }
+    if (isStrict()) {
+      assertNoDuplicate(this.providers, token as ResourceToken<unknown>, this.currentModuleName);
+    }
+    this.resources.set(token.key, { token: token as ResourceToken<unknown>, value });
+    this.providers.set(token.key, this.currentModuleName);
+    const active = this.active.get(this.currentModuleName);
+    if (active) {
+      active.providedKeys.add(token.key);
+    }
+  }
+
+  /**
+   * Provide a typed resource from an external provider (e.g. the LibraryHost).
+   * Unlike `provide()`, this does not require a current plugin context.
+   * The `providerName` is used for diagnostics.
+   */
+  provideExternal<T>(providerName: string, token: ResourceToken<T>, value: T): void {
+    if (isStrict()) {
+      assertNoDuplicate(this.providers, token as ResourceToken<unknown>, providerName);
+    }
+    this.resources.set(token.key, { token: token as ResourceToken<unknown>, value });
+    this.providers.set(token.key, providerName);
+  }
+
+  inject<T>(token: ResourceToken<T>): T {
+    const entry = this.resources.get(token.key);
+    if (!entry) {
+      throw new Error(
+        `Module "${this.currentModuleName}" injects "${token.key}" which is not provided. ` +
+          `Add a plugin that provides it, or use injectOptional() for safe reads.`,
+      );
+    }
+    return entry.value as T;
+  }
+
+  injectOptional<T>(token: ResourceToken<T>): T | undefined {
+    const entry = this.resources.get(token.key);
+    return entry?.value as T | undefined;
+  }
+
+  registerMigration(fromVersion: number, fn: (data: unknown) => unknown): void {
+    this.migrations.set(fromVersion, fn);
+  }
+
+  getMigration(fromVersion: number): ((data: unknown) => unknown) | undefined {
+    return this.migrations.get(fromVersion);
+  }
+
+  onDispose(fn: () => void): void {
+    const active = this.active.get(this.currentModuleName);
+    if (active) {
+      active.disposeFns.push(fn);
+    } else {
+      // Don't drop the callback silently — run it at disposeAll() so
+      // resources registered outside a lifecycle still get cleaned up.
+      log.warn("ModuleHost", "onDispose called outside a module register() lifecycle — the callback will run at disposeAll() instead of being attributed to a module");
+      this.unattributedDisposeFns.push(fn);
+    }
+  }
+
+  private currentModuleName: string = "";
+  private systemCounter = 0;
+  /** Systems registered outside a register() lifecycle — removed at disposeAll(). */
+  private unattributedSystemNames: string[] = [];
+  /** Dispose callbacks registered outside a register() lifecycle — run at disposeAll(). */
+  private unattributedDisposeFns: Array<() => void> = [];
+
+  setCurrentPlugin(name: string): void {
+    this.currentModuleName = name;
+  }
+}
+
+// No-op DevTools API stub — used when setDevToolsAPI() hasn't been called.
+// Plugins that call ctx.devtools.registerPanel() will silently no-op.
+const NoopDevToolsAPI: ModuleDevToolsAPI = {
+  registerPanel: () => {},
+  registerOverlayToggle: () => {},
+  registerDataFeed: () => {},
+  registerCommand: () => {},
+  registerSABStat: () => {},
+};

package/core/src/module/index.ts

@@ -0,0 +1,22 @@
+// Module sub-barrel — re-exports all module-related items.
+export { buildCrossThreadReport, crossThreadToken } from "./cross-thread";
+export type { CrossThreadReport, CrossThreadToken, ModuleThreadInfo, ThreadTag } from "./cross-thread";
+export { DiagnosticError, isStrict, setStrict } from "./diagnostics";
+export { ModuleHost } from "./host";
+export type { DevToolsOverlayToggleRegistration, DevToolsPanelRegistration, Module, ModuleContext, ModuleDevToolsAPI, SABChannel } from "./module";
+export { ModuleRegistry } from "./registry";
+export type {
+    CameraControllerLike,
+    DragDelta,
+    DragHandler,
+    FrameHook,
+    FramePhase,
+    InputEventControl,
+    KeyHandler,
+    PointerHandler, RendererInputBus,
+    RendererModule,
+    RendererModuleContext, RenderPassHook, ResizeHook,
+    WheelHandler
+} from "./renderer-module";
+export { TsModuleLoader } from "./ts-loader";
+

package/core/src/module/module.ts

@@ -0,0 +1,109 @@
+import type { ComponentId } from "../ecs/component";
+import type { ResourceToken } from "../ecs/resource";
+import type { Stage, System, SystemFn } from "../ecs/system";
+
+export interface SABChannel {
+  name: string;
+  buffer: SharedArrayBuffer;
+}
+
+/**
+ * Panel registration payload for `ctx.devtools.registerPanel()`.
+ * Structurally compatible with `IDevToolsPanelExtension` from
+ * `@downdraft/engine/modules/devtools` — core declares the minimal shape
+ * so it doesn't depend on the devtools module (layering).
+ */
+export interface DevToolsPanelRegistration {
+  /** Unique id for this extension (e.g. "debug-info", "game-panel"). */
+  id: string;
+  /** Tab label shown in the tab bar. */
+  tabLabel: string;
+  /** Tab tooltip. */
+  tabTooltip?: string;
+  /** Order/priority for tab placement. Core tabs: 0-100, game tabs: 100+. Default: 100. */
+  order?: number;
+  /** __sceneInspector methods that must exist for this tab to be shown. */
+  requiredMethods?: string[];
+  /** HTML content for the panel body. */
+  html: string;
+  /** CSS to inject into the panel document. */
+  css?: string;
+  /** JS to eval in the panel context. */
+  script?: string;
+}
+
+/**
+ * Overlay toggle registration payload for `ctx.devtools.registerOverlayToggle()`.
+ * Structurally compatible with `IDevToolsOverlayToggle` from
+ * `@downdraft/engine/modules/devtools`.
+ */
+export interface DevToolsOverlayToggleRegistration {
+  /** Unique id (e.g. "chunk-grid", "vel-arrows"). */
+  id: string;
+  /** Label shown next to the checkbox. */
+  label: string;
+  /** __sceneInspector methods that must exist for this toggle to be shown. */
+  requiredMethods?: string[];
+  /** JS to eval in the panel context. */
+  script?: string;
+}
+
+/**
+ * DevTools registration surface exposed on ModuleContext.
+ * Plugins call `ctx.devtools.registerPanel(...)` etc. to self-register
+ * debug screens. The same interface works in both main and worker realms.
+ *
+ * The actual implementation is provided by @downdraft/engine/modules/devtools via
+ * the `devtools` singleton. Core defines the interface; the host injects
+ * the concrete object at construction time (see ModuleHost.setDevToolsAPI).
+ */
+export interface ModuleDevToolsAPI {
+  registerPanel(ext: DevToolsPanelRegistration): void;
+  registerOverlayToggle(toggle: DevToolsOverlayToggleRegistration): void;
+  registerDataFeed(name: string, fn: () => unknown, writeRateHz?: number): void;
+  registerCommand(name: string, fn: (...args: unknown[]) => unknown): void;
+  registerSABStat(name: string, offset: number, type: "u32" | "f32" | "i32"): void;
+}
+
+export interface ModuleContext {
+  registerComponent<T>(name: string, schema: T): ComponentId;
+  registerSystem(stage: Stage, system: SystemFn): void;
+  /** Register a pre-built System object (with queries) to the world schedule. */
+  registerSystemObject(system: System): void;
+  allocateSABChannel(name: string, size: number): SABChannel;
+  /**
+   * Provide a typed resource to the plugin graph. Other plugins can
+   * `inject()` it by the same token. In DOWNDRAFT_STRICT mode, duplicate
+   * provides of the same token throw a DiagnosticError.
+   */
+  provide<T>(token: ResourceToken<T>, value: T): void;
+  /**
+   * Read a typed resource provided by another plugin. Throws if the token
+   * has no provider (use `injectOptional` for safe reads).
+   */
+  inject<T>(token: ResourceToken<T>): T;
+  /**
+   * Read a typed resource, returning `undefined` if no plugin provides it.
+   */
+  injectOptional<T>(token: ResourceToken<T>): T | undefined;
+  registerMigration(fromVersion: number, fn: (data: unknown) => unknown): void;
+  onDispose(fn: () => void): void;
+  /**
+   * DevTools registration surface. Plugins self-register debug panels,
+   * data feeds, and commands via `ctx.devtools.register*(...)`.
+   * Works in both sim (worker) and renderer (main) plugin contexts.
+   */
+  readonly devtools: ModuleDevToolsAPI;
+}
+
+export interface Module {
+  name: string;
+  version: string;
+  dependencies?: string[];
+  /** Typed tokens this plugin provides to the graph. Validated at activation. */
+  provides?: ResourceToken<unknown>[];
+  /** Typed tokens this plugin requires from the graph. Validated at activation. */
+  requires?: ResourceToken<unknown>[];
+  register(ctx: ModuleContext): void;
+}
+

package/core/src/module/registry.ts

@@ -0,0 +1,94 @@
+import type { Module } from "./module";
+
+export class ModuleRegistry {
+  private plugins: Map<string, Module> = new Map();
+  private loadOrder: string[] = [];
+
+  register(plugin: Module): void {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Module "${plugin.name}" is already registered`);
+    }
+    if (plugin.dependencies) {
+      for (let i = 0; i < plugin.dependencies.length; i++) {
+        if (!this.plugins.has(plugin.dependencies[i])) {
+          throw new Error(`Module "${plugin.name}" requires "${plugin.dependencies[i]}" which is not registered`);
+        }
+      }
+    }
+    this.plugins.set(plugin.name, plugin);
+    this.loadOrder.push(plugin.name);
+  }
+
+  unregister(name: string): void {
+    this.plugins.delete(name);
+    const idx = this.loadOrder.indexOf(name);
+    if (idx >= 0) this.loadOrder.splice(idx, 1);
+  }
+
+  get(name: string): Module | undefined {
+    return this.plugins.get(name);
+  }
+
+  getAll(): Module[] {
+    return this.loadOrder.map((name) => this.plugins.get(name)!).filter(Boolean);
+  }
+
+  has(name: string): boolean {
+    return this.plugins.has(name);
+  }
+
+  /**
+   * Resolve activation order via topological sort over `dependencies`
+   * (module names) AND `requires` (typed tokens → provider module). A module
+   * that `requires` a token must activate after whichever module `provides`
+   * it — otherwise its `register()` would fail at `inject()`.
+   *
+   * Throws on a dependency cycle. A `requires` token with no registered
+   * provider adds no edge (the strict-mode graph validation reports it).
+   */
+  resolveOrder(): string[] {
+    // Provider map: token key → module name that provides it.
+    const providers = new Map<string, string>();
+    for (const m of this.getAll()) {
+      (m.provides ?? []).forEach((token) => {
+        providers.set(token.key, m.name);
+      });
+    }
+
+    const visited = new Set<string>();
+    const result: string[] = [];
+    const visiting = new Set<string>();
+
+    const visit = (name: string): void => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        throw new Error(`Module dependency cycle detected at "${name}"`);
+      }
+      visiting.add(name);
+
+      const plugin = this.plugins.get(name);
+      if (plugin?.dependencies) {
+        for (let i = 0; i < plugin.dependencies.length; i++) {
+          visit(plugin.dependencies[i]);
+        }
+      }
+      // requires (typed tokens → provider module)
+      if (plugin?.requires) {
+        plugin.requires.forEach((token) => {
+          const providerName = providers.get(token.key);
+          if (providerName && providerName !== name) visit(providerName);
+        });
+      }
+
+      visiting.delete(name);
+      visited.add(name);
+      result.push(name);
+    };
+
+    for (let i = 0; i < this.loadOrder.length; i++) {
+      visit(this.loadOrder[i]);
+    }
+
+    return result;
+  }
+}