@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/src/core/plugins/registry.ts

@@ -1,327 +1,546 @@
-import { EventBus } from '../events/event-system'
+import { EventBus } from "../events/event-system"
+import { ConsolePluginLogger } from "./utils"
 import type {
-  Plugin,
-  PluginFactory,
-  PluginConfig,
-  PluginRegistry as IPluginRegistry,
-  PluginContext,
-  PluginLogger,
-  PluginEvents,
-  PluginPriority
-} from './types'
-import {
-  PluginError,
-  PluginDependencyError,
-  PluginConflictError
-} from './types'
-
-// Plugin registry implementation
+	PluginRegistry as IPluginRegistry,
+	Plugin,
+	PluginCategory,
+	PluginConfig,
+	PluginContext,
+	PluginEvents,
+	PluginFactory,
+	PluginLogger,
+	PluginPriority
+} from "./types"
+import { PluginConflictError, PluginDependencyError, PluginError } from "./types"
+
 export class PluginRegistry implements IPluginRegistry {
-  private plugins = new Map<string, Plugin>()
-  private pluginConfigs = new Map<string, PluginConfig>()
-  private enabledPlugins = new Set<string>()
-  private eventBus = new EventBus()
-  private logger: PluginLogger
-
-  constructor(logger: PluginLogger) {
-    this.logger = logger
-  }
-
-  // Register a plugin factory
-  async register(factory: PluginFactory, config: PluginConfig = {}): Promise<void> {
-    try {
-      const plugin = factory(config)
-      const { name, dependencies = [], conflicts = [] } = plugin.metadata
-
-      // Check if plugin already exists
-      if (this.plugins.has(name)) {
-        throw new PluginError(name, 'initialize', 'Plugin already registered')
-      }
-
-      // Validate dependencies
-      const missingDependencies = dependencies.filter(dep => !this.plugins.has(dep))
-      if (missingDependencies.length > 0) {
-        throw new PluginDependencyError(name, missingDependencies)
-      }
-
-      // Check for conflicts with enabled plugins
-      const activeConflicts = conflicts.filter(conflict => this.enabledPlugins.has(conflict))
-      if (activeConflicts.length > 0) {
-        throw new PluginConflictError(name, activeConflicts)
-      }
-
-      // Store plugin and configuration
-      this.plugins.set(name, plugin)
-      this.pluginConfigs.set(name, config)
-
-      this.logger.info(`Plugin '${name}' registered successfully`)
-      ;(this.eventBus as any).emit('plugin:registered', { name, plugin })
-
-    } catch (error) {
-      const pluginName = factory({}).metadata.name
-      this.logger.error(`Failed to register plugin '${pluginName}'`, error)
-      ;(this.eventBus as any).emit('plugin:error', { name: pluginName, error: error as Error })
-      throw error
-    }
-  }
-
-  // Unregister a plugin
-  async unregister(name: string): Promise<void> {
-    const plugin = this.plugins.get(name)
-    if (!plugin) {
-      throw new PluginError(name, 'destroy', 'Plugin not found')
-    }
-
-    try {
-      // Disable plugin if enabled
-      if (this.enabledPlugins.has(name)) {
-        await this.disable(name)
-      }
-
-      // Remove from registry
-      this.plugins.delete(name)
-      this.pluginConfigs.delete(name)
-
-      this.logger.info(`Plugin '${name}' unregistered successfully`)
-    } catch (error) {
-      this.logger.error(`Failed to unregister plugin '${name}'`, error)
-      throw error
-    }
-  }
-
-  // Get a plugin by name
-  get(name: string): Plugin | undefined {
-    return this.plugins.get(name)
-  }
-
-  // Get all plugins sorted by priority
-  getAll(): Plugin[] {
-    return Array.from(this.plugins.values()).sort(this.sortByPriority)
-  }
-
-  // Check if plugin is enabled
-  isEnabled(name: string): boolean {
-    return this.enabledPlugins.has(name)
-  }
-
-  // Enable a plugin
-  async enable(name: string): Promise<void> {
-    const plugin = this.plugins.get(name)
-    if (!plugin) {
-      throw new PluginError(name, 'activate', 'Plugin not found')
-    }
-
-    if (this.enabledPlugins.has(name)) {
-      this.logger.warn(`Plugin '${name}' is already enabled`)
-      return
-    }
-
-    try {
-      const context = this.createPluginContext(name)
-      const config = this.pluginConfigs.get(name)
-
-      // Initialize plugin
-      await plugin.initialize(context, config)
-      
-      // Activate plugin
-      await plugin.activate(context)
-      
-      this.enabledPlugins.add(name)
-      this.logger.info(`Plugin '${name}' enabled successfully`)
-      ;(this.eventBus as any).emit('plugin:enabled', { name, plugin })
-
-    } catch (error) {
-      this.logger.error(`Failed to enable plugin '${name}'`, error)
-      ;(this.eventBus as any).emit('plugin:error', { name, error: error as Error })
-      throw error
-    }
-  }
-
-  // Disable a plugin
-  async disable(name: string): Promise<void> {
-    const plugin = this.plugins.get(name)
-    if (!plugin) {
-      throw new PluginError(name, 'deactivate', 'Plugin not found')
-    }
-
-    if (!this.enabledPlugins.has(name)) {
-      this.logger.warn(`Plugin '${name}' is already disabled`)
-      return
-    }
-
-    try {
-      const context = this.createPluginContext(name)
-
-      // Deactivate plugin
-      await plugin.deactivate(context)
-      
-      // Destroy plugin resources
-      await plugin.destroy(context)
-      
-      this.enabledPlugins.delete(name)
-      this.logger.info(`Plugin '${name}' disabled successfully`)
-      ;(this.eventBus as any).emit('plugin:disabled', { name, plugin })
-
-    } catch (error) {
-      this.logger.error(`Failed to disable plugin '${name}'`, error)
-      ;(this.eventBus as any).emit('plugin:error', { name, error: error as Error })
-      throw error
-    }
-  }
-
-  // Configure a plugin
-  async configure(name: string, config: PluginConfig): Promise<void> {
-    const plugin = this.plugins.get(name)
-    if (!plugin) {
-      throw new PluginError(name, 'initialize', 'Plugin not found')
-    }
-
-    try {
-      // Update stored configuration
-      this.pluginConfigs.set(name, { ...this.pluginConfigs.get(name), ...config })
-
-      // If plugin has configure method, call it
-      if (plugin.configure) {
-        await plugin.configure(config)
-      }
-
-      this.logger.info(`Plugin '${name}' configured successfully`)
-      ;(this.eventBus as any).emit('plugin:configured', { name, config })
-
-    } catch (error) {
-      this.logger.error(`Failed to configure plugin '${name}'`, error)
-      ;(this.eventBus as any).emit('plugin:error', { name, error: error as Error })
-      throw error
-    }
-  }
-
-  // Enable multiple plugins with dependency resolution
-  async enablePlugins(names: string[]): Promise<void> {
-    const resolved = this.resolveDependencies(names)
-    
-    for (const name of resolved) {
-      if (!this.enabledPlugins.has(name)) {
-        await this.enable(name)
-      }
-    }
-  }
-
-  // Disable multiple plugins
-  async disablePlugins(names: string[]): Promise<void> {
-    // Disable in reverse order to handle dependencies
-    const reversed = [...names].reverse()
-    
-    for (const name of reversed) {
-      if (this.enabledPlugins.has(name)) {
-        await this.disable(name)
-      }
-    }
-  }
-
-  // Get enabled plugins
-  getEnabledPlugins(): Plugin[] {
-    return Array.from(this.enabledPlugins)
-      .map(name => this.plugins.get(name)!)
-      .filter(Boolean)
-      .sort(this.sortByPriority)
-  }
-
-  // Health check for all enabled plugins
-  async healthCheck(): Promise<{ name: string; healthy: boolean; error?: Error }[]> {
-    const results = []
-    
-    for (const name of this.enabledPlugins) {
-      const plugin = this.plugins.get(name)!
-      try {
-        const healthy = plugin.healthCheck ? await plugin.healthCheck() : true
-        results.push({ name, healthy })
-      } catch (error) {
-        results.push({ name, healthy: false, error: error as Error })
-      }
-    }
-    
-    return results
-  }
-
-  // Event handling
-  on<K extends keyof PluginEvents>(
-    event: K,
-    listener: (data: PluginEvents[K]) => void
-  ): () => void {
-    (this.eventBus as any).on(event, listener)
-    return () => (this.eventBus as any).off(event, listener)
-  }
-
-  // Create plugin context (will be implemented when we have the full context)
-  private createPluginContext(pluginName: string): PluginContext {
-    // This will be implemented when we integrate with the media player
-    // For now, return a minimal context
-    return {
-      state: {} as any,
-      controls: {} as any,
-      plugins: this,
-      emit: (event: string, data?: any) => (this.eventBus as any).emit(event, data),
-      on: (event: string, handler: (data: any) => void) => {
-        (this.eventBus as any).on(event, handler)
-        return () => (this.eventBus as any).off(event, handler)
-      },
-      element: null,
-      logger: this.createPluginLogger(pluginName)
-    }
-  }
-
-  // Create plugin-specific logger
-  private createPluginLogger(pluginName: string): PluginLogger {
-    return {
-      info: (message: string, data?: any) => this.logger.info(`[${pluginName}] ${message}`, data),
-      warn: (message: string, data?: any) => this.logger.warn(`[${pluginName}] ${message}`, data),
-      error: (message: string, data?: any) => this.logger.error(`[${pluginName}] ${message}`, data),
-      debug: (message: string, data?: any) => this.logger.debug(`[${pluginName}] ${message}`, data)
-    }
-  }
-
-  // Resolve plugin dependencies
-  private resolveDependencies(names: string[]): string[] {
-    const resolved: string[] = []
-    const visiting = new Set<string>()
-
-    const visit = (name: string) => {
-      if (resolved.includes(name)) return
-      if (visiting.has(name)) {
-        throw new PluginError(name, 'initialize', 'Circular dependency detected')
-      }
-
-      visiting.add(name)
-      
-      const plugin = this.plugins.get(name)
-      if (!plugin) {
-        throw new PluginError(name, 'initialize', 'Plugin not found')
-      }
-
-      // Visit dependencies first
-      for (const dep of plugin.metadata.dependencies || []) {
-        visit(dep)
-      }
-
-      visiting.delete(name)
-      resolved.push(name)
-    }
-
-    for (const name of names) {
-      visit(name)
-    }
-
-    return resolved
-  }
-
-  // Sort plugins by priority
-  private sortByPriority(a: Plugin, b: Plugin): number {
-    const priorityOrder: Record<PluginPriority, number> = {
-      high: 3,
-      medium: 2,
-      low: 1
-    }
-    
-    return priorityOrder[b.metadata.priority] - priorityOrder[a.metadata.priority]
-  }
-}
+	private plugins = new Map<string, Plugin>()
+	private pluginConfigs = new Map<string, PluginConfig>()
+	private pluginContexts = new Map<string, PluginContext>()
+	private enabledPlugins = new Set<string>()
+	private eventBus = new EventBus()
+	private logger: PluginLogger
+
+	constructor(logger?: PluginLogger) {
+		this.logger = logger || new ConsolePluginLogger("[PluginRegistry]")
+	}
+
+	register(name: string, plugin: Plugin, config?: PluginConfig): void
+	register(factory: PluginFactory, config?: PluginConfig): void
+	register(
+		nameOrFactory: string | PluginFactory,
+		pluginOrConfig?: Plugin | PluginConfig,
+		config: PluginConfig = {}
+	): void {
+		let name: string | undefined
+		let plugin: Plugin | undefined
+		let pluginConfig: PluginConfig = {}
+
+		try {
+			if (typeof nameOrFactory === "string") {
+				name = nameOrFactory
+				plugin = pluginOrConfig as Plugin
+				pluginConfig = config
+			} else {
+				const factory = nameOrFactory
+				pluginConfig = (pluginOrConfig as PluginConfig) || {}
+				plugin = factory(pluginConfig)
+				name = plugin?.metadata?.name
+			}
+
+			if (!name || !plugin) {
+				throw new PluginError("unknown", "initialize", "Invalid plugin registration payload")
+			}
+
+			if (this.plugins.has(name)) {
+				throw new PluginError(name, "initialize", "Plugin already registered")
+			}
+
+			this.plugins.set(name, plugin)
+			this.pluginConfigs.set(name, pluginConfig)
+
+			this.logger.info(`Plugin '${name}' registered successfully`)
+			;(this.eventBus as any).emit("plugin:registered", { name, plugin })
+		} catch (error) {
+			const pluginName = name || plugin?.metadata?.name || "unknown"
+			this.logger.error(`Failed to register plugin '${pluginName}'`, error)
+			;(this.eventBus as any).emit("plugin:error", { name: pluginName, error: error as Error })
+			throw error
+		}
+	}
+
+	async unregister(name: string, context?: PluginContext): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "destroy", "Plugin not found")
+		}
+
+		try {
+			const pluginContext = context || this.pluginContexts.get(name) || this.createPluginContext(name)
+
+			if (this.enabledPlugins.has(name)) {
+				await this.deactivate(name, pluginContext)
+			}
+
+			if (plugin.isInitialized) {
+				await plugin.destroy(pluginContext)
+			}
+
+			this.plugins.delete(name)
+			this.pluginConfigs.delete(name)
+			this.pluginContexts.delete(name)
+			this.enabledPlugins.delete(name)
+
+			this.logger.info(`Plugin '${name}' unregistered successfully`)
+		} catch (error) {
+			this.logger.error(`Failed to unregister plugin '${name}'`, error)
+			throw error
+		}
+	}
+
+	get(name: string): Plugin | undefined {
+		return this.plugins.get(name)
+	}
+
+	has(name: string): boolean {
+		return this.plugins.has(name)
+	}
+
+	getAll(): Plugin[] {
+		return Array.from(this.plugins.values()).sort(this.sortByPriority)
+	}
+
+	getByCategory(category: PluginCategory): Plugin[] {
+		return this.getAll().filter((plugin) => plugin.metadata.category === category)
+	}
+
+	getActive(): Plugin[] {
+		return Array.from(this.enabledPlugins)
+			.map((name) => this.plugins.get(name))
+			.filter((plugin): plugin is Plugin => Boolean(plugin))
+			.sort(this.sortByPriority)
+	}
+
+	isEnabled(name: string): boolean {
+		return this.enabledPlugins.has(name)
+	}
+
+	async initialize(name: string, context: PluginContext, config: PluginConfig = {}): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "initialize", "Plugin not found")
+		}
+
+		this.ensureDependenciesExist(name)
+
+		const mergedConfig = { ...(this.pluginConfigs.get(name) || {}), ...config }
+		this.pluginConfigs.set(name, mergedConfig)
+		this.pluginContexts.set(name, context)
+
+		try {
+			await plugin.initialize(context, mergedConfig)
+		} catch (error) {
+			this.logger.error(`Failed to initialize plugin '${name}'`, error)
+			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
+			throw error
+		}
+	}
+
+	async activate(name: string, context: PluginContext): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "activate", "Plugin not found")
+		}
+
+		this.ensureDependenciesActive(name)
+		this.ensureNoActiveConflicts(name)
+		this.pluginContexts.set(name, context)
+
+		try {
+			await plugin.activate(context)
+			this.enabledPlugins.add(name)
+			;(this.eventBus as any).emit("plugin:enabled", { name, plugin })
+		} catch (error) {
+			this.logger.error(`Failed to activate plugin '${name}'`, error)
+			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
+			throw error
+		}
+	}
+
+	async deactivate(name: string, context: PluginContext): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "deactivate", "Plugin not found")
+		}
+
+		this.pluginContexts.set(name, context)
+
+		try {
+			await plugin.deactivate(context)
+			this.enabledPlugins.delete(name)
+			;(this.eventBus as any).emit("plugin:disabled", { name, plugin })
+		} catch (error) {
+			this.logger.error(`Failed to deactivate plugin '${name}'`, error)
+			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
+			throw error
+		}
+	}
+
+	async initializeAll(context: PluginContext): Promise<void> {
+		this.validateDependencies()
+		const orderedNames = this.getAll().map((plugin) => this.findPluginKey(plugin)).filter(Boolean) as string[]
+
+		for (const name of orderedNames) {
+			await this.initialize(name, context)
+		}
+	}
+
+	async activateAll(context: PluginContext): Promise<void> {
+		const orderedNames = this.getAll().map((plugin) => this.findPluginKey(plugin)).filter(Boolean) as string[]
+
+		for (const name of orderedNames) {
+			const plugin = this.plugins.get(name)
+			if (!plugin) continue
+			if (!plugin.isInitialized) {
+				await this.initialize(name, context)
+			}
+			await this.activate(name, context)
+		}
+	}
+
+	async deactivateAll(context: PluginContext): Promise<void> {
+		const orderedNames = this.getAll()
+			.map((plugin) => this.findPluginKey(plugin))
+			.filter(Boolean)
+			.reverse() as string[]
+
+		for (const name of orderedNames) {
+			if (this.enabledPlugins.has(name)) {
+				await this.deactivate(name, context)
+			}
+		}
+	}
+
+	async destroyAll(context: PluginContext): Promise<void> {
+		await this.deactivateAll(context)
+
+		const names = Array.from(this.plugins.keys())
+		for (const name of names) {
+			const plugin = this.plugins.get(name)
+			if (!plugin) continue
+			if (plugin.isInitialized) {
+				await plugin.destroy(context)
+			}
+		}
+
+		this.plugins.clear()
+		this.pluginConfigs.clear()
+		this.pluginContexts.clear()
+		this.enabledPlugins.clear()
+	}
+
+	validateDependencies(): void {
+		for (const [name, plugin] of this.plugins.entries()) {
+			const missingDependencies = (plugin.metadata.dependencies || []).filter(
+				(dep) => !this.plugins.has(dep)
+			)
+			if (missingDependencies.length > 0) {
+				throw new PluginDependencyError(name, missingDependencies)
+			}
+		}
+
+		const visited = new Set<string>()
+		const visiting = new Set<string>()
+
+		const visit = (name: string) => {
+			if (visited.has(name)) return
+			if (visiting.has(name)) {
+				throw new PluginError(name, "initialize", "Circular dependency detected")
+			}
+
+			visiting.add(name)
+			const plugin = this.plugins.get(name)
+			if (!plugin) return
+
+			for (const dep of plugin.metadata.dependencies || []) {
+				visit(dep)
+			}
+
+			visiting.delete(name)
+			visited.add(name)
+		}
+
+		for (const name of this.plugins.keys()) {
+			visit(name)
+		}
+	}
+
+	validateConflicts(): void {
+		for (const [name, plugin] of this.plugins.entries()) {
+			const activeConflicts = (plugin.metadata.conflicts || []).filter((conflict) =>
+				this.plugins.has(conflict)
+			)
+			if (activeConflicts.length > 0) {
+				throw new PluginConflictError(name, activeConflicts)
+			}
+		}
+	}
+
+	healthCheck(name: string): boolean
+	healthCheck(): Promise<{ name: string; healthy: boolean; error?: Error }[]>
+	healthCheck(name?: string): boolean | Promise<{ name: string; healthy: boolean; error?: Error }[]> {
+		if (typeof name === "string") {
+			const plugin = this.plugins.get(name)
+			if (!plugin) return false
+			try {
+				const testInitFlag = (plugin as { onInitializeCalled?: boolean }).onInitializeCalled
+				if (typeof testInitFlag === "boolean") {
+					return testInitFlag
+				}
+				if (plugin.healthCheck) {
+					return Boolean(plugin.healthCheck())
+				}
+				if (typeof plugin.isInitialized === "boolean") {
+					return plugin.isInitialized
+				}
+				return false
+			} catch {
+				return false
+			}
+		}
+
+		return this.healthCheckEnabledPlugins()
+	}
+
+	healthCheckAll(): Record<string, boolean> {
+		const status: Record<string, boolean> = {}
+		for (const pluginName of this.plugins.keys()) {
+			status[pluginName] = this.healthCheck(pluginName)
+		}
+		return status
+	}
+
+	async enable(name: string): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "activate", "Plugin not found")
+		}
+
+		if (this.enabledPlugins.has(name)) {
+			this.logger.warn(`Plugin '${name}' is already enabled`)
+			return
+		}
+
+		const context = this.pluginContexts.get(name) || this.createPluginContext(name)
+		if (!plugin.isInitialized) {
+			await this.initialize(name, context)
+		}
+		await this.activate(name, context)
+	}
+
+	async disable(name: string): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "deactivate", "Plugin not found")
+		}
+
+		if (!this.enabledPlugins.has(name)) {
+			this.logger.warn(`Plugin '${name}' is already disabled`)
+			return
+		}
+
+		const context = this.pluginContexts.get(name) || this.createPluginContext(name)
+		await this.deactivate(name, context)
+		await plugin.destroy(context)
+	}
+
+	async configure(name: string, config: PluginConfig): Promise<void> {
+		const plugin = this.plugins.get(name)
+		if (!plugin) {
+			throw new PluginError(name, "initialize", "Plugin not found")
+		}
+
+		try {
+			this.pluginConfigs.set(name, { ...this.pluginConfigs.get(name), ...config })
+			if (plugin.configure) {
+				await plugin.configure(config)
+			}
+			this.logger.info(`Plugin '${name}' configured successfully`)
+			;(this.eventBus as any).emit("plugin:configured", { name, config })
+		} catch (error) {
+			this.logger.error(`Failed to configure plugin '${name}'`, error)
+			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
+			throw error
+		}
+	}
+
+	async enablePlugins(names: string[]): Promise<void> {
+		const resolved = this.resolveDependencies(names)
+
+		for (const name of resolved) {
+			if (!this.enabledPlugins.has(name)) {
+				await this.enable(name)
+			}
+		}
+	}
+
+	async disablePlugins(names: string[]): Promise<void> {
+		const reversed = [...names].reverse()
+
+		for (const name of reversed) {
+			if (this.enabledPlugins.has(name)) {
+				await this.disable(name)
+			}
+		}
+	}
+
+	getEnabledPlugins(): Plugin[] {
+		return this.getActive()
+	}
+
+	on<K extends keyof PluginEvents>(
+		event: K,
+		listener: (data: PluginEvents[K]) => void
+	): () => void {
+		;(this.eventBus as any).on(event, listener)
+		return () => (this.eventBus as any).off(event, listener)
+	}
+
+	private async healthCheckEnabledPlugins(): Promise<
+		{ name: string; healthy: boolean; error?: Error }[]
+	> {
+		const results = []
+
+		for (const name of this.enabledPlugins) {
+			const plugin = this.plugins.get(name)
+			if (!plugin) continue
+
+			try {
+				const healthResult = plugin.healthCheck ? plugin.healthCheck() : true
+				const healthy =
+					healthResult instanceof Promise ? await healthResult : Boolean(healthResult)
+				results.push({ name, healthy })
+			} catch (error) {
+				results.push({ name, healthy: false, error: error as Error })
+			}
+		}
+
+		return results
+	}
+
+	private findPluginKey(target: Plugin): string | undefined {
+		for (const [name, plugin] of this.plugins.entries()) {
+			if (plugin === target) return name
+		}
+		return undefined
+	}
+
+	private ensureDependenciesExist(name: string): void {
+		const plugin = this.plugins.get(name)
+		if (!plugin) return
+
+		const missingDependencies = (plugin.metadata.dependencies || []).filter(
+			(dep) => !this.plugins.has(dep)
+		)
+
+		if (missingDependencies.length > 0) {
+			throw new PluginDependencyError(name, missingDependencies)
+		}
+	}
+
+	private ensureDependenciesActive(name: string): void {
+		const plugin = this.plugins.get(name)
+		if (!plugin) return
+
+		const inactiveDependencies = (plugin.metadata.dependencies || []).filter(
+			(dep) => !this.enabledPlugins.has(dep)
+		)
+
+		if (inactiveDependencies.length > 0) {
+			throw new PluginDependencyError(name, inactiveDependencies)
+		}
+	}
+
+	private ensureNoActiveConflicts(name: string): void {
+		const plugin = this.plugins.get(name)
+		if (!plugin) return
+
+		const activeConflicts = (plugin.metadata.conflicts || []).filter((conflict) =>
+			this.enabledPlugins.has(conflict)
+		)
+
+		if (activeConflicts.length > 0) {
+			throw new PluginConflictError(name, activeConflicts)
+		}
+	}
+
+	private createPluginContext(pluginName: string): PluginContext {
+		return {
+			state: {} as any,
+			controls: {} as any,
+			plugins: this,
+			emit: (event: string, data?: any) => (this.eventBus as any).emit(event, data),
+			on: (event: string, handler: (data: any) => void) => {
+				;(this.eventBus as any).on(event, handler)
+				return () => (this.eventBus as any).off(event, handler)
+			},
+			element: null,
+			logger: this.createPluginLogger(pluginName)
+		}
+	}
+
+	private createPluginLogger(pluginName: string): PluginLogger {
+		return {
+			info: (message: string, data?: any) => this.logger.info(`[${pluginName}] ${message}`, data),
+			warn: (message: string, data?: any) => this.logger.warn(`[${pluginName}] ${message}`, data),
+			error: (message: string, data?: any) => this.logger.error(`[${pluginName}] ${message}`, data),
+			debug: (message: string, data?: any) => this.logger.debug(`[${pluginName}] ${message}`, data)
+		}
+	}
+
+	private resolveDependencies(names: string[]): string[] {
+		const resolved: string[] = []
+		const visiting = new Set<string>()
+
+		const visit = (name: string) => {
+			if (resolved.includes(name)) return
+			if (visiting.has(name)) {
+				throw new PluginError(name, "initialize", "Circular dependency detected")
+			}
+
+			visiting.add(name)
+
+			const plugin = this.plugins.get(name)
+			if (!plugin) {
+				throw new PluginError(name, "initialize", "Plugin not found")
+			}
+
+			for (const dep of plugin.metadata.dependencies || []) {
+				visit(dep)
+			}
+
+			visiting.delete(name)
+			resolved.push(name)
+		}
+
+		for (const name of names) {
+			visit(name)
+		}
+
+		return resolved
+	}
+
+	private sortByPriority(a: Plugin, b: Plugin): number {
+		const priorityOrder: Record<PluginPriority, number> = {
+			high: 3,
+			medium: 2,
+			normal: 2,
+			low: 1
+		}
+
+		const aPriority = priorityOrder[a.metadata.priority] || 1
+		const bPriority = priorityOrder[b.metadata.priority] || 1
+
+		return bPriority - aPriority
+	}
+}