@kotori-bot/loader 1.5.1 → 1.6.0

package/lib/class/runner.d.ts

@@ -1,11 +1,13 @@
 import { Context, LocaleType, ModuleConfig, Symbols } from '@kotori-bot/core';
 import { BUILD_MODE, DEV_MODE, DEV_SOURCE_MODE } from '../constants';
+import '../types/internal';
 import './loader';
 interface BaseDir {
     root: string;
     modules: string;
     data: string;
     logs: string;
+    config: string;
 }
 interface Options {
     mode: typeof BUILD_MODE | typeof DEV_MODE | typeof DEV_SOURCE_MODE;

package/lib/class/runner.js

@@ -1,234 +1,325 @@
+
+/**
+ * @Package @kotori-bot/loader
+ * @Version 1.6.0-beta.1
+ * @Author Hotaru <biyuehuya@gmail.com>
+ * @Copyright 2024 Hotaru. All rights reserved.
+ * @License GPL-3.0
+ * @Link https://github.com/kotorijs/kotori
+ * @Date 2024/6/6 21:03:54
+ */
+
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/class/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  Runner: () => Runner,
+  default: () => runner_default,
+  localeTypeSchema: () => localeTypeSchema
+});
+module.exports = __toCommonJS(runner_exports);
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_core4 = require("@kotori-bot/core");
+var import_logger3 = require("@kotori-bot/logger");
+
+// src/constants.ts
+var DEV_FILE = ".ts";
+var BUILD_FILE = ".js";
+var DEV_CODE_DIRS = "./src/";
+var DEV_IMPORT = `${DEV_CODE_DIRS}index.ts`;
+var DEV_MODE = "dev";
+var DEV_SOURCE_MODE = "dev-source";
+var CORE_MODULES = [
+  "@kotori-bot/kotori-plugin-core",
+  "@kotori-bot/kotori-plugin-i18n-command",
+  "@kotori-bot/kotori-plugin-filter"
+  // '@kotori-bot/kotori-plugin-webui'
+];
+
+// src/utils/logger.ts
+var import_logger = require("@kotori-bot/logger");
+var KotoriLogger = class extends import_logger.Logger {
+  constructor(optionsSelf, ctx) {
+    super(optionsSelf);
+    this.optionsSelf = optionsSelf;
+    this.ctx = ctx;
+  }
+  setLabel() {
+    const origin = Object.create(this.optionsSelf.label);
+    const label = this.ctx.identity ? [this.ctx.identity, ...this.optionsSelf.label] : this.optionsSelf.label;
+    this[/* @__PURE__ */ (() => "options")()].label = label;
+    return () => {
+      this[/* @__PURE__ */ (() => "options")()].label = origin;
+    };
+  }
+  fatal(...args) {
+    const dispose = this.setLabel();
+    super.fatal(...args);
+    dispose();
+  }
+  error(...args) {
+    const dispose = this.setLabel();
+    super.error(...args);
+    dispose();
+  }
+  warn(...args) {
+    const dispose = this.setLabel();
+    super.warn(...args);
+    dispose();
+  }
+  info(...args) {
+    const dispose = this.setLabel();
+    super.info(...args);
+    dispose();
+  }
+  record(...args) {
+    const dispose = this.setLabel();
+    super.record(...args);
+    dispose();
+  }
+  debug(...args) {
+    const dispose = this.setLabel();
+    super.debug(...args);
+    dispose();
+  }
+  trace(...args) {
+    const dispose = this.setLabel();
+    super.trace(...args);
+    dispose();
+  }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Runner = exports.localeTypeSchema = void 0;
-const node_fs_1 = __importStar(require("node:fs"));
-const node_path_1 = __importStar(require("node:path"));
-const core_1 = require("@kotori-bot/core");
-const logger_1 = require("@kotori-bot/logger");
-const constants_1 = require("../constants");
-const logger_2 = __importDefault(require("../utils/logger"));
-require("./loader");
-exports.localeTypeSchema = core_1.Tsu.Union([
-    core_1.Tsu.Union([core_1.Tsu.Literal('en_US'), core_1.Tsu.Literal('ja_JP')]),
-    core_1.Tsu.Union([core_1.Tsu.Literal('zh_TW'), core_1.Tsu.Any()])
+var logger_default = KotoriLogger;
+
+// src/class/loader.ts
+var import_core3 = require("@kotori-bot/core");
+var import_node_path2 = __toESM(require("path"));
+var import_node_fs = __toESM(require("fs"));
+var import_logger2 = __toESM(require("@kotori-bot/logger"));
+
+// src/service/server.ts
+var import_core = require("@kotori-bot/core");
+var import_node_http = require("http");
+var import_path_to_regexp = require("path-to-regexp");
+var import_express = __toESM(require("express"));
+var import_ws = __toESM(require("ws"));
+
+// src/service/file.ts
+var import_core2 = require("@kotori-bot/core");
+var import_node_path = require("path");
+
+// src/class/runner.ts
+var localeTypeSchema = import_core4.Tsu.Union([
+  import_core4.Tsu.Union([import_core4.Tsu.Literal("en_US"), import_core4.Tsu.Literal("ja_JP")]),
+  import_core4.Tsu.Union([import_core4.Tsu.Literal("zh_TW"), import_core4.Tsu.Any()])
 ]);
-const modulePackageSchema = core_1.Tsu.Object({
-    name: core_1.Tsu.String().regexp(/kotori-plugin-[a-z]([a-z,0-9]{2,13})\b/),
-    version: core_1.Tsu.String(),
-    description: core_1.Tsu.String(),
-    main: core_1.Tsu.String(),
-    license: core_1.Tsu.Literal('GPL-3.0'),
-    keywords: core_1.Tsu.Custom((val) => Array.isArray(val) && val.includes('kotori') && val.includes('chatbot') && val.includes('kotori-plugin')),
-    author: core_1.Tsu.Union([core_1.Tsu.String(), core_1.Tsu.Array(core_1.Tsu.String())]),
-    peerDependencies: core_1.Tsu.Object({
-        'kotori-bot': core_1.Tsu.String()
-    }),
-    kotori: core_1.Tsu.Object({
-        enforce: core_1.Tsu.Union([core_1.Tsu.Literal('pre'), core_1.Tsu.Literal('post')]).optional(),
-        meta: core_1.Tsu.Object({
-            language: core_1.Tsu.Array(exports.localeTypeSchema).default([])
-        }).default({ language: [] })
-    }).default({
-        enforce: undefined,
-        meta: { language: [] }
-    })
+var modulePackageSchema = import_core4.Tsu.Object({
+  name: import_core4.Tsu.String().regexp(/kotori-plugin-[a-z]([a-z,0-9]{2,13})\b/),
+  version: import_core4.Tsu.String(),
+  description: import_core4.Tsu.String(),
+  main: import_core4.Tsu.String(),
+  license: import_core4.Tsu.Literal("GPL-3.0"),
+  keywords: import_core4.Tsu.Custom(
+    (val) => Array.isArray(val) && val.includes("kotori") && val.includes("chatbot") && val.includes("kotori-plugin")
+  ),
+  author: import_core4.Tsu.Union([import_core4.Tsu.String(), import_core4.Tsu.Array(import_core4.Tsu.String())]),
+  peerDependencies: import_core4.Tsu.Object({
+    "kotori-bot": import_core4.Tsu.String()
+  }),
+  kotori: import_core4.Tsu.Object({
+    enforce: import_core4.Tsu.Union([import_core4.Tsu.Literal("pre"), import_core4.Tsu.Literal("post")]).optional(),
+    meta: import_core4.Tsu.Object({
+      language: import_core4.Tsu.Array(localeTypeSchema).default([])
+    }).default({ language: [] })
+  }).default({
+    enforce: void 0,
+    meta: { language: [] }
+  })
 });
 function moduleLoadOrder(pkg) {
-    if (pkg.name.includes(core_1.DATABASE_PREFIX))
-        return 1;
-    if (pkg.name.includes(core_1.ADAPTER_PREFIX))
-        return 2;
-    // if (CORE_MODULES.includes(pkg.name)) return 3;
-    if (pkg.kotori.enforce === 'pre')
-        return 4;
-    if (!pkg.kotori.enforce)
-        return 5;
-    return 6;
+  if (CORE_MODULES.includes(pkg.name)) return 1;
+  if (pkg.name.includes(import_core4.DATABASE_PREFIX)) return 2;
+  if (pkg.name.includes(import_core4.ADAPTER_PREFIX)) return 3;
+  if (pkg.kotori.enforce === "pre") return 4;
+  if (!pkg.kotori.enforce) return 5;
+  return 6;
 }
-class Runner {
-    baseDir;
-    options;
-    ctx;
-    isDev;
-    isSourceDev;
-    [core_1.Symbols.modules] = new Map();
-    constructor(ctx, config) {
-        this.ctx = ctx;
-        /* handle config */
-        this.baseDir = config.baseDir;
-        this.options = config.options;
-        this.isDev = this.options.mode.startsWith(constants_1.DEV_MODE);
-        this.isSourceDev = this.options.mode === constants_1.DEV_SOURCE_MODE;
-        const loggerOptions = {
-            level: this.ctx.config.global.level ?? config.level,
-            label: [],
-            transports: [
-                new logger_1.ConsoleTransport(),
-                new logger_1.FileTransport({ dir: this.baseDir.logs, filter: (data) => data.level >= logger_1.LoggerLevel.WARN })
-            ]
-        };
-        ctx.provide('logger', new logger_2.default(loggerOptions, this.ctx));
-        ctx.inject('logger');
-    }
-    getDirFiles(rootDir) {
-        const files = node_fs_1.default.readdirSync(rootDir);
-        const list = [];
-        files.forEach((fileName) => {
-            const file = node_path_1.default.join(rootDir, fileName);
-            if (node_fs_1.default.statSync(file).isDirectory()) {
-                list.push(...this.getDirFiles(file));
-            }
-            if (node_path_1.default.parse(file).ext !== (this.isSourceDev ? constants_1.DEV_FILE : constants_1.BUILD_FILE))
-                return;
-            list.push(node_path_1.default.resolve(file));
-        });
-        return list;
-    }
-    getModuleRootDir() {
-        const moduleRootDir = [];
-        [
-            ...this.ctx.config.global.dirs.map((dir) => node_path_1.default.resolve(this.ctx.baseDir.root, dir)),
-            this.ctx.baseDir.modules
-        ].forEach((dir) => {
-            if (node_fs_1.default.existsSync(dir) && node_fs_1.default.statSync(dir).isDirectory())
-                moduleRootDir.push(dir);
-        });
-        return moduleRootDir;
+var Runner = class {
+  baseDir;
+  options;
+  ctx;
+  isDev;
+  isSourceDev;
+  [import_core4.Symbols.modules] = /* @__PURE__ */ new Map();
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.baseDir = config.baseDir;
+    this.options = config.options;
+    this.isDev = this.options.mode.startsWith(DEV_MODE);
+    this.isSourceDev = this.options.mode === DEV_SOURCE_MODE;
+    const loggerOptions = {
+      level: this.ctx.config.global.level ?? config.level,
+      label: [],
+      transports: [
+        new import_logger3.ConsoleTransport({
+          template: "<blue>%time%</blue> %level% (<bold>%pid%</bold>) %labels%: %msg%",
+          time: "M/D H:m:s"
+        }),
+        new import_logger3.FileTransport({ dir: this.baseDir.logs, filter: (data) => data.level >= import_logger3.LoggerLevel.WARN })
+      ]
+    };
+    ctx.provide("logger", new logger_default(loggerOptions, this.ctx));
+    ctx.inject("logger");
+  }
+  getDirFiles(rootDir) {
+    const files = import_node_fs2.default.readdirSync(rootDir);
+    const list = [];
+    files.forEach((fileName) => {
+      const file = import_node_path3.default.join(rootDir, fileName);
+      if (import_node_fs2.default.statSync(file).isDirectory()) {
+        list.push(...this.getDirFiles(file));
+      }
+      if (import_node_path3.default.parse(file).ext !== (this.isSourceDev ? DEV_FILE : BUILD_FILE)) return;
+      list.push(import_node_path3.default.resolve(file));
+    });
+    return list;
+  }
+  getModuleRootDir() {
+    const moduleRootDir = [];
+    [
+      ...this.ctx.config.global.dirs.map((dir) => import_node_path3.default.resolve(this.ctx.baseDir.root, dir)),
+      this.ctx.baseDir.modules
+    ].forEach((dir) => {
+      if (import_node_fs2.default.existsSync(dir) && import_node_fs2.default.statSync(dir).isDirectory()) moduleRootDir.push(dir);
+    });
+    return moduleRootDir;
+  }
+  async checkModuleFiles(rootDir, filename) {
+    const dir = import_node_path3.default.join(rootDir, filename);
+    if (!import_node_fs2.default.statSync(dir).isDirectory()) return;
+    if (rootDir !== this.ctx.baseDir.modules && !filename.startsWith(import_core4.PLUGIN_PREFIX)) return;
+    const packagePath = import_node_path3.default.join(dir, "package.json");
+    let pkg;
+    if (!import_node_fs2.default.existsSync(packagePath)) return;
+    try {
+      pkg = JSON.parse(import_node_fs2.default.readFileSync(packagePath).toString());
+    } catch {
+      throw new import_core4.DevError(this.ctx.format("error.dev.package.illegal", [packagePath]));
     }
-    async checkModuleFiles(rootDir, filename) {
-        const dir = node_path_1.default.join(rootDir, filename);
-        if (!node_fs_1.default.statSync(dir).isDirectory())
-            return;
-        if (rootDir !== this.ctx.baseDir.modules && !filename.startsWith(core_1.PLUGIN_PREFIX))
-            return;
-        const packagePath = node_path_1.default.join(dir, 'package.json');
-        let pkg;
-        if (!node_fs_1.default.existsSync(packagePath))
-            return;
-        try {
-            pkg = JSON.parse(node_fs_1.default.readFileSync(packagePath).toString());
-        }
-        catch {
-            throw new core_1.DevError(this.ctx.format('error.dev.package.illegal', [packagePath]));
-        }
-        const result = modulePackageSchema.parseSafe(pkg);
-        if (!result.value) {
-            if (rootDir !== this.ctx.baseDir.modules)
-                return;
-            throw new core_1.DevError(this.ctx.format('error.dev.package.missing', [packagePath, result.error.message]));
-        }
-        pkg = result.data;
-        const devMode = this.isSourceDev && (0, node_fs_1.existsSync)(node_path_1.default.resolve(dir, constants_1.DEV_IMPORT));
-        const main = node_path_1.default.resolve(dir, devMode ? constants_1.DEV_IMPORT : pkg.main);
-        if (!node_fs_1.default.existsSync(main))
-            throw new core_1.DevError(this.ctx.format('error.dev.main_file', [main]));
-        const dirs = node_path_1.default.join(dir, devMode ? constants_1.DEV_CODE_DIRS : node_path_1.default.dirname(pkg.main));
-        const files = node_fs_1.default.statSync(dirs).isDirectory() ? this.getDirFiles(dirs) : [];
-        this[core_1.Symbols.modules].set(pkg.name, [
-            { pkg, files, main },
-            this.ctx.config.plugin[(0, core_1.stringRightSplit)(pkg.name, core_1.PLUGIN_PREFIX)] || {}
-        ]);
+    const result = modulePackageSchema.parseSafe(pkg);
+    if (!result.value) {
+      if (rootDir !== this.ctx.baseDir.modules) return;
+      throw new import_core4.DevError(this.ctx.format("error.dev.package.missing", [packagePath, result.error.message]));
     }
-    getModuleList(rootDir) {
-        this.ctx.logger.trace('load dirs:', rootDir);
-        node_fs_1.default.readdirSync(rootDir).forEach(async (filename) => {
-            await this.checkModuleFiles(rootDir, filename);
-        });
+    pkg = result.data;
+    const devMode = this.isSourceDev && (0, import_node_fs2.existsSync)(import_node_path3.default.resolve(dir, DEV_IMPORT));
+    const main = import_node_path3.default.resolve(dir, devMode ? DEV_IMPORT : pkg.main);
+    if (!import_node_fs2.default.existsSync(main)) throw new import_core4.DevError(this.ctx.format("error.dev.main_file", [main]));
+    const dirs = import_node_path3.default.join(dir, devMode ? DEV_CODE_DIRS : import_node_path3.default.dirname(pkg.main));
+    const files = import_node_fs2.default.statSync(dirs).isDirectory() ? this.getDirFiles(dirs) : [];
+    this[import_core4.Symbols.modules].set(pkg.name, [
+      { pkg, files, main },
+      this.ctx.config.plugin[(0, import_core4.stringRightSplit)(pkg.name, import_core4.PLUGIN_PREFIX)] || {}
+    ]);
+  }
+  getModuleList(rootDir) {
+    this.ctx.logger.trace("load dirs:", rootDir);
+    import_node_fs2.default.readdirSync(rootDir).forEach(async (filename) => {
+      await this.checkModuleFiles(rootDir, filename);
+    });
+  }
+  loadLang(lang) {
+    if (lang) this.ctx.i18n.use((0, import_node_path3.resolve)(...Array.isArray(lang) ? lang : [lang]));
+  }
+  loadEx(instance, origin) {
+    this.ctx.logger.trace("module:", instance, origin);
+    if (!instance.main) return;
+    const parsed = (schema) => {
+      const result = schema.parseSafe(config);
+      if (!result.value)
+        throw new import_core4.ModuleError(this.ctx.format("error.module.config", [pkg.name, result.error.message]));
+      return result.data;
+    };
+    const { main, pkg } = instance;
+    let obj = require(main);
+    let config = origin;
+    const adapterName = pkg.name.split(import_core4.ADAPTER_PREFIX)[1];
+    if (this.ctx.get("decorators")?.registers.includes(pkg.name)) {
+      this.ctx.emit("ready_module_decorators", pkg.name);
+      return;
     }
-    loadLang(lang) {
-        if (lang)
-            this.ctx.i18n.use((0, node_path_1.resolve)(...(Array.isArray(lang) ? lang : [lang])));
+    if (import_core4.Adapter.isPrototypeOf.call(import_core4.Adapter, obj.default) && adapterName && (!obj.config || obj.config instanceof import_core4.Parser)) {
+      this.ctx[import_core4.Symbols.adapter].set(adapterName, [obj.default, obj.config]);
+      obj = {};
+    } else if (import_core4.Service.isPrototypeOf.call(import_core4.Service, obj.default)) {
+      obj = {};
+    } else if (obj.config instanceof import_core4.Parser) {
+      config = parsed(obj.config);
     }
-    loadEx(instance, origin) {
-        this.ctx.logger.trace('module:', instance, origin);
-        const parsed = (schema) => {
-            const result = schema.parseSafe(config);
-            if (!result.value)
-                throw new core_1.ModuleError(this.ctx.format('error.module.config', [pkg.name, result.error.message]));
-            return result.data;
-        };
-        const { main, pkg } = instance;
-        /* eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires */
-        let obj = require(main);
-        let config = origin;
-        const adapterName = pkg.name.split(core_1.ADAPTER_PREFIX)[1];
-        if (core_1.Adapter.isPrototypeOf.call(core_1.Adapter, obj.default) &&
-            adapterName &&
-            (!obj.config || obj.config instanceof core_1.Parser)) {
-            /* Adapter Class */
-            this.ctx[core_1.Symbols.adapter].set(adapterName, [obj.default, obj.config]);
-            obj = {};
-        }
-        else if (core_1.Service.isPrototypeOf.call(core_1.Service, obj.default)) {
-            /* Service Class */
-            obj = {};
-        }
-        else if (obj.config instanceof core_1.Parser) {
-            config = parsed(obj.config);
-        }
-        if (obj.lang)
-            this.loadLang(obj.lang);
-        if (obj.default) {
-            if (obj.default.lang)
-                this.loadLang(obj.default.lang);
-            if (obj.default.config instanceof core_1.Parser)
-                config = parsed(obj.default.config);
-        }
-        else if (obj.Main) {
-            if (obj.Main.lang)
-                this.loadLang(obj.Main.lang);
-            if (obj.Main.config instanceof core_1.Parser)
-                config = parsed(obj.Main.config);
-        }
-        this.ctx.load({ name: pkg.name, ...obj, config });
+    if (obj.lang) this.loadLang(obj.lang);
+    if (obj.default) {
+      if (obj.default.lang) this.loadLang(obj.default.lang);
+      if (obj.default.config instanceof import_core4.Parser) config = parsed(obj.default.config);
+    } else if (obj.Main) {
+      if (obj.Main.lang) this.loadLang(obj.Main.lang);
+      if (obj.Main.config instanceof import_core4.Parser) config = parsed(obj.Main.config);
     }
-    unloadEx(instance) {
-        instance.files.forEach((file) => delete require.cache[require.resolve(file)]);
-        this.ctx.load({ name: instance.pkg.name });
-    }
-    loadAll() {
-        this.getModuleRootDir().forEach((dir) => this.getModuleList(dir));
-        const modules = [];
-        this[core_1.Symbols.modules].forEach((val) => modules.push(val));
-        modules
-            .sort((el1, el2) => moduleLoadOrder(el1[0].pkg) - moduleLoadOrder(el2[0].pkg))
-            .forEach((el) => this.loadEx(...el));
-        if (this.isDev)
-            this.watcher();
-    }
-    watcher() {
-        this[core_1.Symbols.modules].forEach((data) => data[0].files.forEach((file) => node_fs_1.default.watchFile(file, async () => {
-            this.ctx.logger.debug(this.ctx.format('loader.debug.reload', [data[0].pkg.name]));
-            this.unloadEx(data[0]);
-            this.loadEx(...data);
-        })));
-    }
-}
-exports.Runner = Runner;
-exports.default = Runner;
+    this.ctx.load({ name: pkg.name, ...obj, config });
+  }
+  unloadEx(instance) {
+    instance.files.forEach((file) => delete require.cache[require.resolve(file)]);
+    this.ctx.load({ name: instance.pkg.name });
+  }
+  loadAll() {
+    this.getModuleRootDir().forEach((dir) => this.getModuleList(dir));
+    const modules = [];
+    this[import_core4.Symbols.modules].forEach((val) => modules.push(val));
+    modules.sort(([{ pkg: pkg1 }], [{ pkg: pkg2 }]) => moduleLoadOrder(pkg1) - moduleLoadOrder(pkg2)).forEach((el) => this.loadEx(...el));
+    if (this.isDev) this.watcher();
+  }
+  watcher() {
+    this[import_core4.Symbols.modules].forEach(
+      (data) => data[0].files.forEach(
+        (file) => import_node_fs2.default.watchFile(file, async () => {
+          this.ctx.logger.debug(this.ctx.format("loader.debug.reload", [data[0].pkg.name]));
+          this.unloadEx(data[0]);
+          this.loadEx(...data);
+        })
+      )
+    );
+  }
+};
+var runner_default = Runner;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Runner,
+  localeTypeSchema
+});

package/lib/constants.d.ts

@@ -2,10 +2,12 @@ export declare const DEV_FILE = ".ts";
 export declare const BUILD_FILE = ".js";
 export declare const DEV_CODE_DIRS = "./src/";
 export declare const DEV_IMPORT = "./src/index.ts";
-export declare const BUILD_CONFIG_NAME = "kotori.yml";
-export declare const DEV_CONFIG_NAME = "kotori.dev.yml";
+export declare const CONFIG_EXT: string[];
+export declare const BUILD_CONFIG_NAME = "kotori";
+export declare const DEV_CONFIG_NAME = "kotori.dev";
 export declare const SUPPORTS_VERSION: RegExp;
 export declare const SUPPORTS_HALF_VERSION: RegExp;
 export declare const BUILD_MODE: "build";
 export declare const DEV_MODE: "dev";
 export declare const DEV_SOURCE_MODE: "dev-source";
+export declare const CORE_MODULES: string[];