@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/performance/ModSupport.js

@@ -1,519 +1,479 @@
-/**
- * @file ModSupport.ts
- * @description Plugin/mod loading system for extensible games
- * PRO-1.5: Runtime & Performance
- *
- * Features:
- * - Mod discovery and loading
- * - Dependency resolution
- * - Version compatibility
- * - Sandboxed execution
- * - Mod configuration
- * - Steam Workshop integration ready
- * - Conflict detection
- * - Load order management
- */
-// ============================================================
-// Default Configuration
-// ============================================================
 const DEFAULT_MOD_CONFIG = {
-    modsDirectory: 'mods/',
-    enabledModsFile: 'enabled_mods.json',
-    configDirectory: 'mod_configs/',
-    gameVersion: '1.0.0',
-    maxMods: 100,
-    sandboxEnabled: true,
-    allowNetworkAccess: false,
-    allowFileAccess: false,
+  modsDirectory: "mods/",
+  enabledModsFile: "enabled_mods.json",
+  configDirectory: "mod_configs/",
+  gameVersion: "1.0.0",
+  maxMods: 100,
+  sandboxEnabled: true,
+  allowNetworkAccess: false,
+  allowFileAccess: false
 };
-// ============================================================
-// Version Utilities
-// ============================================================
 function parseVersion(version) {
-    const [major, minor, patch] = version.split('.').map(Number);
-    return { major: major || 0, minor: minor || 0, patch: patch || 0 };
+  const [major, minor, patch] = version.split(".").map(Number);
+  return { major: major || 0, minor: minor || 0, patch: patch || 0 };
 }
 function compareVersions(a, b) {
-    const va = parseVersion(a);
-    const vb = parseVersion(b);
-    if (va.major !== vb.major) {
-        return va.major - vb.major;
-    }
-    if (va.minor !== vb.minor) {
-        return va.minor - vb.minor;
-    }
-    return va.patch - vb.patch;
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (va.major !== vb.major) {
+    return va.major - vb.major;
+  }
+  if (va.minor !== vb.minor) {
+    return va.minor - vb.minor;
+  }
+  return va.patch - vb.patch;
 }
 function isVersionCompatible(version, min, max) {
-    if (min && compareVersions(version, min) < 0) {
-        return false;
-    }
-    if (max && compareVersions(version, max) > 0) {
-        return false;
-    }
-    return true;
+  if (min && compareVersions(version, min) < 0) {
+    return false;
+  }
+  if (max && compareVersions(version, max) > 0) {
+    return false;
+  }
+  return true;
 }
