mm_machine 2.9.3 → 2.9.4

package/index.js

@@ -1,678 +1,1220 @@
-const { Mod } = require('./mod');
-const { Drive } = require('./drive.js');
+/**
+ * Manager 管理器类
+ * 负责模块注册、检索、执行，支持注册表协同和多种执行模式
+ * @class Manager
+ * @augments Drive
+ */
+var path = require('path');
+var { Drive } = require('./drive');
+var { Registry } = require('./registry');
 
 /**
- * 管理器类
+ * 生命周期状态优先级
+ * 用于 reload 时状态恢复
  */
-class Manager extends Mod {
-  /**
-   * 配置项
-   * @type {object}
-   */
-  static config = {
-    /**
-     * 管理器名称
-     * @type {string}
-     */
-    name: 'manager',
-    /**
-     * 管理器标题
-     * @type {string}
-     */
-    title: '管理器',
-    /**
-     * 管理器描述
-     * @type {string}
-     */
-    description: '用于管理驱动',
-    /**
-     * 检索文件名
-     * @type {string}
-     */
-    filename: 'manager.json',
-    /**
-     * 模板目录
-     * @type {string}
-     */
-    tpl_dir: __dirname,
-    /**
-     * 基础目录，加载模块内置资源
-     * @type {string}
-     */
-    base_dir: '', // '../common/manager'.fullname(__dirname),
-    /**
-     * 自定义目录，加载项目自定义资源
-     * @type {string}
-     */
-    dir: '', // './ai/manager'.fullname(),
-    /**
-     * 搜索模式 dir按目录搜索 | file按文件名搜索
-     * @type {string}
-     */
-    search_way: 'file',
-    /**
-     * 类型 script脚本 | json配置 | drive驱动
-     * @type {string}
-     */
-    mod_type: 'drive',
-    /**
-     * 是否懒加载
-     * @type {boolean}
-     */
-    lazy_load: true,
-    /**
-     * 模式
-     * 1.生产模式，改变文件不会重新加载
-     * 2.热更新模式，改变配置文件会重新加载配置，不重新加载脚本
-     * 3.热重载模式，改变配置文件都会加载配置和脚本
-     * 4.热更新+重载模式，改变配置文件重新加载配置和脚本，执行完后重新加载脚本
-     * 5.重载模式，执行完后重新加载脚本，避免变量污染
-     * @type {number}
-     */
-    mode: 3,
-    /**
-     * 排序项
-     * @type {string}
-     */
-    sort_key: 'sort',
-    /**
-     * 作用域
-     * @type {string}
-     */
-    scope: $.val && $.val.scope ? $.val.scope + '' : 'server',
-    /**
-     * 是否启用快照加速
-     * @type {boolean}
-     */
-    use_snapshot: true,
-    /**
-     * 快照文件路径，留空则自动生成到 cache/snapshot/ 目录下
-     * @type {string}
-     */
-    snapshot_file: ''
-  };
+var statePriority = {
+  created: 0,
+  loaded: 1,
+  inited: 2,
+  started: 3,
+  paused: 4,
+  ended: 5,
+  destroyed: 6
+};
 
+/**
+ * 静态配置默认值
+ */
+var defaultConfig = {
+  name: 'manager',
+  title: '管理器',
+  description: '模块管理器',
+  dir: '',
+  use_registry: false,
+  registry_file: 'cache/registry.json',
+  lazy_load: 'auto',
+  exec_mode: 1,
+  sort: 100
+};
+
+class Manager extends Drive {
   /**
    * 构造函数
-   * @param {object} config 配置项
-   * @param {object} parent 父项对象
-   * @param {object} mods 模块对象列表
-   * @param {object} Drive 驱动对象
+   * @param {object} cfg 配置参数
+   * @param {string} [cfg.dir] 模块存放目录
+   * @param {boolean} [cfg.use_registry=false] 是否启用注册表
+   * @param {string} [cfg.registry_file='cache/registry.json'] 注册表文件路径
+   * @param {string|boolean} [cfg.lazy_load='auto'] 全局懒加载策略
+   * @param {number} [cfg.exec_mode=1] 事件执行模式
+   * @param parent
+   * @param mods
+   * @param DriveClass
    */
-  constructor(config, parent, mods = {}, Drive) {
-    super(
-      {
-        ...Manager.config,
-        ...config
-      },
-      parent
-    );
-
-    // 模块信息列表 { name: '', sort: 0, available: true, enabled: true }
-    this.infos = [];
-    // 模块
-    this.mods = mods;
-    if (Drive) {
-      this.Drive = Drive;
+  constructor(cfg, parent, mods, DriveClass) {
+    // 兼容旧签名：new Manager(config, parent, mods, Drive)
+    if (parent !== undefined || mods !== undefined) {
+      var config = { ...defaultConfig, ...cfg };
+      // 合并旧 config 中的静态配置
+      if (Manager.config) {
+        config = { ...Manager.config, ...config };
+      }
+      super(config, parent);
+      this._mods = mods || {};
+      this._infos = [];
+      this.registry = null;
+      this.dir = config.dir || '';
+      if (DriveClass) {
+        this.Drive = DriveClass;
+      }
+    } else {
+      var config = { ...defaultConfig, ...cfg };
+      super(config);
+      this._mods = {};
+      this._infos = [];
+      this.registry = null;
+      this.dir = config.dir || '';
     }
   }
-
-  get list() {
-    return this.getList();
-  }
 }
 
+// ==================== 注册表管理 ====================
+
 /**
- * 获取事件触发器
- * @returns {object} 事件触发器
+ * 关联注册表实例
+ * @param {object} registry Registry 实例
  */
-Manager.prototype.getEventer = function () {
-  return $.eventer;
+Manager.prototype.setRegistry = function (registry) {
+  this.registry = registry;
 };
 
 /**
- * 获取所有模块信息
- * @returns {object[]} 模块信息数组
+ * 获取注册表实例
+ * @returns {object|null} Registry 实例
  */
-Manager.prototype.getInfos = function () {
-  return this.infos;
+Manager.prototype.getRegistry = function () {
+  return this.registry;
 };
 
+// ==================== 模块查询 ====================
+
 /**
- * 创建模块状态模型
- * @param {string} name 模块名
- * @param {number} sort 排序值
- * @param {boolean} state 状态
- * @param {string} file 文件名
- * @returns {object} 模块状态模型
+ * 获取模块
+ * @param {string} name 模块名称
+ * @returns {object|null} 模块实例，不存在返回 null
  */
-Manager.prototype.newInfo = function (name, sort, state, file = '') {
-  return {
-    name,
-    sort,
-    state,
-    enabled: true,
-    file: file || '',
-    get available() {
-      return this.state == true && this.enabled;
-    }
-  };
+Manager.prototype.getMod = function (name) {
+  return this._mods[name];
 };
 
 /**
- * 设置模块信息
- * @param {object} info 模块信息
+ * 获取所有模块
+ * @returns {object} 模块对象 { name: Drive }
  */
-Manager.prototype.setInfo = function (info) {
-  let has = false;
-  for (let i = 0; i < this.infos.length; i++) {
-    let o = this.infos[i];
-    if (o.name == info.name) {
-      this.infos[i] = info;
-      has = true;
-      break;
-    }
-  }
-  if (!has) {
-    this.infos.push(info);
-  }
+Manager.prototype.getMods = function () {
+  return this._mods;
 };
 
 /**
- * 获取所有模块对象
- * @param {string} keyword 查询关键词，判断name、title、description之一是否包含关键词，包含的才返回
- * @returns {object[]} 模块对象数组
+ * 获取模块列表
+ * @param {string} [keyword] 模糊匹配关键词，匹配 name 和 title
+ * @returns {Array<object>} 模块实例数组
  */
 Manager.prototype.getList = function (keyword) {
-  let list = [];
-  for (let i = 0; i < this.infos.length; i++) {
-    let info = this.infos[i];
-    let mod = this.getMod(info.name);
+  var list = [];
+  for (var i = 0; i < this._infos.length; i++) {
+    var info = this._infos[i];
+    var mod = this.getMod(info.name);
     if (!mod) {
       continue;
     }
+    // 合并状态信息
     mod.config.state = info.state;
     list.push(mod);
   }
   if (keyword) {
-    list = list.filter((o) => o.name.includes(keyword) || o.title.includes(keyword) || o.description.includes(keyword));
+    list = list.filter((o) => {
+      return (o.config.name && o.config.name.indexOf(keyword) !== -1) ||
+             (o.config.title && o.config.title.indexOf(keyword) !== -1) ||
+             (o.config.description && o.config.description.indexOf(keyword) !== -1);
+    });
   }
   return list;
 };
 
 /**
- * 获取基础目录
- * @returns {string} 基础目录
+ * 获取模块信息列表
+ * @returns {Array<object>} 模块信息数组
  */
-Manager.prototype.getBaseDir = function () {
-  return this.config.base_dir || __dirname;
+Manager.prototype.getInfos = function () {
+  return this._infos;
 };
 
 /**
- * 获取模板目录
- * @returns {string} 模板目录
+ * 设置模块
+ * @param {string} name 模块名称
+ * @param {object} mod 模块实例
+ * @returns {object|null} 设置的模块实例
  */
-Manager.prototype.getTplDir = function () {
-  return this.config.tpl_dir || __dirname;
+Manager.prototype.setMod = function (name, mod) {
+  this._mods[name] = mod;
+  return this.getMod(name);
 };
 
 /**
- * 默认驱动
+ * 更新模块信息
+ * 部分合并，只覆盖 info 中存在的字段
+ * @param {string} name 模块名称
+ * @param {object} info 要更新的信息字段
  */
-Manager.prototype.Drive = Drive;
+Manager.prototype.setInfo = function (name, info) {
+  // 兼容旧签名：setInfo({ name, sort, state, ... })
+  var info_name = name;
+  var info_data = info;
+  if (typeof name === 'object' && name !== null) {
+    info_data = name;
+    info_name = info_data.name;
+  }
+  if (!info_data || !info_name) {
+    return;
+  }
+  for (var i = 0; i < this._infos.length; i++) {
+    if (this._infos[i].name === info_name) {
+      for (var k in info_data) {
+        this._infos[i][k] = info_data[k];
+      }
+      return;
+    }
+  }
+  // 不存在则追加
+  this._infos.push(info_data);
+};
 
 /**
- * 更新模块信息
+ * 删除模块（仅内存，不删除文件）
+ * @param {string} name 模块名称
+ * @returns {object|null} 删除的模块实例
  */
-Manager.prototype.updateInfo = function () {
-  this.infos = [];
-  let mods = this.getMods();
-  for (let name in mods) {
-    let o = mods[name];
-    let info = this.newInfo(name, o.config.sort, o.config.state, o.config_file);
-    this.infos.push(info);
+Manager.prototype.delMod = function (name) {
+  var mod = this._mods[name];
+  if (mod) {
+    delete this._mods[name];
   }
-  this.sort();
+  return mod;
 };
 
 /**
- * 排序
+ * 清除所有模块
+ * 先遍历调用所有模块的 end() 和 destroy() 清理，再清空内存
  */
-Manager.prototype._sort = function () {
-  var sort_key = this.config.sort_key || 'sort';
-  this.infos.sort((o1, o2) => {
-    let p1 = o1[sort_key] || 100;
-    let p2 = o2[sort_key] || 100;
-    return p1 - p2;
-  });
+Manager.prototype.clearMods = function () {
+  for (var name in this._mods) {
+    var mod = this._mods[name];
+    try {
+      if (mod.lifecycle_state === 'started' || mod.lifecycle_state === 'paused') {
+        mod.end();
+      }
+      if (mod.lifecycle_state === 'ended') {
+        mod.destroy();
+      }
+    } catch {
+      // 清理异常不影响其他模块
+    }
+  }
+  this._mods = {};
+  this._infos = [];
 };
 
+// ==================== 模块注册/创建 ====================
+
 /**
- * 排序
+ * 创建并注册模块
+ * 根据 type 决定实例化类
+ * @param {string} config_file 配置文件路径
+ * @param {object} [cfg] 配置对象，不传则从文件读取
+ * @param {object|string} [script] 脚本内容，不传则从文件读取
+ * @returns {object} 模块实例
  */
-Manager.prototype.sort = function () {
-  this._sort();
+Manager.prototype.registerMod = function (config_file, cfg, script) {
+  var config = cfg || {};
+
+  // 未提供 cfg 时从文件读取
+  if (!config.name && config_file) {
+    try {
+      var content = require(config_file);
+      config = { ...config, ...content };
+    } catch {
+      // 文件读取失败，使用传入的 cfg
+    }
+  }
+
+  // 创建模块实例
+  var mod = this._createModInstance(config);
+  mod.config_file = config_file;
+  mod.mode = config.mode || 3;
+
+  // 注册脚本方法
+  this._regScriptMethods(mod, script);
+
+  this._mods[config.name] = mod;
+  return mod;
 };
 
-// ==== 模块管理接口 ====
 /**
- * 清除所有模块
+ * 根据类型创建模块实例
+ * @param {object} config 配置对象
+ * @returns {object} 模块实例
+ * @private
  */
-Manager.prototype.clearMods = function () {
-  for (let name in this.mods) {
-    delete this.mods[name];
+Manager.prototype._createModInstance = function (config) {
+  var mod_type = config.type || 'plugin';
+  if (mod_type === 'manager') {
+    return new Manager(config);
   }
+  return new Drive(config);
 };
 
 /**
- * 删除模块
- * @param {string} name 模块名
- * @returns {object|null} 删除的模块对象
+ * 注册脚本方法到模块
+ * @param {object} mod 模块实例
+ * @param {object|string} script 脚本内容
+ * @private
  */
-Manager.prototype.delMod = function (name) {
-  let mod = this.mods[name];
-  if (mod) {
-    delete this.mods[name];
+Manager.prototype._regScriptMethods = function (mod, script) {
+  if (!script || typeof script !== 'object') {
+    return;
+  }
+  for (var key in script) {
+    var val = script[key];
+    if (typeof val === 'function') {
+      mod.setMethod(key, val);
+    }
+  }
+}
+
+// 向后兼容：infos 和 mods 通过 getter/setter 暴露
+Object.defineProperty(Manager.prototype, 'infos', {
+  get: function () { return this._infos; },
+  set: function (val) { this._infos = val; }
+});
+Object.defineProperty(Manager.prototype, 'mods', {
+  get: function () { return this._mods; },
+  set: function (val) { this._mods = val; }
+});
+
+/**
+ * 从注册表数据直接创建模块实例（轻量版，0 IO）
+ * 已存在的模块跳过（不重复创建）
+ * @param {object} data 注册表数据
+ * @param {string} data.name 模块名称
+ * @param {string} data.config_file 配置文件路径
+ * @param {string} [data.type] 模块类型
+ * @returns {object|null} 创建的模块实例，已存在返回 null
+ */
+Manager.prototype.registerModEx = function (data) {
+  if (!data || !data.name) {
+    return null;
+  }
+
+  // 去重检查
+  if (this.getMod(data.name)) {
+    return null;
   }
+
+  // 根据 type 选择实例化类
+  var mod_type = data.type || 'plugin';
+  var mod;
+  if (mod_type === 'manager') {
+    mod = new Manager(data);
+  } else {
+    mod = new Drive(data);
+  }
+
+  mod.config_file = data.config_file || '';
+  this._mods[data.name] = mod;
   return mod;
 };
 
 /**
- * 设置模块
- * @param {string} name 模块名
- * @param {object} mod 模块对象
- * @returns {object|null} 设置的模块对象
+ * 创建文件模块并注册
+ * @param {object} cfg 模块配置
+ * @param {string} [file] 目标文件路径，不传则按规则生成
+ * @returns {object} 模块实例
  */
-Manager.prototype.setMod = function (name, mod) {
-  this.mods[name] = mod;
-  return this.getMod(name);
+Manager.prototype.create = function (cfg, file) {
+  if (!cfg || !cfg.name) {
+    throw new TypeError('模块配置必须包含 name 字段');
+  }
+
+  var new_cfg = { ...cfg };
+  var config_file = file || this._resolveConfigFile(new_cfg.name);
+  new_cfg.config_file = config_file;
+
+  // 创建配置文件到磁盘
+  Drive.prototype.createConfigFile(config_file, new_cfg);
+
+  return this.registerMod(config_file, new_cfg);
 };
 
 /**
- * 获取模块
- * @param {string} name 模块名
- * @returns {object|null} 模块对象，若模块则返回模块对象，否则返回null
+ * 构建模块信息对象
+ * @param {object} mod 模块实例
+ * @returns {object} 模块信息
+ * @private
  */
-Manager.prototype.getMod = function (name) {
-  return this.mods[name];
+// eslint-disable-next-line complexity
+Manager.prototype._buildInfo = function (mod) {
+  var cfg = mod.config || {};
+  return {
+    name: cfg.name || '',
+    title: cfg.title || '',
+    main: cfg.main || '',
+    func_name: cfg.func_name || 'main',
+    scope: cfg.scope || 0,
+    sort: cfg.sort || 100,
+    mode: cfg.mode || 3,
+    exec_mode: cfg.exec_mode || 1,
+    dir: mod.getDir ? mod.getDir() : '',
+    config_file: mod.config_file || '',
+    script_file: mod._script || '',
+    // eslint-disable-next-line mm_eslint/variable-name
+    lifecycle_state: mod.lifecycle_state || 'created',
+    is_loaded: !!mod.is_loaded,
+    enabled: cfg.enabled !== false
+  };
 };
 
 /**
- * 获取所有模块
- * @returns {object[]} 模块对象数组
+ * 解析配置文件路径
+ * @param {string} name 模块名称
+ * @returns {string} 配置文件路径
+ * @private
  */
-Manager.prototype.getMods = function () {
-  return this.mods;
+Manager.prototype._resolveConfigFile = function (name) {
+  var base_dir = this.dir || process.cwd();
+  return path.join(base_dir, name, name + '.json');
 };
 
+// ==================== 模块调用 ====================
+
 /**
- * 创建模块
- * @param {string} config_file 配置文件路径
- * @param {object} config 配置项
- * @param {object} script 模块对象
- * @returns {object} 模块对象
- */
-Manager.prototype.newMod = function (config_file, config, script) {
-  let mod;
-  switch (this.config.mod_type) {
-    case 'script':
-      mod = new Mod(config, this);
+ * 调用模块方法
+ * @param {string} name 模块名称，传 null 遍历所有已启用模块
+ * @param {string} [method] 方法名，默认 'main'
+ * @param {*} [params] 参数
+ * @returns {Promise<*|Array>} 执行结果
+ */
+Manager.prototype.main = async function (name, method, params) {
+  var method_name = method || 'main';
+
+  if (name) {
+    // 指定模块
+    var mod = this.getMod(name);
+    if (!mod) {
+      return null;
+    }
+    return this._runMod(mod, method_name, params);
+  }
+
+  // 遍历所有已启用模块
+  var results = [];
+  var mods = this._getSortedMods();
+  for (var i = 0; i < mods.length; i++) {
+    var mod = mods[i];
+    var cfg = mod.config || {};
+    if (cfg.enabled === false) {
+      continue;
+    }
+    try {
+      var result = await this._runMod(mod, method_name, params);
+      results.push({ name: mod.config.name, result: result });
+    } catch (err) {
+      results.push({ name: mod.config.name, error: err });
+    }
+  }
+  return results;
+};
+
+/**
+ * 运行模块方法（自动推进生命周期）
+ * @param {object} mod 模块实例
+ * @param {string} method 方法名
+ * @param {*} params 参数
+ * @returns {Promise<*>} 执行结果
+ * @private
+ */
+Manager.prototype._runMod = async function (mod, method, params) {
+  var state = mod.lifecycle_state;
+
+  try {
+    await this._advanceToStarted(mod, state);
+  } catch (err) {
+    // 生命周期推进失败，透传错误
+    throw err;
+  }
+
+  return mod.call(method, params);
+};
+
+/**
+ * 推进模块到 started 状态
+ * @param {object} mod 模块实例
+ * @param {string} state 当前状态
+ * @returns {Promise<void>}
+ * @private
+ */
+Manager.prototype._advanceToStarted = async function (mod, state) {
+  var mod_name = mod.config.name || '';
+
+  switch (state) {
+    case 'created':
+      await mod.load();
+      await mod.init();
+      await mod.start();
       break;
-    default:
-      // 创建模块
-      mod = new this.Drive(config, this);
+    case 'loaded':
+      await mod.init();
+      await mod.start();
+      break;
+    case 'inited':
+      await mod.start();
+      break;
+    case 'started':
       break;
+    case 'paused':
+      throw new Error('模块 [' + mod_name + '] 已暂停，无法执行');
+    case 'ended':
+      await mod.load();
+      await mod.init();
+      await mod.start();
+      break;
+    case 'destroyed':
+      throw new Error('模块 [' + mod_name + '] 已销毁，无法执行');
+    default:
+      throw new Error('模块 [' + mod_name + '] 状态异常');
   }
-  mod.mode = this.config.mode;
-  mod.loadConfig(config_file);
-  if (script) {
-    for (let key in script) {
-      let obj = script[key];
-      if (typeof obj == 'function') {
-        mod.setMethod(key, obj);
-      } else {
-        mod.setData(key, obj);
-      }
-    }
+};
+
+/**
+ * 获取按 sort 排序的模块列表
+ * @returns {Array<object>} 排序后的模块数组
+ * @private
+ */
+Manager.prototype._getSortedMods = function () {
+  var list = [];
+  for (var name in this._mods) {
+    list.push(this._mods[name]);
   }
-  return mod;
+  list.sort((a, b) => {
+    var sort_a = (a.config && a.config.sort) || 100;
+    var sort_b = (b.config && b.config.sort) || 100;
+    return sort_a - sort_b;
+  });
+  return list;
 };
 
+// ==================== 模块注销/删除 ====================
+
 /**
- * 注册模块
- * @param {string} config_file 配置文件路径
- * @param {object} config 配置项
- * @param {object} script 模块对象
- * @returns {object} 模块对象
+ * 注销模块
+ * 先 end() 卸载，再 delMod 删除内存
+ * @param {string} name 模块名称
+ * @returns {object|null} 注销的模块实例
  */
-Manager.prototype.registerMod = function (config_file, config = {}, script = {}) {
-  let mod = this.newMod(config_file, config, script);
-  this.setMod(mod.config.name, mod);
+Manager.prototype.unreMod = function (name) {
+  var mod = this.getMod(name);
+  if (!mod) {
+    return null;
+  }
+
+  try {
+    if (mod.lifecycle_state === 'started' || mod.lifecycle_state === 'paused') {
+      mod.end();
+    }
+  } catch {
+    // 忽略
+  }
+
+  this.delMod(name);
+  this._removeInfo(name);
   return mod;
 };
 
 /**
- * 加载模块
- * @param {string} name 模块名
- * @returns {Promise<any>} 加载结果
+ * 删除模块（先注销，再删除配置文件+脚本文件）
+ * @param {string} name 模块名称
  */
-Manager.prototype.loadMod = async function (name) {
-  let mod = this.getMod(name);
-  if (mod) {
-    return await mod.do('load');
+Manager.prototype.remove = function (name) {
+  var mod = this.unreMod(name);
+  if (!mod) {
+    return;
+  }
+
+  // 删除配置文件
+  try {
+    if (mod.config_file && require('fs').existsSync(mod.config_file)) {
+      require('fs').unlinkSync(mod.config_file);
+    }
+  } catch {
+    // 忽略
+  }
+
+  // 删除脚本文件
+  try {
+    if (mod._script && require('fs').existsSync(mod._script)) {
+      require('fs').unlinkSync(mod._script);
+    }
+  } catch {
+    // 忽略
   }
-  return null;
 };
 
 /**
- * 卸载模块
- * @param {string} name 模块名
- * @returns {Promise<any>} 卸载结果
+ * 移除模块信息
+ * @param {string} name 模块名称
+ * @private
  */
-Manager.prototype.unloadMod = async function (name) {
-  let mod = this.getMod(name);
-  if (mod) {
-    return await mod.do('unload');
+Manager.prototype._removeInfo = function (name) {
+  for (var i = 0; i < this._infos.length; i++) {
+    if (this._infos[i].name === name) {
+      this._infos.splice(i, 1);
+      return;
+    }
   }
-  return null;
 };
 
+// ==================== 重载模块 ====================
+
 /**
  * 重载模块
- * @param {string} name 模块名
- * @returns {Promise<any>} 重载结果
+ * 清除缓存 → 重新执行生命周期到原状态
+ * @param {string} name 模块名称
+ * @returns {Promise<object>} 重载后的模块状态
  */
-Manager.prototype.reloadMod = async function (name) {
-  let mod = this.getMod(name);
-  if (mod) {
-    return await mod.do('reload');
+Manager.prototype.reload = async function (name) {
+  var mod = this.getMod(name);
+  if (!mod) {
+    throw new Error('模块 [' + name + '] 不存在');
   }
-  return null;
+
+  var current_state = mod.lifecycle_state;
+  var priority = statePriority[current_state] !== undefined ? statePriority[current_state] : 0;
+
+  // 清理：优先级 >= 3 时先 end()
+  if (priority >= 3) {
+    try {
+      await mod.end();
+    } catch {
+      // 忽略
+    }
+  }
+
+  // 清除 require.cache
+  this._clearModCache(mod);
+
+  // 重新执行生命周期到原状态
+  try {
+    await this._restoreModState(mod, priority);
+  } catch (err) {
+    throw err;
+  }
+
+  return mod.lifecycle_state;
 };
 
 /**
- * 注销模块
- * @param {string} name 模块名
- * @returns {Promise<any>} 注销结果
+ * 清除模块的 require 缓存
+ * @param {object} mod 模块实例
+ * @private
  */
-Manager.prototype.unregisterMod = function (name) {
-  // 卸载模块
-  this.unloadMod(name);
-  // 删除模块
-  let mod = this.delMod(name);
-  return mod;
+Manager.prototype._clearModCache = function (mod) {
+  if (!mod._script) {
+    return;
+  }
+  try {
+    var resolved = require.resolve(mod._script);
+    if (require.cache[resolved]) {
+      delete require.cache[resolved];
+    }
+  } catch {
+    // 忽略
+  }
 };
 
 /**
- * 批量注册模块
- * @param {string[]} files 配置文件路径数组
- * @param {object} config 配置项
- * @param {object} script 模块对象
+ * 恢复模块到指定优先级状态
+ * @param {object} mod 模块实例
+ * @param {number} priority 目标优先级
+ * @returns {Promise<void>}
+ * @private
  */
-Manager.prototype.registerMods = function (files, config = {}, script = {}) {
-  for (let file of files) {
-    this.registerMod(file, config, script);
+Manager.prototype._restoreModState = async function (mod, priority) {
+  if (priority >= 1) {
+    await mod.load();
+  }
+  if (priority >= 2) {
+    await mod.init();
+  }
+  if (priority >= 3) {
+    await mod.start();
+  }
+  if (priority >= 4) {
+    await mod.pause();
   }
 };
 
+// ==================== 扫描注册 ====================
+
 /**
- * 加载所有模块
+ * 扫描目录并注册新模块
+ * @param {object} scanner DirScanner 实例
+ * @param {string[]} dirs 要扫描的目录列表
+ * @returns {Promise<number>} 成功注册的模块数量
  */
-Manager.prototype.loadMods = async function () {
-  var promises = [];
-  let mods = this.getMods();
-  for (let name in mods) {
-    let mod = mods[name];
-    promises.push(mod.do('load'));
+Manager.prototype.scanAndRegister = async function (scanner, dirs) {
+  if (!scanner || typeof scanner.scanAndParse !== 'function') {
+    throw new TypeError('scanner 必须包含 scanAndParse 方法');
   }
-  await Promise.all(promises);
+  if (!dirs || !Array.isArray(dirs)) {
+    return 0;
+  }
+
+  var count = 0;
+
+  for (var i = 0; i < dirs.length; i++) {
+    count += this._scanDirModules(scanner, dirs[i]);
+  }
+
+  return count;
 };
 
 /**
- * 获取目录名
- * @returns {string} 目录名
+ * 扫描单个目录并注册模块
+ * @param {object} scanner DirScanner 实例
+ * @param {string} dir 目录路径
+ * @returns {number} 成功注册的模块数量
+ * @private
  */
-Manager.prototype.getDirName = function () {
-  // 前缀，为当前类名
-  let prefix = this.constructor.name.toLowerCase();
-  // 后缀，为配置项名称
-  let name = this.config.name.toLowerCase();
-  // 目录名，为前缀加下划线加后缀
-  return prefix + '_' + name;
+Manager.prototype._scanDirModules = function (scanner, dir) {
+  var count = 0;
+
+  try {
+    var entries = scanner.scanAndParse(dir, '*.json');
+    for (var j = 0; j < entries.length; j++) {
+      var entry = entries[j];
+      var cfg = entry.config;
+      if (cfg && cfg.name && !this.getMod(cfg.name)) {
+        this.registerMod(entry.file, cfg);
+        count++;
+      }
+    }
+  } catch {
+    // 单个目录扫描失败不影响其他目录
+  }
+
+  return count;
 };
 
+// ==================== 启动引导 ====================
+
 /**
- * 获取所有目录下的文件
- * @param {string} dir 目录路径
- * @returns {Array} 文件路径数组
- */
-Manager.prototype._getAllDirFiles = async function (dir) {
-  var dirs = await $.dir.getAllAsync(dir, this.getDirName());
-  var filename = this.config.filename;
-  var results = await Promise.all(dirs.map((d) => $.file.getAllAsync(d, filename)));
-  var files = [];
-  for (var i = 0; i < results.length; i++) {
-    if (results[i].length > 0) {
-      files.push(...results[i]);
+ * 启动引导
+ * 外部入口，根据 use_registry 决定走注册表路径还是旧路径
+ * @returns {Promise<void>}
+ */
+Manager.prototype.boot = async function () {
+  if (this.config.use_registry) {
+    await this._bootWithRegistry();
+  } else {
+    await this._bootWithoutRegistry();
+  }
+};
+
+/**
+ * 注册表路径启动引导
+ * @returns {Promise<void>}
+ * @private
+ */
+Manager.prototype._bootWithRegistry = async function () {
+  if (!this.registry) {
+    this.registry = new Registry(this, {});
+  }
+  await this.registry.boot();
+
+  // 注册表为空时，扫描文件系统
+  if (this.registry.getEntryCount() === 0 && this.dir) {
+    await this._scanAndFillRegistry();
+  }
+};
+
+/**
+ * 旧路径启动引导（直接扫描目录）
+ * @returns {Promise<void>}
+ * @private
+ */
+Manager.prototype._bootWithoutRegistry = async function () {
+  if (!this.dir) {
+    return;
+  }
+
+  var { DirScanner } = require('./dir_scanner');
+  var scanner = new DirScanner();
+  var entries = scanner.scanAndParse(this.dir, '*.json');
+
+  for (var i = 0; i < entries.length; i++) {
+    var entry = entries[i];
+    if (entry.config && entry.config.name) {
+      this.registerMod(entry.file, entry.config);
     }
   }
-  return files;
+
+  // 启动自启动模块
+  await this._startAutoModules();
 };
 
 /**
- * 检索目录下所有文件
+ * 扫描文件系统并填充注册表
+ * @returns {Promise<void>}
  * @private
- * @param {string} dir 目录路径
- * @returns {Array} 文件路径数组
  */
-Manager.prototype._findFiles = async function (dir) {
-  // 检查目录是否存在
-  if (!dir) {
-    this.log('error', '目录不能为空');
-    return [];
+Manager.prototype._scanAndFillRegistry = async function () {
+  var { DirScanner } = require('./dir_scanner');
+  var scanner = new DirScanner();
+  var entries = scanner.scanAndParse(this.dir, '*.json');
+  if (entries.length > 0) {
+    this.registry.registerAll(entries);
+  }
+};
+
+/**
+ * 启动所有自启动模块
+ * @returns {Promise<void>}
+ * @private
+ */
+Manager.prototype._startAutoModules = async function () {
+  var mods = this._getSortedMods();
+  for (var j = 0; j < mods.length; j++) {
+    var mod = mods[j];
+    if (mod.config && mod.config.auto_start) {
+      try {
+        await mod.load();
+        await mod.init();
+        await mod.start();
+      } catch {
+        // 单个模块启动失败不影响其他模块
+      }
+    }
+  }
+};
+
+// ==================== 生命周期传播 ====================
+
+/**
+ * 启动核心
+ * 先调用父类逻辑，再传播到子模块
+ * @returns {Promise<void>}
+ * @private
+ * @override
+ */
+Manager.prototype._startCore = async function () {
+  if (this.lifecycle_state !== 'inited') {
+    if (this.lifecycle_state === 'started') {
+      return;
+    }
+    throw new Error('模块未初始化，无法启动');
+  }
+
+  this.emit('start:before');
+
+  try {
+    var start_hook = this.getMethod('_start');
+    if (start_hook) {
+      var result = start_hook(this);
+      if (result instanceof Promise) {
+        await result;
+      }
+    }
+
+    // 传播到子模块
+    await this._propToChildren('start');
+
+    this.lifecycle_state = 'started';
+    this.emit('start:success');
+  } catch (err) {
+    this.emit('start:error', err);
+    throw err;
+  }
+};
+
+/**
+ * 暂停核心
+ * 先调用父类逻辑，再传播到子模块
+ * @returns {Promise<void>}
+ * @private
+ * @override
+ */
+Manager.prototype._pauseCore = async function () {
+  if (this.lifecycle_state !== 'started') {
+    throw new Error('模块未启动，无法暂停');
+  }
+
+  this.emit('pause:before');
+
+  try {
+    var pause_hook = this.getMethod('_pause');
+    if (pause_hook) {
+      pause_hook(this);
+    }
+
+    // 传播到子模块
+    this._propToChildren('pause');
+
+    this.lifecycle_state = 'paused';
+    this.emit('pause:success');
+  } catch (err) {
+    this.emit('pause:error', err);
+    throw err;
+  }
+};
+
+/**
+ * 恢复核心
+ * 先调用父类逻辑，再传播到子模块
+ * @returns {Promise<void>}
+ * @private
+ * @override
+ */
+Manager.prototype._resumeCore = async function () {
+  if (this.lifecycle_state !== 'paused') {
+    throw new Error('模块未暂停，无法恢复');
   }
-  // 检查目录是否存在
-  if (!dir.hasDir()) {
-    return [];
+
+  this.emit('resume:before');
+
+  try {
+    var resume_hook = this.getMethod('_resume');
+    if (resume_hook) {
+      resume_hook(this);
+    }
+
+    // 传播到子模块
+    await this._propToChildren('resume');
+
+    this.lifecycle_state = 'started';
+    this.emit('resume:success');
+  } catch (err) {
+    this.emit('resume:error', err);
+    throw err;
   }
-  if (this.config.search_way === 'dir') {
-    return await this._getAllDirFiles(dir);
+};
+
+/**
+ * 结束核心
+ * 先调用父类逻辑，再传播到子模块
+ * @returns {Promise<void>}
+ * @private
+ * @override
+ */
+Manager.prototype._endCore = async function () {
+  if (this.lifecycle_state !== 'started' && this.lifecycle_state !== 'paused') {
+    throw new Error('模块未启动或暂停，无法结束');
+  }
+
+  this.emit('end:before');
+
+  try {
+    var end_hook = this.getMethod('_end');
+    if (end_hook) {
+      end_hook(this);
+    }
+
+    // 传播到子模块
+    this._propToChildren('end');
+
+    // 卸载脚本
+    this.unloadScript();
+    this.lifecycle_state = 'ended';
+    this.emit('end:success');
+  } catch (err) {
+    this.emit('end:error', err);
+    throw err;
+  }
+};
+
+/**
+ * 销毁核心
+ * 先调用父类逻辑，再传播到子模块
+ * @returns {Promise<void>}
+ * @private
+ * @override
+ */
+Manager.prototype._destroyCore = async function () {
+  if (this.lifecycle_state !== 'ended') {
+    throw new Error('模块未结束，无法销毁');
+  }
+
+  this.emit('destroy:before');
+
+  try {
+    var destroy_hook = this.getMethod('_onDestroy');
+    if (destroy_hook) {
+      destroy_hook(this);
+    }
+
+    // 传播到子模块
+    this._propToChildren('destroy');
+
+    this._methods = {};
+    this.lifecycle_state = 'destroyed';
+    this.emit('destroy:success');
+  } catch (err) {
+    this.emit('destroy:error', err);
+    throw err;
+  }
+};
+
+/**
+ * 传播生命周期操作到子模块
+ * 最多 3 层深度，异常隔离
+ * @param {string} action 操作名称（start/pause/resume/end/destroy）
+ * @param {number} [cur_depth] 当前深度
+ * @returns {Promise<void>}
+ * @private
+ */
+Manager.prototype._propToChildren = async function (action, cur_depth) {
+  var depth = cur_depth || 0;
+
+  // 3 层深度限制
+  if (depth >= 3) {
+    return;
+  }
+
+  var method_map = {
+    start: 'start',
+    pause: 'pause',
+    resume: 'resume',
+    end: 'end',
+    destroy: 'destroy'
+  };
+
+  var method_name = method_map[action];
+  if (!method_name) {
+    return;
+  }
+
+  for (var name in this._mods) {
+    var mod = this._mods[name];
+    if (typeof mod[method_name] !== 'function') {
+      continue;
+    }
+
+    try {
+      await mod[method_name]();
+    } catch {
+      // 单个模块异常不影响其他模块
+    }
   }
-  // 检索目录下所有文件
-  return await $.file.getAllAsync(dir, this.config.filename);
 };
 
+// ==================== 基础API兼容（旧接口） ====================
+
+/**
+ * 默认驱动类
+ */
+Manager.prototype.Drive = Drive;
+
 /**
- * 获取快照文件路径
- * 默认统一放到 /cache/snapshot/ 目录，文件名由类名+配置名组成
- * @returns {string} 快照文件完整路径
+ * 创建模块信息对象
+ * 兼容旧接口 newInfo(name, sort, state, file)
+ * @param {string} name 模块名
+ * @param {number} sort 排序值
+ * @param {boolean} state 状态
+ * @param {string} [file] 文件路径
+ * @returns {object} 模块信息对象
  */
-Manager.prototype.getSnapshotPath = function () {
-  var snapshot_file = this.config.snapshot_file;
-  if (!snapshot_file) {
-    var class_name = this.constructor.name.toLowerCase();
-    var name = this.config.name || 'default';
-    snapshot_file = `./cache/snapshot/${class_name}_${name}.json`;
-    // 确保目录存在
-    snapshot_file.addDir();
+Manager.prototype.newInfo = function (name, sort, state, file) {
+  return {
+    name: name,
+    sort: sort,
+    state: state,
+    enabled: true,
+    file: file || '',
+    get available() {
+      return this.state == true && this.enabled;
+    }
+  };
+};
+
+/**
+ * 更新模块信息列表
+ * 从 _mods 重新构建 _infos
+ */
+Manager.prototype.updateInfo = function () {
+  this._infos = [];
+  for (var name in this._mods) {
+    var o = this._mods[name];
+    var info = this.newInfo(name, o.config.sort, o.config.state, o.config_file);
+    this._infos.push(info);
   }
-  return snapshot_file.fullname();
+  this._sort();
+};
+
+/**
+ * 内部排序
+ * 按 sort_key 排序 _infos
+ * @private
+ */
+Manager.prototype._sort = function () {
+  var sort_key = this.config.sort_key || 'sort';
+  this._infos.sort((o1, o2) => {
+    var p1 = o1[sort_key] || 100;
+    var p2 = o2[sort_key] || 100;
+    return p1 - p2;
+  });
+};
+
+/**
+ * 排序
+ */
+Manager.prototype.sort = function () {
+  this._sort();
+};
+
+/**
+ * 获取基础目录
+ * @returns {string} 基础目录
+ */
+Manager.prototype.getBaseDir = function () {
+  return this.config.base_dir || '';
+};
+
+/**
+ * 获取模板目录
+ * @returns {string} 模板目录
+ */
+Manager.prototype.getTplDir = function () {
+  return this.config.tpl_dir || '';
+};
+
+/**
+ * 获取目录名
+ * 前缀为当前类名小写，后缀为配置项名称
+ * @returns {string} 目录名
+ */
+Manager.prototype.getDirName = function () {
+  var prefix = this.constructor.name.toLowerCase();
+  var name = this.config.name.toLowerCase();
+  return prefix + '_' + name;
 };
 
+// ==================== 模块生命周期管理 ====================
+
 /**
- * 保存快照数据
- * @param {object} mods_map 目录到模块条目的映射 { dir: [{ file, config }, ...] }
+ * 加载模块
+ * @param {string} name 模块名
+ * @returns {Promise<*>} 加载结果
  */
-Manager.prototype._saveSnapshot = function (mods_map) {
-  try {
-    var snapshot_path = this.getSnapshotPath();
-    var snapshot = {
-      mods_map: mods_map,
-      updated_at: Date.now()
-    };
-    snapshot_path.saveJson(snapshot);
-  } catch (err) {
-    this.log('error', '保存快照失败', err);
+Manager.prototype.loadMod = async function (name) {
+  var mod = this.getMod(name);
+  if (mod) {
+    return await mod.load();
   }
+  return null;
 };
 
 /**
- * 从当前已加载模块刷新快照
- * 确保快照与内存中模块状态一致
+ * 卸载模块（旧接口 unloadMod -> end）
+ * @param {string} name 模块名
+ * @returns {Promise<*>} 卸载结果
  */
-Manager.prototype.refreshSnapshot = function () {
-  if (!this.config.use_snapshot) {
-    return;
-  }
-  var mods_map = {};
-  for (var name in this.mods) {
-    var mod = this.mods[name];
-    var f = mod.config_file;
-    if (!f) {
-      continue;
-    }
-    var dir = this._findSnapshotDir(f);
-    if (!mods_map[dir]) {
-      mods_map[dir] = [];
+Manager.prototype.unloadMod = async function (name) {
+  var mod = this.getMod(name);
+  if (mod) {
+    try {
+      if (mod.lifecycle_state === 'started' || mod.lifecycle_state === 'paused') {
+        await mod.end();
+      }
+    } catch {
+      // 忽略
     }
-    mods_map[dir].push({ file: f, config: mod.config });
+    return mod;
   }
-  this._saveSnapshot(mods_map);
+  return null;
 };
 
 /**
- * 推断配置文件所属的快照检索目录
- * @param {string} file 配置文件路径
- * @returns {string} 检索目录
+ * 重载模块（旧接口 reloadMod）
+ * @param {string} name 模块名
+ * @returns {Promise<*>} 重载结果
  */
-Manager.prototype._findSnapshotDir = function (file) {
-  var base_dir = this.getBaseDir();
-  if (base_dir && file.startsWith(base_dir)) {
-    return base_dir;
-  }
-  var dir = this.getDir();
-  if (dir && file.startsWith(dir)) {
-    return dir;
+Manager.prototype.reloadMod = async function (name) {
+  var mod = this.getMod(name);
+  if (mod) {
+    return await mod.reload();
   }
-  return file.dirname();
+  return null;
 };
 
 /**
- * 加载快照数据
- * @returns {object|null} 快照数据，不存在时返回null
+ * 注销模块
+ * 兼容旧接口 unregisterMod
+ * @param {string} name 模块名称
+ * @returns {object|null} 注销的模块实例
  */
-Manager.prototype._loadSnapshot = function () {
-  try {
-    var snapshot_path = this.getSnapshotPath();
-    if (!snapshot_path.hasFile()) {
-      return null;
-    }
-    var snapshot = snapshot_path.loadJson();
-    if (!snapshot || !snapshot.mods_map) {
-      return null;
-    }
-    return snapshot;
-  } catch (err) {
-    this.log('error', '加载快照失败', err);
-    return null;
-  }
+Manager.prototype.unregisterMod = function (name) {
+  // 先卸载
+  this.unloadMod(name);
+  // 再删除
+  var mod = this.delMod(name);
+  this._removeInfo(name);
+  return mod;
 };
 
 /**
- * 从快照快速加载模块，不进行文件系统扫描和磁盘配置读取
- * 使用快照中的config直接创建模块，跳过loadConfig的IO
- * @param {object} mods_map 目录到模块条目的映射 { dir: [{ file, config }, ...] }
- * @param {boolean} clear 是否清除已有模块
+ * 批量注册模块
+ * @param {string[]} files 配置文件路径数组
+ * @param {object} [cfg] 配置对象
+ * @param {object} [script] 脚本对象
  */
-Manager.prototype._loadFromSnapshot = function (mods_map, clear = true) {
-  if (clear) {
-    this.clearMods();
+Manager.prototype.registerMods = function (files, cfg, script) {
+  if (!files || !Array.isArray(files)) {
+    return;
   }
-  for (var dir in mods_map) {
-    var entries = mods_map[dir];
-    if (!entries || entries.length === 0) {
-      continue;
-    }
-    for (var i = 0; i < entries.length; i++) {
-      var entry = entries[i];
-      var f = entry.file;
-      // 跳过已不存在的文件，等待后台同步处理
-      if (!f.hasFile || !f.hasFile()) {
-        continue;
-      }
-      this._newModFromSnap(f, entry.config);
-    }
+  for (var i = 0; i < files.length; i++) {
+    this.registerMod(files[i], cfg, script);
   }
-  this.updateInfo();
-  this.is_loaded = true;
 };
 
 /**
- * 用快照config创建模块，跳过磁盘读取
- * @param {string} file 配置文件路径
- * @param {object} config 模块配置
- * @returns {object} 模块对象
+ * 加载所有模块的脚本
  */
-Manager.prototype._newModFromSnap = function (file, config) {
-  var mod;
-  if (this.config.mod_type === 'script') {
-    mod = new Mod(config || {}, this);
-  } else {
-    mod = new this.Drive(config || {}, this);
-  }
-  mod.mode = this.config.mode;
-  mod.config_file = file;
-  if (mod._preset) {
-    mod._preset();
+Manager.prototype.loadScripts = async function () {
+  var promises = [];
+  for (var name in this._mods) {
+    var mod = this._mods[name];
+    if (typeof mod.loadScript === 'function') {
+      promises.push(mod.loadScript());
+    }
   }
-  return this.setMod(mod.config.name, mod);
+  await Promise.all(promises);
 };
 
 /**
- * 后台增量同步：扫描文件系统并与快照进行diff，增减模块
- * 使用锁防止多次重入冲突
- * @param {object} snapshot 快照数据
+ * 加载所有模块
  */
-Manager.prototype._syncFromFile = async function (snapshot) {
-  // 防重入锁，避免多次同步同时执行
-  if (this._syncing) {
-    return;
-  }
-  this._syncing = true;
-  try {
-    var old_dirs = snapshot.mods_map || {};
-    var old = this._buildSet(old_dirs);
-
-    // 扫描目录，对所有文件重新注册（含快照已有模块，补全热更新监听和脚本加载）
-    for (var dir in old_dirs) {
-      var current = await this._findFiles(dir);
-      for (var fi = 0; fi < current.length; fi++) {
-        var f = current[fi];
-        this.registerMod(f);
-        old[f] = false;
-      }
-    }
-
-    // 移除已删除的模块
-    await this._removeStale(old);
-    // 加载所有模块脚本（lazy_load时不阻塞但后台仍加载）
-    if (!this.config.lazy_load) {
-      await this.loadScripts();
-    }
-    this.updateInfo();
-    await this._saveSnapshotDirs(Object.keys(old_dirs));
-    // this.log('info', '快照同步完成');
-  } catch (err) {
-    this.log('error', '快照增量同步失败', err);
-  } finally {
-    this._syncing = false;
+Manager.prototype.loadMods = async function () {
+  var promises = [];
+  for (var name in this._mods) {
+    var mod = this._mods[name];
+    promises.push(mod.load());
   }
+  await Promise.all(promises);
 };
 
 /**
  * 构建文件集合
- * @param {object} dirs 目录到模块条目的映射 { dir: [{ file, config }, ...] }
+ * @param {object} dirs 目录到模块条目的映射
  * @returns {object} 文件集合 { file: true }
+ * @private
  */
 Manager.prototype._buildSet = function (dirs) {
   var set = {};
@@ -686,30 +1228,14 @@ Manager.prototype._buildSet = function (dirs) {
 };
 
 /**
- * 移除已删除的模块
- * @param {object} old 旧文件集合，标记为false表示仍存在
- */
-Manager.prototype._removeStale = async function (old) {
-  for (var file in old) {
-    if (old[file] === true) {
-      var mod = this.getMod(file);
-      if (mod) {
-        await this.unloadMod(mod.config.name);
-        this.delMod(mod.config.name);
-      }
-    }
-  }
-};
-
-/**
- * 构建文件到config的映射
- * @returns {object} 文件到config的映射 { file_path: config }
+ * 构建配置映射
+ * @returns {object} 文件到配置的映射
+ * @private
  */
 Manager.prototype._buildConfigMap = function () {
   var map = {};
-  var mods = this.getMods();
-  for (var name in mods) {
-    var mod = mods[name];
+  for (var name in this._mods) {
+    var mod = this._mods[name];
     if (mod.config_file) {
       map[mod.config_file] = mod.config;
     }
@@ -720,8 +1246,9 @@ Manager.prototype._buildConfigMap = function () {
 /**
  * 构建模块条目列表
  * @param {string[]} files 文件路径数组
- * @param {object} config_dict 文件到config的映射
- * @returns {object[]} 模块条目数组 [{ file, config }]
+ * @param {object} config_dict 文件到配置的映射
+ * @returns {Array<{file: string, config: object}>} 模块条目数组
+ * @private
  */
 Manager.prototype._buildEntries = function (files, config_dict) {
   var entries = [];
@@ -736,334 +1263,129 @@ Manager.prototype._buildEntries = function (files, config_dict) {
 };
 
 /**
- * 保存快照目录（含config）
- * @param {string[]} dirs 目录列表
- */
-Manager.prototype._saveSnapshotDirs = async function (dirs) {
-  var new_map = {};
-  var config_dict = this._buildConfigMap();
-  for (var i = 0; i < dirs.length; i++) {
-    var dir = dirs[i];
-    var files = await this._findFiles(dir);
-    new_map[dir] = this._buildEntries(files, config_dict);
-  }
-  this._saveSnapshot(new_map);
-};
-
-/**
- * 加载所有模块的脚本
- */
-Manager.prototype.loadScripts = async function () {
-  var promises = [];
-  let mods = this.getMods();
-  for (let name in mods) {
-    let mod = mods[name];
-    promises.push(mod.call('loadScript'));
-  }
-  await Promise.all(promises);
-};
-
-/**
- * 更新配置前的钩子函数
+ * 更新前的钩子
  */
 Manager.prototype.updateBefore = function () {
-  // this.log('info', '更新配置前的钩子函数');
+  // 空实现，子类可重写
 };
 
 /**
- * 更新配置前的钩子函数
+ * 更新后的钩子
  */
 Manager.prototype.updateAfter = function () {
-  // this.log('info', '更新配置后钩子函数');
+  // 空实现，子类可重写
 };
 
 /**
  * 更新配置
- * @param {string} dir 检索的路径
- * @param {boolean} clear 是否清除缓存
+ * @param {string} dir 检索的目录
+ * @param {boolean} [clear] 是否清除缓存
  */
-Manager.prototype.update = async function (dir, clear = true) {
-  if (clear) {
+Manager.prototype.update = async function (dir, clear) {
+  var do_clear = clear !== false;
+  if (do_clear) {
     this.clearMods();
   }
 
-  var search_dir = dir || this.config.dir;
-  // 查找所有json文件
-  var files = await this._findFiles(search_dir);
-  // 批量注册模块
-  this.registerMods(files);
-  // 更新配置信息
-  this.updateInfo();
-  if (!this.config.lazy_load) {
-    // 批量加载脚本
-    await this.loadScripts();
-  }
-  this.is_loaded = true;
-};
-
-// ==== 高性能调用接口 ====
-/**
- * 调用模块的方法（高性能版本）
- * @param {string} name 模块名
- * @param {string} method 方法名
- * @param {...any} params 参数集合
- * @returns {Promise<any>} 执行结果
- */
-Manager.prototype.main = async function (name, method, ...params) {
-  var result = null;
-  if (name) {
-    let mod = this.getMod(name);
-    if (mod && mod.config?.state === 1) {
-      result = await this._runMod(mod, method, ...params);
-    }
-  } else if (name === null) {
-    result = await this._runAllEnabled(method, ...params);
-  }
-  return result;
-};
-
-/**
- * 私有方法：执行所有模块方法
- * @param {string} method 方法名称
- * @param {...any} params 方法参数集合
- * @returns {Promise<any>} 执行结果
- * @private
- */
-Manager.prototype._runAllEnabled = async function (method, ...params) {
-  var result;
-  for (let i = 0; i < this.infos.length; i++) {
-    let config = this.infos[i];
-    let mod = this.getMod(config.name);
-    if (mod && mod.config?.state === 1) {
-      var ret = null;
-      try {
-        ret = await this._runMod(mod, method, ...params);
-      } catch (err) {
-        $.log.error(`执行模块方法失败: `, err);
-      }
-      if (ret !== null && ret !== undefined) {
-        result = ret;
-        // 如果结果不为空且有结束标志，则停止迭代
-        if (mod.config?.end) {
-          break;
-        }
-      }
-    }
-  }
-  return result;
-};
-
-/**
- * 私有方法：执行模块方法
- * @param {object} mod 模块对象
- * @param {string} method 方法名称
- * @param {...any} params 参数集合
- * @returns {Promise<any>} 执行结果
- * @private
- */
-Manager.prototype._runMod = async function (mod, method, ...params) {
-  if (!mod || !method) return null;
-
-  // 确保模块已加载
-  if (!mod.isLoaded()) {
-    try {
-      await mod.call('loadScript');
-    } catch (err) {
-      $.log.error(`加载模块脚本失败: `, err);
-    }
-  }
-
-  // 执行方法
-  let ret = await mod.call(method, ...params);
-  // 根据模式决定是否重载
-  if (this.mode >= 4) {
-    mod.do('reload');
+  var search_dir = dir || this.dir;
+  if (!search_dir) {
+    return;
   }
 
-  return ret;
-};
-
-/**
- * 初始化管理器
- */
-Manager.prototype._initManager = function () { };
-
-/**
- * 获取公共模块目录
- * @returns {string} 公共模块目录
- */
-Manager.prototype.getBaseDir = function () {
-  return this.config.base_dir;
-};
-
-/**
- * 获取二次开发模块目录
- * @returns {string} 二次开发模块目录
- */
-Manager.prototype.getDir = function () {
-  return this.config.dir || this.getDir();
-};
-
-/**
- * 加载资源
- */
-Manager.prototype._loadSources = async function () {
-  var base_dir = this.getBaseDir();
-  var dir = this.getDir();
+  // 查找所有 json 文件
+  var { DirScanner } = require('./dir_scanner');
+  var scanner = new DirScanner();
+  var entries = scanner.scanAndParse(search_dir, '*.json');
 
-  // 启用快照加速时，优先从快照加载
-  if (this.config.use_snapshot) {
-    var snapshot = this._loadSnapshot();
-    if (snapshot) {
-      // 快照存在，用config快速加载模块
-      this._loadFromSnapshot(snapshot.mods_map);
-      // this.log('info', '已从快照快速加载模块，正在后台同步文件变更...');
-      // 同步等待文件同步完成，确保模块已全部注册后再执行初始化，防止竞态条件
-      await this._syncFromFile(snapshot);
-      return;
+  for (var i = 0; i < entries.length; i++) {
+    var entry = entries[i];
+    if (entry.config && entry.config.name) {
+      this.registerMod(entry.file, entry.config);
     }
   }
 
-  // 无快照时走正常流程
-  if (base_dir) {
-    await this.call('update', base_dir, true);
-    await this.call('update', dir, false);
-  } else {
-    await this.call('update', dir, true);
-  }
-
-  // 首次扫描后保存快照（含config）
-  if (this.config.use_snapshot) {
-    var dirs = [];
-    if (base_dir) {
-      dirs.push(base_dir);
-    }
-    if (dir) {
-      dirs.push(dir);
-    }
-    await this._saveSnapshotDirs(dirs);
+  this.updateInfo();
+  if (!this.config.lazy_load) {
+    await this.loadScripts();
   }
+  this.is_loaded = true;
 };
 
-/**
- * 初始化资源
- */
-Manager.prototype._initSources = async function () {
-  // 通过
-};
-
-/**
- * 初始化公共属性
- */
-Manager.prototype._initCore = async function () {
-  // 初始化管理器
-  this._initManager();
-  // 加载资源
-  await this._loadSources();
-  // 初始化AI客户端
-  await this._initSources();
-};
+// ==================== 执行方法 ====================
 
 /**
- * 执行方法 - 内部方法
- * @param {string} mod 模块对象
+ * 执行模块方法
+ * @param {object} mod 模块对象
  * @param {string} method 方法名称
  * @param {...any} params 参数列表
- * @returns {any} 返回执行结果
+ * @returns {Promise<*>} 执行结果
+ * @private
  */
-Manager.prototype._exec = async function (mod, method, ...params) {
+Manager.prototype._exec = async function (mod, method) {
+  var params = Array.prototype.slice.call(arguments, 2);
   if (mod[method]) {
-    return await mod[method](...params);
+    return await mod[method].apply(mod, params);
   } else {
-    throw new Error(`方法${method}不存在`);
+    throw new Error('方法' + method + '不存在');
   }
 };
 
 /**
- * 执行方法
+ * 执行模块方法
  * @param {string} name 模块名
  * @param {string} method 方法名称
  * @param {...any} params 参数列表
- * @returns {any} 返回执行结果
+ * @returns {Promise<*>} 执行结果
  */
-Manager.prototype.exec = async function (name, method, ...params) {
-  let ret;
+Manager.prototype.exec = async function (name, method) {
+  var params = Array.prototype.slice.call(arguments, 2);
   try {
-    let mod = this.getMod(name);
+    var mod = this.getMod(name);
     if (!mod) {
-      throw new Error(`模块${name}不存在`);
+      throw new Error('模块' + name + '不存在');
     }
-    ret = await this._exec(mod, method, ...params);
+    return await this._exec.apply(this, [mod, method].concat(params));
   } catch (error) {
-    this.log('error', `${method}方法执行失败！`, error);
-  }
-  return ret;
-};
-
-/**
- * 确保所有模块都已加载
- * @returns {Promise} 加载完成
- */
-Manager.prototype._ensureAllLoaded = async function () {
-  var infos = this.getInfos();
-  var promises = [];
-
-  for (var i = 0; i < infos.length; i++) {
-    var mod = this.getMod(infos[i].name);
-    if (mod && !mod.isLoaded()) {
-      ((info) => {
-        promises.push(
-          mod.call('loadScript').catch((err) => {
-            this.log('error', `模块${info.name}加载失败`, err);
-          })
-        );
-      })(infos[i]);
-    }
-  }
-  if (promises.length > 0) {
-    await Promise.all(promises);
+    this.log('error', method + '方法执行失败！', error);
+    return null;
   }
 };
 
 /**
  * 异步触发事件，按顺序执行等待完成
  * @param {string} method 方法名称
- * @param  {...any} params 事件参数
- * @returns {Promise} 事件触发结果
+ * @param {...any} params 事件参数
+ * @returns {Promise<*>} 事件触发结果
  */
-Manager.prototype.runWait = async function (method, ...params) {
-  // 参数校验
+Manager.prototype.runWait = async function (method) {
   if (typeof method !== 'string') {
     throw new TypeError('方法名称必须是字符串');
   }
+  var params = Array.prototype.slice.call(arguments, 1);
+  var result;
+  var infos = this.getInfos();
 
-  let result;
-  let infos = this.getInfos();
-
-  for (let i = 0; i < infos.length; i++) {
-    let info = infos[i];
-    let mod = this.getMod(info.name);
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    var mod = this.getMod(info.name);
     if (!mod) {
-      continue; // 跳过不存在的模块
+      continue;
     }
-    // 确保模块已加载
     if (!mod.isLoaded()) {
       try {
         await mod.call('loadScript');
       } catch (error) {
-        this.log('error', `模块${info.name}加载失败`, error);
-        continue; // 跳过加载失败的模块
+        this.log('error', '模块' + info.name + '加载失败', error);
+        continue;
       }
     }
-
-    // 执行方法
     try {
-      let ret = await mod.do(method, ...params);
+      var ret = await mod.call.apply(mod, [method].concat(params));
       if (ret !== null && ret !== undefined) {
         result = ret;
       }
     } catch (error) {
-      this.log('error', `模块${info.name}执行${method}方法失败`, error);
+      this.log('error', '模块' + info.name + '执行' + method + '方法失败', error);
     }
   }
 
@@ -1073,28 +1395,23 @@ Manager.prototype.runWait = async function (method, ...params) {
 /**
  * 异步触发事件，并发执行不等待
  * @param {string} method 方法名称
- * @param  {...any} params 事件参数
+ * @param {...any} params 事件参数
  * @returns {boolean} 是否成功触发事件
  */
-Manager.prototype.runAsync = async function (method, ...params) {
-  // 参数校验
+Manager.prototype.runAsync = async function (method) {
   if (typeof method !== 'string') {
     throw new TypeError('方法名称必须是字符串');
   }
+  var params = Array.prototype.slice.call(arguments, 1);
+  var infos = this.getInfos();
 
-  // 确保所有模块都已加载
-  await this._ensureAllLoaded();
-
-  let infos = this.getInfos();
-
-  // 并发执行所有方法，不等待结果
-  for (let i = 0; i < infos.length; i++) {
-    let info = infos[i];
-    let mod = this.getMod(info.name);
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    var mod = this.getMod(info.name);
     try {
-      mod.do(method, ...params);
+      mod.call.apply(mod, [method].concat(params));
     } catch (error) {
-      this.log('error', `模块${info.name}执行${method}方法失败`, error);
+      this.log('error', '模块' + info.name + '执行' + method + '方法失败', error);
     }
   }
 
@@ -1104,28 +1421,23 @@ Manager.prototype.runAsync = async function (method, ...params) {
 /**
  * 异步触发事件，并发执行等待完成
  * @param {string} method 方法名称
- * @param  {...any} params 事件参数
- * @returns {Promise} 事件触发结果
+ * @param {...any} params 事件参数
+ * @returns {Promise<Array>} 事件触发结果数组
  */
-Manager.prototype.runAll = async function (method, ...params) {
-  // 参数校验
+Manager.prototype.runAll = async function (method) {
   if (typeof method !== 'string') {
     throw new TypeError('方法名称必须是字符串');
   }
+  var params = Array.prototype.slice.call(arguments, 1);
+  var promises = [];
+  var infos = this.getInfos();
 
-  // 确保所有模块都已加载
-  await this._ensureAllLoaded();
-
-  const promises = [];
-  let infos = this.getInfos();
-
-  // 并发执行所有方法
-  for (let i = 0; i < infos.length; i++) {
-    let info = infos[i];
-    let mod = this.getMod(info.name);
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    var mod = this.getMod(info.name);
     promises.push(
-      mod.do(method, ...params).catch((error) => {
-        return null; // 失败时返回null
+      mod.call.apply(mod, [method].concat(params)).catch(() => {
+        return null;
       })
     );
   }
@@ -1136,29 +1448,22 @@ Manager.prototype.runAll = async function (method, ...params) {
 /**
  * 异步触发事件，竞争执行
  * @param {string} method 方法名称
- * @param  {...any} params 事件参数
- * @returns {Promise} 第一个完成的结果
+ * @param {...any} params 事件参数
+ * @returns {Promise<*>} 第一个完成的结果
  */
-Manager.prototype.runRace = async function (method, ...params) {
-  // 参数校验
+Manager.prototype.runRace = async function (method) {
   if (typeof method !== 'string') {
     throw new TypeError('方法名称必须是字符串');
   }
+  var params = Array.prototype.slice.call(arguments, 1);
+  var promises = [];
+  var infos = this.getInfos();
 
-  // 确保所有模块都已加载
-  await this._ensureAllLoaded();
-
-  const promises = [];
-  let infos = this.getInfos();
-
-  // 竞争执行所有方法
-  for (let i = 0; i < infos.length; i++) {
-    let info = infos[i];
-    let mod = this.getMod(info.name);
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    var mod = this.getMod(info.name);
     promises.push(
-      mod.do(method, ...params).catch((error) => {
-        throw error; // 竞争执行中，失败应该抛出错误
-      })
+      mod.call.apply(mod, [method].concat(params))
     );
   }
 
@@ -1169,62 +1474,34 @@ Manager.prototype.runRace = async function (method, ...params) {
  * 异步触发事件，瀑布流执行
  * @param {string} method 方法名称
  * @param {*} result 初始值
- * @param  {...any} params 事件参数
- * @returns {Promise} 最后一个事件监听者的结果
+ * @param {...any} params 事件参数
+ * @returns {Promise<*>} 最后一个事件监听者的结果
  */
-Manager.prototype.runWaterfall = async function (method, result, ...params) {
-  // 参数校验
+Manager.prototype.runWaterfall = async function (method, result) {
   if (typeof method !== 'string') {
     throw new TypeError('方法名称必须是字符串');
   }
+  var params = Array.prototype.slice.call(arguments, 2);
+  var infos = this.getInfos();
+  var final_result = result;
 
-  let infos = this.getInfos();
-
-  for (let i = 0; i < infos.length; i++) {
-    let info = infos[i];
-    let mod = this.getMod(info.name);
-
-    // 确保模块已加载
-    if (!mod.isLoaded()) {
-      try {
-        await mod.call('loadScript');
-      } catch (error) {
-        this.log('error', `模块${info.name}加载失败`, error);
-        continue; // 跳过加载失败的模块
-      }
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    var mod = this.getMod(info.name);
+    if (!mod) {
+      continue;
     }
-
-    // 执行方法，将前一个结果作为参数传递给下一个
     try {
-      let ret = await mod.do(method, result, ...params);
+      var ret = await mod.call.apply(mod, [method, final_result].concat(params));
       if (ret !== null && ret !== undefined) {
-        result = ret;
+        final_result = ret;
       }
     } catch (error) {
-      this.log('error', `模块${info.name}执行${method}方法失败`, error);
+      this.log('error', '模块' + info.name + '执行' + method + '方法失败', error);
     }
   }
 
-  return result;
-};
-
-/**
- * 异步触发事件，子模块执行
- * @param {string} name 子模块名称
- * @param {string} method 方法名称
- * @param  {...any} params 事件参数
- * @returns {Promise} 事件触发结果
- */
-Manager.prototype.runSubMod = async function (name, method, ...params) {
-  // 参数校验
-  if (typeof method !== 'string') {
-    throw new TypeError('方法名称必须是字符串');
-  }
-  let mod = this.getMod(name);
-  if (!mod) {
-    throw new Error(`模块${name}不存在`);
-  }
-  return await mod.do(method, ...params);
+  return final_result;
 };
 
 /**
@@ -1232,75 +1509,18 @@ Manager.prototype.runSubMod = async function (name, method, ...params) {
  * @param {string} event 事件名
  */
 Manager.prototype.offEvent = function (event) {
-  this.getEventer()?.off(event);
-};
-
-/**
- * 创建模块
- * @param {object} config 模块配置
- * @param {string} file 模块文件路径
- * @returns {string} 创建的模块文件路径
- */
-Manager.prototype.createFile = function (config, file) {
-  if (!config.name) {
-    throw new TypeError('模块名称不能为空');
-  }
-  if (!config.title) {
-    throw new TypeError('模块标题不能为空');
-  }
-  if (!config.description) {
-    throw new TypeError('模块描述不能为空');
-  }
-  if (this.getMod(config.name)) {
-    throw new Error(`创建失败，原因：模块${config.name}已存在`);
+  var eventer = this.getEventer();
+  if (eventer && eventer.off) {
+    eventer.off(event);
   }
-  let mod = new this.Drive(config, this);
-  let f = file;
-  if (!f) {
-    f = `${config.name}/${this.config.filename}`;
-    if (this.config.search_way === 'dir') {
-      let dir_name = this.getDirName();
-      f = `${dir_name}/${f}`;
-    }
-  }
-  f = f.fullname(this.config.dir);
-  mod.createConfigFile(f, config);
-  return f;
-};
-
-/**
- * 创建模块
- * @param {object} config 模块配置
- * @param {string} file 模块文件路径
- * @returns {object} 创建的模块实例
- */
-Manager.prototype.create = function (config, file = '') {
-  let f = this.createFile(config, file);
-  let mod = this.registerMod(f, config);
-  this.refreshSnapshot();
-  return mod;
-};
-
-/**
- * 删除模块
- * @param {string} name 模块名称
- * @returns {object} 删除的模块实例
- */
-Manager.prototype.remove = async function (name) {
-  let mod = this.getMod(name);
-  if (mod) {
-    await mod.remove();
-  }
-  this.unregisterMod(name);
-  this.refreshSnapshot();
-  return mod;
 };
 
 module.exports = {
   Manager,
   Drive,
-  Mod,
+  // eslint-disable-next-line mm_eslint/variable-name
+  Mod: require('./mod').Mod,
   // 向后兼容
   Index: Manager,
   Item: Drive
-};
+};