-// ============================================================
-// Mod Registry
-// ============================================================
 class ModRegistry {
-    constructor() {
-        this.mods = new Map();
-        this.loadOrder = [];
-    }
-    register(manifest) {
-        const instance = {
-            manifest,
-            state: 'discovered',
-            config: this.getDefaultConfig(manifest),
-        };
-        this.mods.set(manifest.id, instance);
-        return instance;
-    }
-    unregister(modId) {
-        this.mods.delete(modId);
-        this.loadOrder = this.loadOrder.filter((id) => id !== modId);
-    }
-    get(modId) {
-        return this.mods.get(modId);
-    }
-    getAll() {
-        return Array.from(this.mods.values());
-    }
-    getEnabled() {
-        return this.getAll().filter((m) => m.state === 'enabled');
-    }
-    getByState(state) {
-        return this.getAll().filter((m) => m.state === state);
-    }
-    getByType(type) {
-        return this.getAll().filter((m) => m.manifest.type === type);
-    }
-    setState(modId, state, error) {
-        const mod = this.mods.get(modId);
-        if (mod) {
-            mod.state = state;
-            mod.error = error;
-        }
-    }
-    setConfig(modId, config) {
-        const mod = this.mods.get(modId);
-        if (mod) {
-            mod.config = { ...mod.config, ...config };
-        }
-    }
-    setExports(modId, exports) {
-        const mod = this.mods.get(modId);
-        if (mod) {
-            mod.exports = exports;
-        }
-    }
-    getLoadOrder() {
-        return [...this.loadOrder];
-    }
-    setLoadOrder(order) {
-        this.loadOrder = order.filter((id) => this.mods.has(id));
-    }
-    getDefaultConfig(manifest) {
-        const config = {};
-        if (manifest.config) {
-            for (const [key, schema] of Object.entries(manifest.config)) {
-                config[key] = schema.default;
-            }
-        }
-        return config;
-    }
+  constructor() {
+    this.mods = /* @__PURE__ */ new Map();
+    this.loadOrder = [];
+  }
+  register(manifest) {
+    const instance = {
+      manifest,
+      state: "discovered",
+      config: this.getDefaultConfig(manifest)
+    };
+    this.mods.set(manifest.id, instance);
+    return instance;
+  }
+  unregister(modId) {
+    this.mods.delete(modId);
+    this.loadOrder = this.loadOrder.filter((id) => id !== modId);
+  }
+  get(modId) {
+    return this.mods.get(modId);
+  }
+  getAll() {
+    return Array.from(this.mods.values());
+  }
+  getEnabled() {
+    return this.getAll().filter((m) => m.state === "enabled");
+  }
+  getByState(state) {
+    return this.getAll().filter((m) => m.state === state);
+  }
+  getByType(type) {
+    return this.getAll().filter((m) => m.manifest.type === type);
+  }
+  setState(modId, state, error) {
+    const mod = this.mods.get(modId);
+    if (mod) {
+      mod.state = state;
+      mod.error = error;
+    }
+  }
+  setConfig(modId, config) {
+    const mod = this.mods.get(modId);
+    if (mod) {
+      mod.config = { ...mod.config, ...config };
+    }
+  }
+  setExports(modId, exports) {
+    const mod = this.mods.get(modId);
+    if (mod) {
+      mod.exports = exports;
+    }
+  }
+  getLoadOrder() {
+    return [...this.loadOrder];
+  }
+  setLoadOrder(order) {
+    this.loadOrder = order.filter((id) => this.mods.has(id));
+  }
+  getDefaultConfig(manifest) {
+    const config = {};
+    if (manifest.config) {
+      for (const [key, schema] of Object.entries(manifest.config)) {
+        config[key] = schema.default;
+      }
+    }
+    return config;
+  }
 }
-// ============================================================
-// Dependency Resolver
-// ============================================================
 class DependencyResolver {
-    constructor(registry) {
-        this.registry = registry;
-    }
-    resolve(modId) {
-        const visited = new Set();
-        const order = [];
-        const missing = [];
-        let circular = false;
-        const visit = (id, path) => {
-            if (path.has(id)) {
-                circular = true;
-                return;
-            }
-            if (visited.has(id)) {
-                return;
-            }
-            path.add(id);
-            visited.add(id);
-            const mod = this.registry.get(id);
-            if (!mod) {
-                return;
-            }
-            for (const dep of mod.manifest.dependencies) {
-                const depMod = this.registry.get(dep.modId);
-                if (!depMod) {
-                    if (!dep.optional) {
-                        missing.push(dep);
-                    }
-                }
-                else {
-                    visit(dep.modId, new Set(path));
-                }
-            }
-            path.delete(id);
-            order.push(id);
-        };
-        visit(modId, new Set());
-        return { order, missing, circular };
-    }
-    resolveAll() {
-        const allMissing = [];
-        const circular = [];
-        const sorted = [];
-        for (const mod of this.registry.getAll()) {
-            const result = this.resolve(mod.manifest.id);
-            if (result.circular) {
-                circular.push(mod.manifest.id);
-            }
-            allMissing.push(...result.missing);
-            for (const id of result.order) {
-                if (!sorted.includes(id)) {
-                    sorted.push(id);
-                }
-            }
+  constructor(registry) {
+    this.registry = registry;
+  }
+  resolve(modId) {
+    const visited = /* @__PURE__ */ new Set();
+    const order = [];
+    const missing = [];
+    let circular = false;
+    const visit = (id, path) => {
+      if (path.has(id)) {
+        circular = true;
+        return;
+      }
+      if (visited.has(id)) {
+        return;
+      }
+      path.add(id);
+      visited.add(id);
+      const mod = this.registry.get(id);
+      if (!mod) {
+        return;
+      }
+      for (const dep of mod.manifest.dependencies) {
+        const depMod = this.registry.get(dep.modId);
+        if (!depMod) {
+          if (!dep.optional) {
+            missing.push(dep);
+          }
+        } else {
+          visit(dep.modId, new Set(path));
+        }
+      }
+      path.delete(id);
+      order.push(id);
+    };
+    visit(modId, /* @__PURE__ */ new Set());
+    return { order, missing, circular };
+  }
+  resolveAll() {
+    const allMissing = [];
+    const circular = [];
+    const sorted = [];
+    for (const mod of this.registry.getAll()) {
+      const result = this.resolve(mod.manifest.id);
+      if (result.circular) {
+        circular.push(mod.manifest.id);
+      }
+      allMissing.push(...result.missing);
+      for (const id of result.order) {
+        if (!sorted.includes(id)) {
+          sorted.push(id);
         }
-        return {
-            order: sorted,
-            missing: allMissing,
-            circular,
-        };
+      }
     }
+    return {
+      order: sorted,
+      missing: allMissing,
+      circular
+    };
+  }
 }
-// ============================================================
-// Conflict Detector
-// ============================================================
 class ConflictDetector {
-    constructor(registry) {
-        this.registry = registry;
-    }
-    detect() {
-        const conflicts = [];
-        const mods = this.registry.getAll();
-        for (let i = 0; i < mods.length; i++) {
-            const modA = mods[i];
-            // Check explicit conflicts
-            for (const conflictId of modA.manifest.conflicts) {
-                const modB = this.registry.get(conflictId);
-                if (modB) {
-                    conflicts.push({
-                        modA: modA.manifest.id,
-                        modB: modB.manifest.id,
-                        reason: `${modA.manifest.name} explicitly conflicts with ${modB.manifest.name}`,
-                        severity: 'error',
-                    });
-                }
-            }
-            // Check asset conflicts (simplified)
-            for (let j = i + 1; j < mods.length; j++) {
-                const modB = mods[j];
-                if (modA.manifest.assets && modB.manifest.assets) {
-                    const overlap = modA.manifest.assets.filter((a) => modB.manifest.assets?.includes(a));
-                    if (overlap.length > 0) {
-                        conflicts.push({
-                            modA: modA.manifest.id,
-                            modB: modB.manifest.id,
-                            reason: `Both mods modify: ${overlap.join(', ')}`,
-                            severity: 'warning',
-                        });
-                    }
-                }
-            }
+  constructor(registry) {
+    this.registry = registry;
+  }
+  detect() {
+    const conflicts = [];
+    const mods = this.registry.getAll();
+    for (let i = 0; i < mods.length; i++) {
+      const modA = mods[i];
+      for (const conflictId of modA.manifest.conflicts) {
+        const modB = this.registry.get(conflictId);
+        if (modB) {
+          conflicts.push({
+            modA: modA.manifest.id,
+            modB: modB.manifest.id,
+            reason: `${modA.manifest.name} explicitly conflicts with ${modB.manifest.name}`,
+            severity: "error"
+          });
         }
-        return conflicts;
+      }
+      for (let j = i + 1; j < mods.length; j++) {
+        const modB = mods[j];
+        if (modA.manifest.assets && modB.manifest.assets) {
+          const overlap = modA.manifest.assets.filter((a) => modB.manifest.assets?.includes(a));
+          if (overlap.length > 0) {
+            conflicts.push({
+              modA: modA.manifest.id,
+              modB: modB.manifest.id,
+              reason: `Both mods modify: ${overlap.join(", ")}`,
+              severity: "warning"
+            });
+          }
+        }
+      }
     }
+    return conflicts;
+  }
 }
-// ============================================================
-// Mod Loader
-// ============================================================
 class ModLoader {
-    constructor(config) {
-        this.config = { ...DEFAULT_MOD_CONFIG, ...config };
-        this.registry = new ModRegistry();
-        this.resolver = new DependencyResolver(this.registry);
-        this.conflictDetector = new ConflictDetector(this.registry);
-    }
-    // ─── Discovery ─────────────────────────────────────────
-    async discover() {
-        // In a real implementation, this would scan the mods directory
-        // For now, we provide a registration method
-        return this.registry.getAll().map((m) => m.manifest);
-    }
-    registerMod(manifest) {
-        // Validate manifest
-        if (!this.validateManifest(manifest)) {
-            console.warn(`Mod ${manifest.id} has invalid manifest`);
-            return;
-        }
-        // Check version compatibility
-        if (!isVersionCompatible(this.config.gameVersion, manifest.gameVersionMin, manifest.gameVersionMax)) {
-            const instance = this.registry.register(manifest);
-            instance.state = 'incompatible';
-            instance.error = `Requires game version ${manifest.gameVersionMin || '?'} - ${manifest.gameVersionMax || '?'}`;
-            return;
-        }
-        this.registry.register(manifest);
-        this.onModDiscovered?.(manifest);
-    }
-    validateManifest(manifest) {
-        return !!(manifest.id && manifest.name && manifest.version && manifest.entryPoint);
-    }
-    // ─── Loading ───────────────────────────────────────────
-    async load(modId) {
-        const startTime = performance.now();
-        const mod = this.registry.get(modId);
-        if (!mod) {
-            return {
-                success: false,
-                modId,
-                error: 'Mod not found',
-                dependencies: [],
-                loadTime: 0,
-            };
-        }
-        if (mod.state === 'incompatible') {
-            return {
-                success: false,
-                modId,
-                error: mod.error ?? 'Incompatible version',
-                dependencies: [],
-                loadTime: 0,
-            };
-        }
-        // Resolve dependencies
-        const { order, missing, circular } = this.resolver.resolve(modId);
-        if (missing.length > 0) {
-            const missingIds = missing.map((d) => d.modId).join(', ');
-            return {
-                success: false,
-                modId,
-                error: `Missing dependencies: ${missingIds}`,
-                dependencies: [],
-                loadTime: performance.now() - startTime,
-            };
-        }
-        if (circular) {
-            return {
-                success: false,
-                modId,
-                error: 'Circular dependency detected',
-                dependencies: order,
-                loadTime: performance.now() - startTime,
-            };
-        }
-        // Load dependencies first
-        for (const depId of order) {
-            if (depId === modId) {
-                continue;
-            }
-            const depMod = this.registry.get(depId);
-            if (depMod && depMod.state === 'discovered') {
-                await this.load(depId);
-            }
-        }
-        // Load the mod
-        this.registry.setState(modId, 'loading');
-        try {
-            // In real implementation, this would dynamically import the mod
-            // const exports = await this.loadModule(mod.manifest.entryPoint);
-            const exports = {};
-            this.registry.setExports(modId, exports);
-            this.registry.setState(modId, 'loaded');
-            mod.loadedAt = Date.now();
-            const result = {
-                success: true,
-                modId,
-                dependencies: order.filter((id) => id !== modId),
-                loadTime: performance.now() - startTime,
-            };
-            this.onModLoaded?.(result);
-            return result;
-        }
-        catch (error) {
-            this.registry.setState(modId, 'error', error.message);
-            return {
-                success: false,
-                modId,
-                error: error.message,
-                dependencies: order,
-                loadTime: performance.now() - startTime,
-            };
-        }
-    }
-    async loadAll() {
-        const results = [];
-        const { order } = this.resolver.resolveAll();
-        for (const modId of order) {
-            const result = await this.load(modId);
-            results.push(result);
-        }
-        return results;
-    }
-    // ─── Enable/Disable ────────────────────────────────────
-    async enable(modId) {
-        const mod = this.registry.get(modId);
-        if (!mod || mod.state !== 'loaded') {
-            return false;
-        }
-        try {
-            await mod.exports?.init?.();
-            mod.exports?.onEnable?.();
-            this.registry.setState(modId, 'enabled');
-            this.onModEnabled?.(modId);
-            return true;
-        }
-        catch (error) {
-            this.registry.setState(modId, 'error', error.message);
-            return false;
-        }
-    }
-    async disable(modId) {
-        const mod = this.registry.get(modId);
-        if (!mod || mod.state !== 'enabled') {
-            return false;
-        }
-        try {
-            mod.exports?.onDisable?.();
-            this.registry.setState(modId, 'loaded');
-            this.onModDisabled?.(modId);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async unload(modId) {
-        const mod = this.registry.get(modId);
-        if (!mod) {
-            return false;
-        }
-        if (mod.state === 'enabled') {
-            await this.disable(modId);
-        }
-        try {
-            await mod.exports?.shutdown?.();
-        }
-        catch {
-            // Ignore errors during shutdown
-        }
-        this.registry.setState(modId, 'discovered');
-        return true;
-    }
-    // ─── Configuration ─────────────────────────────────────
-    setModConfig(modId, key, value) {
-        const mod = this.registry.get(modId);
-        if (!mod) {
-            return;
-        }
-        this.registry.setConfig(modId, { [key]: value });
-        mod.exports?.onConfigChange?.(key, value);
-    }
-    getModConfig(modId) {
-        return this.registry.get(modId)?.config;
-    }
-    // ─── Conflicts ─────────────────────────────────────────
-    checkConflicts() {
-        const conflicts = this.conflictDetector.detect();
-        for (const conflict of conflicts) {
-            this.onConflict?.(conflict);
-        }
-        return conflicts;
-    }
-    // ─── Load Order ────────────────────────────────────────
-    getLoadOrder() {
-        return this.registry.getLoadOrder();
-    }
-    setLoadOrder(order) {
-        this.registry.setLoadOrder(order);
-    }
-    moveUp(modId) {
-        const order = this.registry.getLoadOrder();
-        const index = order.indexOf(modId);
-        if (index > 0) {
-            [order[index - 1], order[index]] = [order[index], order[index - 1]];
-            this.registry.setLoadOrder(order);
-        }
-    }
-    moveDown(modId) {
-        const order = this.registry.getLoadOrder();
-        const index = order.indexOf(modId);
-        if (index >= 0 && index < order.length - 1) {
-            [order[index], order[index + 1]] = [order[index + 1], order[index]];
-            this.registry.setLoadOrder(order);
-        }
-    }
-    // ─── Query ─────────────────────────────────────────────
-    getMod(modId) {
-        return this.registry.get(modId);
-    }
-    getAllMods() {
-        return this.registry.getAll();
-    }
-    getEnabledMods() {
-        return this.registry.getEnabled();
-    }
-    getModsByType(type) {
-        return this.registry.getByType(type);
-    }
-    // ─── Update Loop ───────────────────────────────────────
-    update(deltaTime) {
-        for (const mod of this.registry.getEnabled()) {
-            try {
-                mod.exports?.update?.(deltaTime);
-            }
-            catch (error) {
-                console.error(`Error in mod ${mod.manifest.id} update:`, error);
-            }
-        }
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setOnModDiscovered(callback) {
-        this.onModDiscovered = callback;
-    }
-    setOnModLoaded(callback) {
-        this.onModLoaded = callback;
-    }
-    setOnModEnabled(callback) {
-        this.onModEnabled = callback;
-    }
-    setOnModDisabled(callback) {
-        this.onModDisabled = callback;
-    }
-    setOnConflict(callback) {
-        this.onConflict = callback;
-    }
+  constructor(config) {
+    this.config = { ...DEFAULT_MOD_CONFIG, ...config };
+    this.registry = new ModRegistry();
+    this.resolver = new DependencyResolver(this.registry);
+    this.conflictDetector = new ConflictDetector(this.registry);
+  }
+  // ─── Discovery ─────────────────────────────────────────
+  async discover() {
+    return this.registry.getAll().map((m) => m.manifest);
+  }
+  registerMod(manifest) {
+    if (!this.validateManifest(manifest)) {
+      console.warn(`Mod ${manifest.id} has invalid manifest`);
+      return;
+    }
+    if (!isVersionCompatible(
+      this.config.gameVersion,
+      manifest.gameVersionMin,
+      manifest.gameVersionMax
+    )) {
+      const instance = this.registry.register(manifest);
+      instance.state = "incompatible";
+      instance.error = `Requires game version ${manifest.gameVersionMin || "?"} - ${manifest.gameVersionMax || "?"}`;
+      return;
+    }
+    this.registry.register(manifest);
+    this.onModDiscovered?.(manifest);
+  }
+  validateManifest(manifest) {
+    return !!(manifest.id && manifest.name && manifest.version && manifest.entryPoint);
+  }
+  // ─── Loading ───────────────────────────────────────────
+  async load(modId) {
+    const startTime = performance.now();
+    const mod = this.registry.get(modId);
+    if (!mod) {
+      return {
+        success: false,
+        modId,
+        error: "Mod not found",
+        dependencies: [],
+        loadTime: 0
+      };
+    }
+    if (mod.state === "incompatible") {
+      return {
+        success: false,
+        modId,
+        error: mod.error ?? "Incompatible version",
+        dependencies: [],
+        loadTime: 0
+      };
+    }
+    const { order, missing, circular } = this.resolver.resolve(modId);
+    if (missing.length > 0) {
+      const missingIds = missing.map((d) => d.modId).join(", ");
+      return {
+        success: false,
+        modId,
+        error: `Missing dependencies: ${missingIds}`,
+        dependencies: [],
+        loadTime: performance.now() - startTime
+      };
+    }
+    if (circular) {
+      return {
+        success: false,
+        modId,
+        error: "Circular dependency detected",
+        dependencies: order,
+        loadTime: performance.now() - startTime
+      };
+    }
+    for (const depId of order) {
+      if (depId === modId) {
+        continue;
+      }
+      const depMod = this.registry.get(depId);
+      if (depMod && depMod.state === "discovered") {
+        await this.load(depId);
+      }
+    }
+    this.registry.setState(modId, "loading");
+    try {
+      const exports = {};
+      this.registry.setExports(modId, exports);
+      this.registry.setState(modId, "loaded");
+      mod.loadedAt = Date.now();
+      const result = {
+        success: true,
+        modId,
+        dependencies: order.filter((id) => id !== modId),
+        loadTime: performance.now() - startTime
+      };
+      this.onModLoaded?.(result);
+      return result;
+    } catch (error) {
+      this.registry.setState(modId, "error", error.message);
+      return {
+        success: false,
+        modId,
+        error: error.message,
+        dependencies: order,
+        loadTime: performance.now() - startTime
+      };
+    }
+  }
+  async loadAll() {
+    const results = [];
+    const { order } = this.resolver.resolveAll();
+    for (const modId of order) {
+      const result = await this.load(modId);
+      results.push(result);
+    }
+    return results;
+  }
+  // ─── Enable/Disable ────────────────────────────────────
+  async enable(modId) {
+    const mod = this.registry.get(modId);
+    if (!mod || mod.state !== "loaded") {
+      return false;
+    }
+    try {
+      await mod.exports?.init?.();
+      mod.exports?.onEnable?.();
+      this.registry.setState(modId, "enabled");
+      this.onModEnabled?.(modId);
+      return true;
+    } catch (error) {
+      this.registry.setState(modId, "error", error.message);
+      return false;
+    }
+  }
+  async disable(modId) {
+    const mod = this.registry.get(modId);
+    if (!mod || mod.state !== "enabled") {
+      return false;
+    }
+    try {
+      mod.exports?.onDisable?.();
+      this.registry.setState(modId, "loaded");
+      this.onModDisabled?.(modId);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async unload(modId) {
+    const mod = this.registry.get(modId);
+    if (!mod) {
+      return false;
+    }
+    if (mod.state === "enabled") {
+      await this.disable(modId);
+    }
+    try {
+      await mod.exports?.shutdown?.();
+    } catch {
+    }
+    this.registry.setState(modId, "discovered");
+    return true;
+  }
+  // ─── Configuration ─────────────────────────────────────
+  setModConfig(modId, key, value) {
+    const mod = this.registry.get(modId);
+    if (!mod) {
+      return;
+    }
+    this.registry.setConfig(modId, { [key]: value });
+    mod.exports?.onConfigChange?.(key, value);
+  }
+  getModConfig(modId) {
+    return this.registry.get(modId)?.config;
+  }
+  // ─── Conflicts ─────────────────────────────────────────
+  checkConflicts() {
+    const conflicts = this.conflictDetector.detect();
+    for (const conflict of conflicts) {
+      this.onConflict?.(conflict);
+    }
+    return conflicts;
+  }
+  // ─── Load Order ────────────────────────────────────────
+  getLoadOrder() {
+    return this.registry.getLoadOrder();
+  }
+  setLoadOrder(order) {
+    this.registry.setLoadOrder(order);
+  }
+  moveUp(modId) {
+    const order = this.registry.getLoadOrder();
+    const index = order.indexOf(modId);
+    if (index > 0) {
+      [order[index - 1], order[index]] = [order[index], order[index - 1]];
+      this.registry.setLoadOrder(order);
+    }
+  }
+  moveDown(modId) {
+    const order = this.registry.getLoadOrder();
+    const index = order.indexOf(modId);
+    if (index >= 0 && index < order.length - 1) {
+      [order[index], order[index + 1]] = [order[index + 1], order[index]];
+      this.registry.setLoadOrder(order);
+    }
+  }
+  // ─── Query ─────────────────────────────────────────────
+  getMod(modId) {
+    return this.registry.get(modId);
+  }
+  getAllMods() {
+    return this.registry.getAll();
+  }
+  getEnabledMods() {
+    return this.registry.getEnabled();
+  }
+  getModsByType(type) {
+    return this.registry.getByType(type);
+  }
+  // ─── Update Loop ───────────────────────────────────────
+  update(deltaTime) {
+    for (const mod of this.registry.getEnabled()) {
+      try {
+        mod.exports?.update?.(deltaTime);
+      } catch (error) {
+        console.error(`Error in mod ${mod.manifest.id} update:`, error);
+      }
+    }
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setOnModDiscovered(callback) {
+    this.onModDiscovered = callback;
+  }
+  setOnModLoaded(callback) {
+    this.onModLoaded = callback;
+  }
+  setOnModEnabled(callback) {
+    this.onModEnabled = callback;
+  }
+  setOnModDisabled(callback) {
+    this.onModDisabled = callback;
+  }
+  setOnConflict(callback) {
+    this.onConflict = callback;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createModLoader(config) {
-    return new ModLoader(config);
+  return new ModLoader(config);
 }
 function createModManifest(id, name, version, entryPoint, options) {
-    return {
-        id,
-        name,
-        version,
-        description: options?.description ?? '',
-        author: options?.author ?? 'Unknown',
-        type: options?.type ?? 'content',
-        gameVersion: options?.gameVersion ?? '1.0.0',
-        dependencies: options?.dependencies ?? [],
-        conflicts: options?.conflicts ?? [],
-        entryPoint,
-        tags: options?.tags ?? [],
-        ...options,
-    };
+  return {
+    id,
+    name,
+    version,
+    description: options?.description ?? "",
+    author: options?.author ?? "Unknown",
+    type: options?.type ?? "content",
+    gameVersion: options?.gameVersion ?? "1.0.0",
+    dependencies: options?.dependencies ?? [],
+    conflicts: options?.conflicts ?? [],
+    entryPoint,
+    tags: options?.tags ?? [],
+    ...options
+  };
 }
-
-export { ConflictDetector, DEFAULT_MOD_CONFIG, DependencyResolver, ModLoader, ModRegistry, compareVersions, createModLoader, createModManifest, isVersionCompatible, parseVersion };
+export {
+  ConflictDetector,
+  DEFAULT_MOD_CONFIG,
+  DependencyResolver,
+  ModLoader,
+  ModRegistry,
+  compareVersions,
+  createModLoader,
+  createModManifest,
+  isVersionCompatible,
+  parseVersion
+};