@eggjs/core 7.0.0-beta.19 → 7.0.0-beta.20

package/dist/index.js

@@ -1,12 +1,2425 @@
-import utils_default from "./utils/index.js";
-import { BaseContextClass } from "./base_context_class.js";
-import { Timing } from "./utils/timing.js";
-import { Lifecycle } from "./lifecycle.js";
-import { CaseStyle, EXPORTS, FULLPATH, FileLoader } from "./loader/file_loader.js";
-import { ClassLoader, ContextLoader } from "./loader/context_loader.js";
-import { sequencify } from "./utils/sequencify.js";
-import { EggLoader } from "./loader/egg_loader.js";
-import { Singleton } from "./singleton.js";
-import { Context, EGG_LOADER, EggCore, KoaApplication, KoaContext, KoaRequest, KoaResponse, Request, Response, Router } from "./egg.js";
+import BuiltinModule from "node:module";
+import { debuglog, format, inspect } from "node:util";
+import path from "node:path";
+import fs from "node:fs";
+import { stat } from "node:fs/promises";
+import { importModule, importResolve, isESM, isSupportTypeScript } from "@eggjs/utils";
+import assert from "node:assert";
+import { Application, Application as KoaApplication, Context as Context$1, Context as KoaContext, Request as KoaRequest, Request as Request$1, Response as KoaResponse, Response as Response$1 } from "@eggjs/koa";
+import { EggConsoleLogger } from "egg-logger";
+import { EggRouter as Router } from "@eggjs/router";
+import { EOL } from "node:os";
+import { EventEmitter } from "node:events";
+import { isAsyncFunction, isClass, isGeneratorFunction, isObject, isPrimitive, isPromise } from "is-type-of";
+import { Ready } from "get-ready";
+import { Ready as Ready$1 } from "ready-callback";
+import { homedir } from "node-homedir";
+import { exists, getParamNames, readJSON, readJSONSync } from "utility";
+import { extend } from "@eggjs/extend2";
+import { register } from "tsconfig-paths";
+import { pathMatching } from "egg-path-matching";
+import { diff, now } from "performance-ms";
+import globby from "globby";
 
+//#region src/utils/index.ts
+const debug$6 = debuglog("egg/core/utils");
+const extensions = (typeof module !== "undefined" && module.constructor.length > 1 ? module.constructor : BuiltinModule)._extensions;
+const extensionNames = Object.keys(extensions).concat([".cjs", ".mjs"]);
+debug$6("Module extensions: %j", extensionNames);
+function getCalleeFromStack(withLine, stackIndex) {
+	stackIndex = stackIndex === void 0 ? 2 : stackIndex;
+	const limit = Error.stackTraceLimit;
+	const prep = Error.prepareStackTrace;
+	Error.prepareStackTrace = prepareObjectStackTrace;
+	Error.stackTraceLimit = 5;
+	const obj = {};
+	Error.captureStackTrace(obj);
+	let callSite = obj.stack[stackIndex];
+	let fileName = "";
+	if (callSite) {
+		fileName = callSite.getFileName();
+		/* istanbul ignore if */
+		if (fileName && fileName.endsWith("egg-mock/lib/app.js")) {
+			callSite = obj.stack[stackIndex + 1];
+			fileName = callSite.getFileName();
+		}
+	}
+	Error.prepareStackTrace = prep;
+	Error.stackTraceLimit = limit;
+	if (!callSite || !fileName) return "<anonymous>";
+	if (!withLine) return fileName;
+	return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
+}
+var utils_default = {
+	deprecated(message) {
+		if (debug$6.enabled) console.trace("[@eggjs/core/deprecated] %s", message);
+		else {
+			console.log("[@eggjs/core/deprecated] %s", message);
+			console.log("[@eggjs/core/deprecated] set NODE_DEBUG=@eggjs/core/utils can show call stack");
+		}
+	},
+	extensions,
+	extensionNames,
+	async existsPath(filepath) {
+		try {
+			await stat(filepath);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+	async loadFile(filepath) {
+		debug$6("[loadFile:start] filepath: %s", filepath);
+		try {
+			const extname = path.extname(filepath);
+			if (extname && !extensionNames.includes(extname) && extname !== ".ts") return fs.readFileSync(filepath);
+			return await importModule(filepath, { importDefaultOnly: true });
+		} catch (e) {
+			if (!(e instanceof Error)) {
+				console.trace(e);
+				throw e;
+			}
+			const err = /* @__PURE__ */ new Error(`[egg/core] load file: ${filepath}, error: ${e.message}`);
+			err.cause = e;
+			debug$6("[loadFile] handle %s error: %s", filepath, e);
+			throw err;
+		}
+	},
+	resolvePath(filepath, options) {
+		return importResolve(filepath, options);
+	},
+	methods: [
+		"head",
+		"options",
+		"get",
+		"put",
+		"patch",
+		"post",
+		"delete"
+	],
+	async callFn(fn, args, ctx) {
+		args = args || [];
+		if (typeof fn !== "function") return;
+		return ctx ? fn.call(ctx, ...args) : fn(...args);
+	},
+	getCalleeFromStack,
+	getResolvedFilename(filepath, baseDir) {
+		return filepath.replace(baseDir + path.sep, "").replace(/[/\\]/g, "/");
+	}
+};
+/**
+* Capture call site stack from v8.
+* https://github.com/v8/v8/wiki/Stack-Trace-API
+*/
+function prepareObjectStackTrace(_obj, stack) {
+	return stack;
+}
+
+//#endregion
+//#region src/base_context_class.ts
+/**
+* BaseContextClass is a base class that can be extended,
+* it's instantiated in context level,
+* {@link Helper}, {@link Service} is extending it.
+*/
+var BaseContextClass = class {
+	ctx;
+	app;
+	config;
+	service;
+	/**
+	* @since 1.0.0
+	*/
+	constructor(ctx) {
+		/**
+		* @member {Context} BaseContextClass#ctx
+		* @since 1.0.0
+		*/
+		this.ctx = ctx;
+		/**
+		* @member {Application} BaseContextClass#app
+		* @since 1.0.0
+		*/
+		this.app = ctx.app;
+		/**
+		* @member {Config} BaseContextClass#config
+		* @since 1.0.0
+		*/
+		this.config = ctx.app.config;
+		/**
+		* @member {Service} BaseContextClass#service
+		* @since 1.0.0
+		*/
+		this.service = ctx.service;
+	}
+};
+
+//#endregion
+//#region src/utils/timing.ts
+const debug$5 = debuglog("egg/core/utils/timing");
+var Timing = class {
+	#enable;
+	#startTime;
+	#map;
+	#list;
+	constructor() {
+		this.#enable = true;
+		this.#map = /* @__PURE__ */ new Map();
+		this.#list = [];
+		this.init();
+	}
+	init() {
+		this.start("Process Start", Date.now() - Math.floor(process.uptime() * 1e3));
+		this.end("Process Start");
+		if ("scriptStartTime" in process && typeof process.scriptStartTime === "number") {
+			this.start("Script Start", process.scriptStartTime);
+			this.end("Script Start");
+		}
+	}
+	start(name, start) {
+		if (!name || !this.#enable) return;
+		if (this.#map.has(name)) this.end(name);
+		start = start || Date.now();
+		if (!this.#startTime) this.#startTime = start;
+		const item = {
+			name,
+			start,
+			pid: process.pid,
+			index: this.#list.length
+		};
+		this.#map.set(name, item);
+		this.#list.push(item);
+		debug$5("start %j", item);
+		return item;
+	}
+	end(name) {
+		if (!name || !this.#enable) return;
+		const item = this.#map.get(name);
+		assert(item, `should run timing.start('${name}') first`);
+		item.end = Date.now();
+		item.duration = item.end - item.start;
+		debug$5("end %j", item);
+		return item;
+	}
+	enable() {
+		this.#enable = true;
+	}
+	disable() {
+		this.#enable = false;
+	}
+	clear() {
+		this.#map.clear();
+		this.#list = [];
+	}
+	toJSON() {
+		return this.#list;
+	}
+	itemToString(timelineEnd, item, times) {
+		const isEnd = typeof item.duration === "number";
+		const duration = isEnd ? item.duration : timelineEnd - item.start;
+		const offset = item.start - this.#startTime;
+		const status = `${duration}ms${isEnd ? "" : " NOT_END"}`;
+		const timespan = Math.floor(Number((offset * times).toFixed(6)));
+		let timeline = Math.floor(Number((duration * times).toFixed(6)));
+		timeline = timeline > 0 ? timeline : 1;
+		const message = `#${item.index} ${item.name}`;
+		return " ".repeat(timespan) + "▇".repeat(timeline) + ` [${status}] - ${message}`;
+	}
+	toString(prefix = "egg start timeline:", width = 50) {
+		const timelineEnd = Date.now();
+		const timelineDuration = timelineEnd - this.#startTime;
+		let times = 1;
+		if (timelineDuration > width) times = width / timelineDuration;
+		return prefix + EOL + this.#list.map((item) => this.itemToString(timelineEnd, item, times)).join(EOL);
+	}
+};
+
+//#endregion
+//#region src/lifecycle.ts
+const debug$4 = debuglog("egg/core/lifecycle");
+var Lifecycle = class extends EventEmitter {
+	#init;
+	#readyObject;
+	#bootHooks;
+	#boots;
+	#isClosed;
+	#closeFunctionSet;
+	loadReady;
+	bootReady;
+	options;
+	readyTimeout;
+	constructor(options) {
+		super();
+		options.logger = options.logger ?? new EggConsoleLogger();
+		this.options = options;
+		this.#readyObject = new Ready();
+		this.#bootHooks = [];
+		this.#boots = [];
+		this.#closeFunctionSet = /* @__PURE__ */ new Set();
+		this.#isClosed = false;
+		this.#init = false;
+		this.timing.start(`${this.options.app.type} Start`);
+		const eggReadyTimeoutEnv = Number.parseInt(process.env.EGG_READY_TIMEOUT_ENV || "10000");
+		assert(Number.isInteger(eggReadyTimeoutEnv), `process.env.EGG_READY_TIMEOUT_ENV ${process.env.EGG_READY_TIMEOUT_ENV} should be able to parseInt.`);
+		this.readyTimeout = eggReadyTimeoutEnv;
+		this.#initReady();
+		this.on("ready_stat", (data) => {
+			this.logger.info("[egg/core/lifecycle:ready_stat] end ready task %s, remain %j", data.id, data.remain);
+		}).on("ready_timeout", (id) => {
+			this.logger.warn("[egg/core/lifecycle:ready_timeout] %s seconds later %s was still unable to finish.", this.readyTimeout / 1e3, id);
+		});
+		this.ready((err) => {
+			this.triggerDidReady(err);
+			debug$4("app ready");
+			this.timing.end(`${this.options.app.type} Start`);
+		});
+	}
+	ready(flagOrFunction) {
+		if (flagOrFunction === void 0) return this.#readyObject.ready();
+		return this.#readyObject.ready(flagOrFunction);
+	}
+	get app() {
+		return this.options.app;
+	}
+	get logger() {
+		return this.options.logger;
+	}
+	get timing() {
+		return this.app.timing;
+	}
+	legacyReadyCallback(name, opt) {
+		const timingKeyPrefix = "readyCallback";
+		const timing = this.timing;
+		const cb = this.loadReady.readyCallback(name, opt);
+		const timingKey = `${timingKeyPrefix} in ` + utils_default.getResolvedFilename(name, this.app.baseDir);
+		this.timing.start(timingKey);
+		debug$4("register legacyReadyCallback");
+		return function legacyReadyCallback(...args) {
+			timing.end(timingKey);
+			debug$4("end legacyReadyCallback");
+			cb(...args);
+		};
+	}
+	addBootHook(bootHootOrBootClass) {
+		assert(this.#init === false, "do not add hook when lifecycle has been initialized");
+		this.#bootHooks.push(bootHootOrBootClass);
+	}
+	addFunctionAsBootHook(hook, fullPath) {
+		assert(this.#init === false, "do not add hook when lifecycle has been initialized");
+		class Boot {
+			static fullPath;
+			app;
+			constructor(app) {
+				this.app = app;
+			}
+			configDidLoad() {
+				hook(this.app);
+			}
+		}
+		Boot.fullPath = fullPath;
+		this.#bootHooks.push(Boot);
+	}
+	/**
+	* init boots and trigger config did config
+	*/
+	init() {
+		debug$4("%s init lifecycle", this.app.type);
+		assert(this.#init === false, "lifecycle have been init");
+		this.#init = true;
+		this.#boots = this.#bootHooks.map((BootHootOrBootClass) => {
+			let instance = BootHootOrBootClass;
+			if (isClass(BootHootOrBootClass)) {
+				instance = new BootHootOrBootClass(this.app);
+				if (!instance.fullPath && "fullPath" in BootHootOrBootClass) instance.fullPath = BootHootOrBootClass.fullPath;
+			}
+			debug$4("[init] add boot instance: %o", instance.fullPath);
+			return instance;
+		});
+	}
+	registerBeforeStart(scope, name) {
+		debug$4("%s add registerBeforeStart, name: %o", this.options.app.type, name);
+		this.#registerReadyCallback({
+			scope,
+			ready: this.loadReady,
+			timingKeyPrefix: "Before Start",
+			scopeFullName: name
+		});
+	}
+	registerBeforeClose(fn, fullPath) {
+		assert(typeof fn === "function", "argument should be function");
+		assert(this.#isClosed === false, "app has been closed");
+		if (fullPath) fn.fullPath = fullPath;
+		this.#closeFunctionSet.add(fn);
+		debug$4("%s register beforeClose at %o, count: %d", this.app.type, fullPath, this.#closeFunctionSet.size);
+	}
+	async close() {
+		const closeFns = Array.from(this.#closeFunctionSet);
+		debug$4("%s start trigger %d beforeClose functions", this.app.type, closeFns.length);
+		for (const fn of closeFns.reverse()) {
+			debug$4("%s trigger beforeClose at %o", this.app.type, fn.fullPath);
+			await utils_default.callFn(fn);
+			this.#closeFunctionSet.delete(fn);
+		}
+		this.app.emit("close");
+		this.removeAllListeners();
+		this.app.removeAllListeners();
+		this.#isClosed = true;
+		debug$4("%s closed", this.app.type);
+	}
+	triggerConfigWillLoad() {
+		debug$4("trigger configWillLoad start");
+		for (const boot of this.#boots) if (typeof boot.configWillLoad === "function") {
+			debug$4("trigger configWillLoad at %o", boot.fullPath);
+			boot.configWillLoad();
+		}
+		debug$4("trigger configWillLoad end");
+		this.triggerConfigDidLoad();
+	}
+	triggerConfigDidLoad() {
+		debug$4("trigger configDidLoad start");
+		for (const boot of this.#boots) {
+			if (typeof boot.configDidLoad === "function") {
+				debug$4("trigger configDidLoad at %o", boot.fullPath);
+				boot.configDidLoad();
+			}
+			if (typeof boot.beforeClose === "function") {
+				const beforeClose = boot.beforeClose.bind(boot);
+				this.registerBeforeClose(beforeClose, boot.fullPath);
+			}
+		}
+		debug$4("trigger configDidLoad end");
+		this.triggerDidLoad();
+	}
+	triggerDidLoad() {
+		debug$4("trigger didLoad start");
+		debug$4("loadReady start");
+		this.loadReady.start();
+		for (const boot of this.#boots) if (typeof boot.didLoad === "function") {
+			const didLoad = boot.didLoad.bind(boot);
+			this.#registerReadyCallback({
+				scope: didLoad,
+				ready: this.loadReady,
+				timingKeyPrefix: "Did Load",
+				scopeFullName: boot.fullPath + ":didLoad"
+			});
+		}
+	}
+	triggerWillReady() {
+		debug$4("trigger willReady start");
+		debug$4("bootReady start");
+		this.bootReady.start();
+		for (const boot of this.#boots) if (typeof boot.willReady === "function") {
+			const willReady = boot.willReady.bind(boot);
+			this.#registerReadyCallback({
+				scope: willReady,
+				ready: this.bootReady,
+				timingKeyPrefix: "Will Ready",
+				scopeFullName: boot.fullPath + ":willReady"
+			});
+		}
+	}
+	triggerDidReady(err) {
+		debug$4("trigger didReady start");
+		return (async () => {
+			for (const boot of this.#boots) if (typeof boot.didReady === "function") {
+				debug$4("trigger didReady at %o", boot.fullPath);
+				try {
+					await boot.didReady(err);
+				} catch (err$1) {
+					debug$4("trigger didReady error at %o, error: %s", boot.fullPath, err$1);
+					this.emit("error", err$1);
+				}
+			}
+			debug$4("trigger didReady end");
+		})();
+	}
+	triggerServerDidReady() {
+		debug$4("trigger serverDidReady start");
+		return (async () => {
+			for (const boot of this.#boots) {
+				if (typeof boot.serverDidReady !== "function") continue;
+				debug$4("trigger serverDidReady at %o", boot.fullPath);
+				try {
+					await boot.serverDidReady();
+				} catch (err) {
+					debug$4("trigger serverDidReady error at %o, error: %s", boot.fullPath, err);
+					this.emit("error", err);
+				}
+			}
+			debug$4("trigger serverDidReady end");
+		})();
+	}
+	#initReady() {
+		debug$4("loadReady init");
+		this.loadReady = new Ready$1({
+			timeout: this.readyTimeout,
+			lazyStart: true
+		});
+		this.#delegateReadyEvent(this.loadReady);
+		this.loadReady.ready((err) => {
+			debug$4("loadReady end, err: %o", err);
+			debug$4("trigger didLoad end");
+			if (err) this.ready(err);
+			else this.triggerWillReady();
+		});
+		debug$4("bootReady init");
+		this.bootReady = new Ready$1({
+			timeout: this.readyTimeout,
+			lazyStart: true
+		});
+		this.#delegateReadyEvent(this.bootReady);
+		this.bootReady.ready((err) => {
+			debug$4("bootReady end, err: %o", err);
+			debug$4("trigger willReady end");
+			this.ready(err || true);
+		});
+	}
+	#delegateReadyEvent(ready) {
+		ready.once("error", (err) => ready.ready(err));
+		ready.on("ready_timeout", (id) => this.emit("ready_timeout", id));
+		ready.on("ready_stat", (data) => this.emit("ready_stat", data));
+		ready.on("error", (err) => this.emit("error", err));
+	}
+	#registerReadyCallback(args) {
+		const { scope, ready, timingKeyPrefix, scopeFullName } = args;
+		if (typeof scope !== "function") throw new TypeError("boot only support function");
+		const name = scopeFullName || utils_default.getCalleeFromStack(true, 4);
+		const timingKey = `${timingKeyPrefix} in ` + utils_default.getResolvedFilename(name, this.app.baseDir);
+		this.timing.start(timingKey);
+		debug$4("[registerReadyCallback] start name: %o", name);
+		const done = ready.readyCallback(name);
+		process.nextTick(async () => {
+			try {
+				await utils_default.callFn(scope);
+				debug$4("[registerReadyCallback] end name: %o", name);
+				done();
+				this.timing.end(timingKey);
+			} catch (e) {
+				let err = e;
+				if (!(err instanceof Error)) err = new Error(format("%s", err));
+				done(err);
+				this.timing.end(timingKey);
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/loader/file_loader.ts
+const debug$3 = debuglog("egg/core/file_loader");
+const FULLPATH = Symbol("EGG_LOADER_ITEM_FULLPATH");
+const EXPORTS = Symbol("EGG_LOADER_ITEM_EXPORTS");
+const CaseStyle = {
+	camel: "camel",
+	lower: "lower",
+	upper: "upper"
+};
+/**
+* Load files from directory to target object.
+* @since 1.0.0
+*/
+var FileLoader = class {
+	static get FULLPATH() {
+		return FULLPATH;
+	}
+	static get EXPORTS() {
+		return EXPORTS;
+	}
+	options;
+	/**
+	* @class
+	* @param {Object} options - options
+	* @param {String|Array} options.directory - directories to be loaded
+	* @param {Object} options.target - attach the target object from loaded files
+	* @param {String} options.match - match the files when load, support glob, default to all js files
+	* @param {String} options.ignore - ignore the files when load, support glob
+	* @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+	* @param {Boolean} options.call - determine whether invoke when exports is function
+	* @param {Boolean} options.override - determine whether override the property when get the same name
+	* @param {Object} options.inject - an object that be the argument when invoke the function
+	* @param {Function} options.filter - a function that filter the exports which can be loaded
+	* @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+	*/
+	constructor(options) {
+		assert(options.directory, "options.directory is required");
+		assert(options.target, "options.target is required");
+		this.options = {
+			caseStyle: CaseStyle.camel,
+			call: true,
+			override: false,
+			...options
+		};
+		if (this.options.lowercaseFirst === true) {
+			utils_default.deprecated("lowercaseFirst is deprecated, use caseStyle instead");
+			this.options.caseStyle = CaseStyle.lower;
+		}
+	}
+	/**
+	* attach items to target object. Mapping the directory to properties.
+	* `app/controller/group/repository.js` => `target.group.repository`
+	* @returns {Object} target
+	* @since 1.0.0
+	*/
+	async load() {
+		const items = await this.parse();
+		const target = this.options.target;
+		for (const item of items) {
+			debug$3("[load] loading item: fullpath: %s, properties: %o", item.fullpath, item.properties);
+			item.properties.reduce((target$1, property, index) => {
+				let obj;
+				const properties = item.properties.slice(0, index + 1).join(".");
+				if (index === item.properties.length - 1) {
+					if (property in target$1 && !this.options.override) throw new Error(`can't overwrite property '${properties}' from ${target$1[property][FULLPATH]} by ${item.fullpath}`);
+					obj = item.exports;
+					if (obj && !isPrimitive(obj)) {
+						Reflect.set(obj, FULLPATH, item.fullpath);
+						Reflect.set(obj, EXPORTS, true);
+					}
+				} else obj = target$1[property] || {};
+				target$1[property] = obj;
+				if (debug$3.enabled) debug$3("[load] loaded item properties: %o => keys: %j, index: %d", properties, Object.keys(obj), index);
+				return obj;
+			}, target);
+		}
+		return target;
+	}
+	/**
+	* Parse files from given directories, then return an items list, each item contains properties and exports.
+	*
+	* For example, parse `app/controller/group/repository.js`
+	*
+	* ```
+	* module.exports = app => {
+	*   return class RepositoryController extends app.Controller {};
+	* }
+	* ```
+	*
+	* It returns a item
+	*
+	* ```
+	* {
+	*   properties: [ 'group', 'repository' ],
+	*   exports: app => { ... },
+	* }
+	* ```
+	*
+	* `Properties` is an array that contains the directory of a filepath.
+	*
+	* `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+	* @returns {Array} items
+	* @since 1.0.0
+	*/
+	async parse() {
+		let files = this.options.match;
+		if (files) files = Array.isArray(files) ? files : [files];
+		else files = isSupportTypeScript() ? ["**/*.(js|ts)", "!**/*.d.ts"] : ["**/*.js"];
+		let ignore = this.options.ignore;
+		if (ignore) {
+			ignore = Array.isArray(ignore) ? ignore : [ignore];
+			ignore = ignore.filter((f) => !!f).map((f) => "!" + f);
+			files = files.concat(ignore);
+		}
+		let directories = this.options.directory;
+		if (!Array.isArray(directories)) directories = [directories];
+		const filter = typeof this.options.filter === "function" ? this.options.filter : null;
+		const items = [];
+		debug$3("[parse] parsing directories: %j", directories);
+		for (const directory of directories) {
+			const filepaths = globby.sync(files, { cwd: directory });
+			debug$3("[parse] globby files: %o, cwd: %o => %o", files, directory, filepaths);
+			for (const filepath of filepaths) {
+				const fullpath = path.join(directory, filepath);
+				if (!fs.statSync(fullpath).isFile()) continue;
+				if (filepath.endsWith(".js")) {
+					const filepathTs = filepath.replace(/\.js$/, ".ts");
+					if (filepaths.includes(filepathTs)) {
+						debug$3("[parse] ignore %s, because %s exists", fullpath, filepathTs);
+						continue;
+					}
+				}
+				const properties = getProperties(filepath, this.options.caseStyle);
+				const pathName = directory.split(/[/\\]/).slice(-1) + "." + properties.join(".");
+				const exports = await getExports(fullpath, this.options, pathName);
+				if (exports === null || exports === void 0 || filter && filter(exports) === false) continue;
+				if (isClass(exports)) {
+					exports.prototype.pathName = pathName;
+					exports.prototype.fullPath = fullpath;
+				}
+				items.push({
+					fullpath,
+					properties,
+					exports
+				});
+				debug$3("[parse] parse %s, properties %j, exports %o", fullpath, properties, exports);
+			}
+		}
+		return items;
+	}
+};
+function getProperties(filepath, caseStyle) {
+	if (typeof caseStyle === "function") {
+		const result = caseStyle(filepath);
+		assert(Array.isArray(result), `caseStyle expect an array, but got ${JSON.stringify(result)}`);
+		return result;
+	}
+	return defaultCamelize(filepath, caseStyle);
+}
+async function getExports(fullpath, options, pathName) {
+	let exports = await utils_default.loadFile(fullpath);
+	if (options.initializer) {
+		exports = options.initializer(exports, {
+			path: fullpath,
+			pathName
+		});
+		debug$3("[getExports] after initializer => %o", exports);
+	}
+	if (isGeneratorFunction(exports)) throw new TypeError(`Support for generators was removed, fullpath: ${fullpath}`);
+	if (isClass(exports) || isAsyncFunction(exports)) return exports;
+	if (options.call && typeof exports === "function") {
+		exports = exports(options.inject);
+		if (exports !== null && exports !== void 0) return exports;
+	}
+	return exports;
+}
+function defaultCamelize(filepath, caseStyle) {
+	return filepath.slice(0, filepath.lastIndexOf(".")).split("/").map((property) => {
+		if (!/^[a-z][a-z0-9_-]*$/i.test(property)) throw new Error(`${property} is not match 'a-z0-9_-' in ${filepath}`);
+		property = property.replaceAll(/[_-][a-z]/gi, (s) => s.slice(1).toUpperCase());
+		let first = property[0];
+		if (caseStyle === CaseStyle.lower) first = first.toLowerCase();
+		else if (caseStyle === CaseStyle.upper) first = first.toUpperCase();
+		return first + property.slice(1);
+	});
+}
+
+//#endregion
+//#region src/loader/context_loader.ts
+const CLASS_LOADER = Symbol("classLoader");
+var ClassLoader = class {
+	_cache = /* @__PURE__ */ new Map();
+	_ctx;
+	constructor(options) {
+		assert(options.ctx, "options.ctx is required");
+		const properties = options.properties;
+		this._ctx = options.ctx;
+		for (const property in properties) this.#defineProperty(property, properties[property]);
+	}
+	#defineProperty(property, values) {
+		Object.defineProperty(this, property, { get() {
+			let instance = this._cache.get(property);
+			if (!instance) {
+				instance = getInstance(values, this._ctx);
+				this._cache.set(property, instance);
+			}
+			return instance;
+		} });
+	}
+};
+/**
+* Same as {@link FileLoader}, but it will attach file to `inject[fieldClass]`.
+* The exports will be lazy loaded, such as `ctx.group.repository`.
+* @augments FileLoader
+* @since 1.0.0
+*/
+var ContextLoader = class extends FileLoader {
+	#inject;
+	/**
+	* @class
+	* @param {Object} options - options same as {@link FileLoader}
+	* @param {String} options.fieldClass - determine the field name of inject object.
+	*/
+	constructor(options) {
+		assert(options.property, "options.property is required");
+		assert(options.inject, "options.inject is required");
+		const target = {};
+		if (options.fieldClass) options.inject[options.fieldClass] = target;
+		super({
+			...options,
+			target
+		});
+		this.#inject = this.options.inject;
+		const app = this.#inject;
+		const property = options.property;
+		Object.defineProperty(app.context, property, { get() {
+			const ctx = this;
+			if (!ctx[CLASS_LOADER]) ctx[CLASS_LOADER] = /* @__PURE__ */ new Map();
+			const classLoader = ctx[CLASS_LOADER];
+			let instance = classLoader.get(property);
+			if (!instance) {
+				instance = getInstance(target, ctx);
+				classLoader.set(property, instance);
+			}
+			return instance;
+		} });
+	}
+};
+function getInstance(values, ctx) {
+	const Class = values[EXPORTS] ? values : null;
+	let instance;
+	if (Class) if (isClass(Class)) instance = new Class(ctx);
+	else instance = Class;
+	else if (isPrimitive(values)) instance = values;
+	else instance = new ClassLoader({
+		ctx,
+		properties: values
+	});
+	return instance;
+}
+
+//#endregion
+//#region src/utils/sequencify.ts
+const debug$2 = debuglog("egg/core/utils/sequencify");
+function sequence(tasks, names, result, missing, recursive, nest, optional, parent) {
+	for (const name of names) {
+		if (result.requires[name]) continue;
+		const node = tasks[name];
+		if (!node) {
+			if (optional === true) continue;
+			missing.push(name);
+		} else if (nest.includes(name)) {
+			nest.push(name);
+			recursive.push(...nest.slice(0));
+			nest.pop();
+		} else if (node.dependencies.length > 0 || node.optionalDependencies.length > 0) {
+			nest.push(name);
+			if (node.dependencies.length > 0) sequence(tasks, node.dependencies, result, missing, recursive, nest, optional, name);
+			if (node.optionalDependencies.length > 0) sequence(tasks, node.optionalDependencies, result, missing, recursive, nest, true, name);
+			nest.pop();
+		}
+		if (!optional) {
+			result.requires[name] = true;
+			debug$2("task: %s is enabled by %s", name, parent);
+		}
+		if (!result.sequence.includes(name)) result.sequence.push(name);
+	}
+}
+function sequencify(tasks, names) {
+	const result = {
+		sequence: [],
+		requires: {}
+	};
+	const missing = [];
+	const recursive = [];
+	sequence(tasks, names, result, missing, recursive, [], false, "app");
+	if (missing.length > 0 || recursive.length > 0) result.sequence = [];
+	return {
+		sequence: result.sequence.filter((item) => result.requires[item]),
+		missingTasks: missing,
+		recursiveDependencies: recursive
+	};
+}
+
+//#endregion
+//#region src/loader/egg_loader.ts
+const debug$1 = debuglog("egg/core/loader/egg_loader");
+const originalPrototypes = {
+	request: Request$1.prototype,
+	response: Response$1.prototype,
+	context: Context$1.prototype,
+	application: Application.prototype
+};
+var EggLoader = class {
+	#requiredCount = 0;
+	options;
+	timing;
+	pkg;
+	eggPaths;
+	serverEnv;
+	serverScope;
+	appInfo;
+	dirs;
+	/**
+	* @class
+	* @param {Object} options - options
+	* @param {String} options.baseDir - the directory of application
+	* @param {EggCore} options.app - Application instance
+	* @param {Logger} options.logger - logger
+	* @param {Object} [options.plugins] - custom plugins
+	* @since 1.0.0
+	*/
+	constructor(options) {
+		this.options = options;
+		assert(fs.existsSync(this.options.baseDir), `${this.options.baseDir} not exists`);
+		assert(this.options.app, "options.app is required");
+		assert(this.options.logger, "options.logger is required");
+		this.timing = this.app.timing || new Timing();
+		/**
+		* @member {Object} EggLoader#pkg
+		* @see {@link AppInfo#pkg}
+		* @since 1.0.0
+		*/
+		this.pkg = readJSONSync(path.join(this.options.baseDir, "package.json"));
+		if (process.env.EGG_TYPESCRIPT === "true" || this.pkg.egg && this.pkg.egg.typescript) {
+			const tsConfigFile = path.join(this.options.baseDir, "tsconfig.json");
+			if (fs.existsSync(tsConfigFile)) register({ cwd: this.options.baseDir });
+			else this.logger.info("[@eggjs/core/egg_loader] skip register \"tsconfig-paths\" because tsconfig.json not exists at %s", tsConfigFile);
+		}
+		/**
+		* All framework directories.
+		*
+		* You can extend Application of egg, the entry point is options.app,
+		*
+		* loader will find all directories from the prototype of Application,
+		* you should define `Symbol.for('egg#eggPath')` property.
+		*
+		* ```ts
+		* // src/example.ts
+		* import { Application } from 'egg';
+		* class ExampleApplication extends Application {
+		*   get [Symbol.for('egg#eggPath')]() {
+		*     return baseDir;
+		*   }
+		* }
+		* ```
+		* @member {Array} EggLoader#eggPaths
+		* @see EggLoader#getEggPaths
+		* @since 1.0.0
+		*/
+		this.eggPaths = this.getEggPaths();
+		debug$1("Loaded eggPaths %j", this.eggPaths);
+		/**
+		* @member {String} EggLoader#serverEnv
+		* @see AppInfo#env
+		* @since 1.0.0
+		*/
+		this.serverEnv = this.getServerEnv();
+		debug$1("Loaded serverEnv %j", this.serverEnv);
+		/**
+		* @member {String} EggLoader#serverScope
+		* @see AppInfo#serverScope
+		*/
+		this.serverScope = options.serverScope ?? this.getServerScope();
+		/**
+		* @member {AppInfo} EggLoader#appInfo
+		* @since 1.0.0
+		*/
+		this.appInfo = this.getAppInfo();
+	}
+	get app() {
+		return this.options.app;
+	}
+	get lifecycle() {
+		return this.app.lifecycle;
+	}
+	get logger() {
+		return this.options.logger;
+	}
+	/**
+	* Get {@link AppInfo#env}
+	* @returns {String} env
+	* @see AppInfo#env
+	* @private
+	* @since 1.0.0
+	*/
+	getServerEnv() {
+		let serverEnv = this.options.env;
+		const envPath = path.join(this.options.baseDir, "config/env");
+		if (!serverEnv && fs.existsSync(envPath)) serverEnv = fs.readFileSync(envPath, "utf8").trim();
+		if (!serverEnv && process.env.EGG_SERVER_ENV) serverEnv = process.env.EGG_SERVER_ENV;
+		if (serverEnv) serverEnv = serverEnv.trim();
+		else if (process.env.NODE_ENV === "test") serverEnv = "unittest";
+		else if (process.env.NODE_ENV === "production") serverEnv = "prod";
+		else serverEnv = "local";
+		return serverEnv;
+	}
+	/**
+	* Get {@link AppInfo#scope}
+	* @returns {String} serverScope
+	* @private
+	*/
+	getServerScope() {
+		return process.env.EGG_SERVER_SCOPE ?? "";
+	}
+	/**
+	* Get {@link AppInfo#name}
+	* @returns {String} appname
+	* @private
+	* @since 1.0.0
+	*/
+	getAppname() {
+		if (this.pkg.name) {
+			debug$1("Loaded appname(%s) from package.json", this.pkg.name);
+			return this.pkg.name;
+		}
+		const pkg = path.join(this.options.baseDir, "package.json");
+		throw new Error(`name is required from ${pkg}`);
+	}
+	/**
+	* Get home directory
+	* @returns {String} home directory
+	* @since 3.4.0
+	*/
+	getHomedir() {
+		return process.env.EGG_HOME || homedir() || "/home/admin";
+	}
+	/**
+	* Get app info
+	* @returns {AppInfo} appInfo
+	* @since 1.0.0
+	*/
+	getAppInfo() {
+		const env = this.serverEnv;
+		const scope = this.serverScope;
+		const home = this.getHomedir();
+		const baseDir = this.options.baseDir;
+		/**
+		* Meta information of the application
+		* @class AppInfo
+		*/
+		return {
+			name: this.getAppname(),
+			baseDir,
+			env,
+			scope,
+			HOME: home,
+			pkg: this.pkg,
+			root: env === "local" || env === "unittest" ? baseDir : home
+		};
+	}
+	/**
+	* Get {@link EggLoader#eggPaths}
+	* @returns {Array} framework directories
+	* @see {@link EggLoader#eggPaths}
+	* @private
+	* @since 1.0.0
+	*/
+	getEggPaths() {
+		const EggCore$1 = this.options.EggCoreClass;
+		const eggPaths = [];
+		let proto = this.app;
+		while (proto) {
+			proto = Object.getPrototypeOf(proto);
+			if (proto === Object.prototype || proto === EggCore$1?.prototype) break;
+			const eggPath = Reflect.get(proto, Symbol.for("egg#eggPath"));
+			if (!eggPath) continue;
+			assert(typeof eggPath === "string", "Symbol.for('egg#eggPath') should be string");
+			assert(fs.existsSync(eggPath), `${eggPath} not exists`);
+			const realpath = fs.realpathSync(eggPath);
+			if (!eggPaths.includes(realpath)) eggPaths.unshift(realpath);
+		}
+		return eggPaths;
+	}
+	/** start Plugin loader */
+	lookupDirs;
+	eggPlugins;
+	appPlugins;
+	customPlugins;
+	allPlugins;
+	orderPlugins;
+	/** enable plugins */
+	plugins;
+	/**
+	* Load config/plugin.js from {EggLoader#loadUnits}
+	*
+	* plugin.js is written below
+	*
+	* ```js
+	* {
+	*   'xxx-client': {
+	*     enable: true,
+	*     package: 'xxx-client',
+	*     dep: [],
+	*     env: [],
+	*   },
+	*   // short hand
+	*   'rds': false,
+	*   'depd': {
+	*     enable: true,
+	*     path: 'path/to/depd'
+	*   }
+	* }
+	* ```
+	*
+	* If the plugin has path, Loader will find the module from it.
+	*
+	* Otherwise Loader will lookup follow the order by packageName
+	*
+	* 1. $APP_BASE/node_modules/${package}
+	* 2. $EGG_BASE/node_modules/${package}
+	*
+	* You can call `loader.plugins` that retrieve enabled plugins.
+	*
+	* ```js
+	* loader.plugins['xxx-client'] = {
+	*   name: 'xxx-client',                 // the plugin name, it can be used in `dep`
+	*   package: 'xxx-client',              // the package name of plugin
+	*   enable: true,                       // whether enabled
+	*   path: 'path/to/xxx-client',         // the directory of the plugin package
+	*   dep: [],                            // the dependent plugins, you can use the plugin name
+	*   env: [ 'local', 'unittest' ],       // specify the serverEnv that only enable the plugin in it
+	* }
+	* ```
+	*
+	* `loader.allPlugins` can be used when retrieve all plugins.
+	* @function EggLoader#loadPlugin
+	* @since 1.0.0
+	*/
+	async loadPlugin() {
+		this.timing.start("Load Plugin");
+		this.lookupDirs = this.getLookupDirs();
+		this.allPlugins = {};
+		this.eggPlugins = await this.loadEggPlugins();
+		this.appPlugins = await this.loadAppPlugins();
+		this.customPlugins = this.loadCustomPlugins();
+		this.#extendPlugins(this.allPlugins, this.eggPlugins);
+		this.#extendPlugins(this.allPlugins, this.appPlugins);
+		this.#extendPlugins(this.allPlugins, this.customPlugins);
+		const enabledPluginNames = [];
+		const plugins = {};
+		const env = this.serverEnv;
+		for (const name in this.allPlugins) {
+			const plugin = this.allPlugins[name];
+			plugin.path = this.getPluginPath(plugin);
+			await this.#mergePluginConfig(plugin);
+			if (env && plugin.env.length > 0 && !plugin.env.includes(env)) {
+				this.logger.info("[egg/core] Plugin %o is disabled by env unmatched, require env(%o) but got env is %o", name, plugin.env, env);
+				plugin.enable = false;
+				continue;
+			}
+			plugins[name] = plugin;
+			if (plugin.enable) enabledPluginNames.push(name);
+		}
+		this.orderPlugins = this.getOrderPlugins(plugins, enabledPluginNames, this.appPlugins);
+		const enablePlugins = {};
+		for (const plugin of this.orderPlugins) enablePlugins[plugin.name] = plugin;
+		debug$1("Loaded enable plugins: %j", Object.keys(enablePlugins));
+		/**
+		* Retrieve enabled plugins
+		* @member {Object} EggLoader#plugins
+		* @since 1.0.0
+		*/
+		this.plugins = enablePlugins;
+		this.timing.end("Load Plugin");
+	}
+	async loadAppPlugins() {
+		const appPlugins = await this.readPluginConfigs(path.join(this.options.baseDir, "config/plugin.default"));
+		debug$1("Loaded app plugins: %j", Object.keys(appPlugins).map((k) => `${k}:${appPlugins[k].enable}`));
+		return appPlugins;
+	}
+	async loadEggPlugins() {
+		const eggPluginConfigPaths = this.eggPaths.map((eggPath) => path.join(eggPath, "config/plugin.default"));
+		const eggPlugins = await this.readPluginConfigs(eggPluginConfigPaths);
+		debug$1("Loaded egg plugins: %j", Object.keys(eggPlugins).map((k) => `${k}:${eggPlugins[k].enable}`));
+		return eggPlugins;
+	}
+	loadCustomPlugins() {
+		let customPlugins = {};
+		const configPaths = [];
+		if (process.env.EGG_PLUGINS) try {
+			customPlugins = JSON.parse(process.env.EGG_PLUGINS);
+			configPaths.push("<process.env.EGG_PLUGINS>");
+		} catch (e) {
+			debug$1("parse EGG_PLUGINS failed, %s", e);
+		}
+		if (this.options.plugins) {
+			customPlugins = {
+				...customPlugins,
+				...this.options.plugins
+			};
+			configPaths.push("<options.plugins>");
+		}
+		if (customPlugins) {
+			const configPath = configPaths.join(" or ");
+			for (const name in customPlugins) this.#normalizePluginConfig(customPlugins, name, configPath);
+			debug$1("Loaded custom plugins: %o", customPlugins);
+		}
+		return customPlugins;
+	}
+	async readPluginConfigs(configPaths) {
+		if (!Array.isArray(configPaths)) configPaths = [configPaths];
+		const newConfigPaths = [];
+		for (const filename of this.getTypeFiles("plugin")) for (let configPath of configPaths) {
+			configPath = path.join(path.dirname(configPath), filename);
+			newConfigPaths.push(configPath);
+		}
+		const plugins = {};
+		for (const configPath of newConfigPaths) {
+			let filepath = this.resolveModule(configPath);
+			if (configPath.endsWith("plugin.default") && !filepath) filepath = this.resolveModule(configPath.replace(/plugin\.default$/, "plugin"));
+			if (!filepath) {
+				debug$1("[readPluginConfigs:ignore] plugin config not found %o", configPath);
+				continue;
+			}
+			const config = await utils_default.loadFile(filepath);
+			for (const name in config) this.#normalizePluginConfig(config, name, filepath);
+			this.#extendPlugins(plugins, config);
+		}
+		return plugins;
+	}
+	#normalizePluginConfig(plugins, name, configPath) {
+		const plugin = plugins[name];
+		if (typeof plugin === "boolean") {
+			plugins[name] = {
+				name,
+				enable: plugin,
+				dependencies: [],
+				optionalDependencies: [],
+				env: [],
+				from: configPath
+			};
+			return;
+		}
+		if (!("enable" in plugin)) Reflect.set(plugin, "enable", true);
+		plugin.name = name;
+		plugin.dependencies = plugin.dependencies || [];
+		plugin.optionalDependencies = plugin.optionalDependencies || [];
+		plugin.env = plugin.env || [];
+		plugin.from = plugin.from || configPath;
+		depCompatible(plugin);
+	}
+	async #mergePluginConfig(plugin) {
+		let pkg;
+		let config;
+		const pluginPackage = path.join(plugin.path, "package.json");
+		if (await utils_default.existsPath(pluginPackage)) {
+			pkg = await readJSON(pluginPackage);
+			config = pkg.eggPlugin;
+			if (pkg.version) plugin.version = pkg.version;
+			plugin.path = await this.#formatPluginPathFromPackageJSON(plugin.path, pkg);
+		}
+		const logger = this.options.logger;
+		if (!config) {
+			logger.warn(`[@eggjs/core/egg_loader] pkg.eggPlugin is missing in ${pluginPackage}`);
+			return;
+		}
+		if (config.name && config.strict !== false && config.name !== plugin.name) logger.warn(`[@eggjs/core/egg_loader] pluginName(${plugin.name}) is different from pluginConfigName(${config.name})`);
+		depCompatible(config);
+		for (const key of [
+			"dependencies",
+			"optionalDependencies",
+			"env"
+		]) {
+			const values = config[key];
+			const existsValues = Reflect.get(plugin, key);
+			if (Array.isArray(values) && !existsValues?.length) Reflect.set(plugin, key, values);
+		}
+	}
+	getOrderPlugins(allPlugins, enabledPluginNames, appPlugins) {
+		if (enabledPluginNames.length === 0) return [];
+		const result = sequencify(allPlugins, enabledPluginNames);
+		debug$1("Got plugins %j after sequencify", result);
+		if (result.sequence.length === 0) {
+			const err = /* @__PURE__ */ new Error(`sequencify plugins has problem, missing: [${result.missingTasks}], recursive: [${result.recursiveDependencies}]`);
+			for (const missName of result.missingTasks) {
+				const requires = [];
+				for (const name in allPlugins) if (allPlugins[name].dependencies.includes(missName)) requires.push(name);
+				err.message += `\n\t>> Plugin [${missName}] is disabled or missed, but is required by [${requires}]`;
+			}
+			err.name = "PluginSequencifyError";
+			throw err;
+		}
+		const implicitEnabledPlugins = [];
+		const requireMap = {};
+		for (const name of result.sequence) {
+			for (const depName of allPlugins[name].dependencies) {
+				if (!requireMap[depName]) requireMap[depName] = [];
+				requireMap[depName].push(name);
+			}
+			if (!allPlugins[name].enable) {
+				implicitEnabledPlugins.push(name);
+				allPlugins[name].enable = true;
+				allPlugins[name].implicitEnable = true;
+			}
+		}
+		for (const [name, dependents] of Object.entries(requireMap)) allPlugins[name].dependents = dependents;
+		if (implicitEnabledPlugins.length > 0) {
+			let message = implicitEnabledPlugins.map((name) => `  - ${name} required by [${requireMap[name]}]`).join("\n");
+			this.options.logger.info(`Following plugins will be enabled implicitly.\n${message}`);
+			const disabledPlugins = implicitEnabledPlugins.filter((name) => appPlugins[name] && appPlugins[name].enable === false);
+			if (disabledPlugins.length > 0) {
+				message = disabledPlugins.map((name) => `  - ${name} required by [${requireMap[name]}]`).join("\n");
+				this.options.logger.warn(`Following plugins will be enabled implicitly that is disabled by application.\n${message}`);
+			}
+		}
+		return result.sequence.map((name) => allPlugins[name]);
+	}
+	getLookupDirs() {
+		const lookupDirs = /* @__PURE__ */ new Set();
+		lookupDirs.add(this.options.baseDir);
+		for (let i = this.eggPaths.length - 1; i >= 0; i--) {
+			const eggPath = this.eggPaths[i];
+			lookupDirs.add(eggPath);
+		}
+		lookupDirs.add(process.cwd());
+		return lookupDirs;
+	}
+	getPluginPath(plugin) {
+		if (plugin.path) return plugin.path;
+		if (plugin.package) assert(isValidatePackageName(plugin.package), `plugin ${plugin.name} invalid, use 'path' instead of package: "${plugin.package}"`);
+		return this.#resolvePluginPath(plugin);
+	}
+	#resolvePluginPath(plugin) {
+		const name = plugin.package || plugin.name;
+		try {
+			const pluginPkgFile = utils_default.resolvePath(`${name}/package.json`, { paths: [...this.lookupDirs] });
+			return path.dirname(pluginPkgFile);
+		} catch (err) {
+			debug$1("[resolvePluginPath] error: %o, plugin info: %o", err, plugin);
+			throw new Error(`Can not find plugin ${name} in "${[...this.lookupDirs].join(", ")}"`, { cause: err });
+		}
+	}
+	async #formatPluginPathFromPackageJSON(pluginPath, pluginPkg) {
+		let realPluginPath = pluginPath;
+		const exports = pluginPkg.eggPlugin?.exports;
+		if (exports) {
+			if (isESM) {
+				if (exports.import) realPluginPath = path.join(pluginPath, exports.import);
+			} else if (exports.require) realPluginPath = path.join(pluginPath, exports.require);
+			if (exports.typescript && isSupportTypeScript() && !await exists(realPluginPath)) {
+				realPluginPath = path.join(pluginPath, exports.typescript);
+				debug$1("[formatPluginPathFromPackageJSON] use typescript path %o", realPluginPath);
+			}
+		} else if (pluginPkg.exports?.["."] && pluginPkg.type === "module") {
+			let defaultExport = pluginPkg.exports["."];
+			if (typeof defaultExport === "string") realPluginPath = path.dirname(path.join(pluginPath, defaultExport));
+			else if (defaultExport?.import) {
+				if (typeof defaultExport.import === "string") realPluginPath = path.dirname(path.join(pluginPath, defaultExport.import));
+				else if (defaultExport.import.default) realPluginPath = path.dirname(path.join(pluginPath, defaultExport.import.default));
+			}
+			debug$1("[formatPluginPathFromPackageJSON] resolve plugin path from %o to %o, defaultExport: %o", pluginPath, realPluginPath, defaultExport);
+		}
+		return realPluginPath;
+	}
+	#extendPlugins(targets, plugins) {
+		if (!plugins) return;
+		for (const name in plugins) {
+			const plugin = plugins[name];
+			let targetPlugin = targets[name];
+			if (!targetPlugin) {
+				targetPlugin = {};
+				targets[name] = targetPlugin;
+			}
+			if (targetPlugin.package && targetPlugin.package === plugin.package) this.logger.warn("[@eggjs/core] plugin %s has been defined that is %j, but you define again in %s", name, targetPlugin, plugin.from);
+			if (plugin.path || plugin.package) {
+				delete targetPlugin.path;
+				delete targetPlugin.package;
+			}
+			for (const [prop, value] of Object.entries(plugin)) {
+				if (value === void 0) continue;
+				if (Reflect.get(targetPlugin, prop) && Array.isArray(value) && value.length === 0) continue;
+				Reflect.set(targetPlugin, prop, value);
+			}
+		}
+	}
+	/** end Plugin loader */
+	/** start Config loader */
+	configMeta;
+	config;
+	/**
+	* Load config/config.js
+	*
+	* Will merge config.default.js 和 config.${env}.js
+	*
+	* @function EggLoader#loadConfig
+	* @since 1.0.0
+	*/
+	async loadConfig() {
+		this.timing.start("Load Config");
+		this.configMeta = {};
+		const target = {
+			middleware: [],
+			coreMiddleware: []
+		};
+		const appConfig = await this.#preloadAppConfig();
+		for (const filename of this.getTypeFiles("config")) for (const unit of this.getLoadUnits()) {
+			const isApp = unit.type === "app";
+			const config = await this.#loadConfig(unit.path, filename, isApp ? void 0 : appConfig, unit.type);
+			if (!config) continue;
+			debug$1("[loadConfig] Loaded config %s/%s, %j", unit.path, filename, config);
+			extend(true, target, config);
+		}
+		const envConfig = this.#loadConfigFromEnv();
+		debug$1("[loadConfig] Loaded config from env, %j", envConfig);
+		extend(true, target, envConfig);
+		target.coreMiddleware = target.coreMiddleware || [];
+		target.coreMiddlewares = target.coreMiddleware;
+		target.appMiddleware = target.middleware || [];
+		target.appMiddlewares = target.appMiddleware;
+		this.config = target;
+		debug$1("[loadConfig] all config: %o", this.config);
+		this.timing.end("Load Config");
+	}
+	async #preloadAppConfig() {
+		const names = ["config.default", `config.${this.serverEnv}`];
+		const target = {};
+		for (const filename of names) {
+			const config = await this.#loadConfig(this.options.baseDir, filename, void 0, "app");
+			if (!config) continue;
+			extend(true, target, config);
+		}
+		return target;
+	}
+	async #loadConfig(dirpath, filename, extraInject, type) {
+		const isPlugin = type === "plugin";
+		const isApp = type === "app";
+		let filepath = this.resolveModule(path.join(dirpath, "config", filename));
+		if (filename === "config.default" && !filepath) filepath = this.resolveModule(path.join(dirpath, "config/config"));
+		if (!filepath) return;
+		const config = await this.loadFile(filepath, this.appInfo, extraInject);
+		if (!config) return;
+		if (isPlugin || isApp) assert(!config.coreMiddleware, "Can not define coreMiddleware in app or plugin");
+		if (!isApp) assert(!config.middleware, "Can not define middleware in " + filepath);
+		this.#setConfigMeta(config, filepath);
+		return config;
+	}
+	#loadConfigFromEnv() {
+		const envConfigStr = process.env.EGG_APP_CONFIG;
+		if (!envConfigStr) return;
+		try {
+			const envConfig = JSON.parse(envConfigStr);
+			this.#setConfigMeta(envConfig, "<process.env.EGG_APP_CONFIG>");
+			return envConfig;
+		} catch {
+			this.options.logger.warn("[egg-loader] process.env.EGG_APP_CONFIG is not invalid JSON: %s", envConfigStr);
+		}
+	}
+	#setConfigMeta(config, filepath) {
+		config = extend(true, {}, config);
+		this.#setConfig(config, filepath);
+		extend(true, this.configMeta, config);
+	}
+	#setConfig(obj, filepath) {
+		for (const key of Object.keys(obj)) {
+			const val = obj[key];
+			if (key === "console" && val && typeof val.Console === "function" && val.Console === console.Console) {
+				obj[key] = filepath;
+				continue;
+			}
+			if (val && Object.getPrototypeOf(val) === Object.prototype && Object.keys(val).length > 0) {
+				this.#setConfig(val, filepath);
+				continue;
+			}
+			obj[key] = filepath;
+		}
+	}
+	/** end Config loader */
+	/** start Extend loader */
+	/**
+	* mixin Agent.prototype
+	* @function EggLoader#loadAgentExtend
+	* @since 1.0.0
+	*/
+	async loadAgentExtend() {
+		await this.loadExtend("agent", this.app);
+	}
+	/**
+	* mixin Application.prototype
+	* @function EggLoader#loadApplicationExtend
+	* @since 1.0.0
+	*/
+	async loadApplicationExtend() {
+		await this.loadExtend("application", this.app);
+	}
+	/**
+	* mixin Request.prototype
+	* @function EggLoader#loadRequestExtend
+	* @since 1.0.0
+	*/
+	async loadRequestExtend() {
+		await this.loadExtend("request", this.app.request);
+	}
+	/**
+	* mixin Response.prototype
+	* @function EggLoader#loadResponseExtend
+	* @since 1.0.0
+	*/
+	async loadResponseExtend() {
+		await this.loadExtend("response", this.app.response);
+	}
+	/**
+	* mixin Context.prototype
+	* @function EggLoader#loadContextExtend
+	* @since 1.0.0
+	*/
+	async loadContextExtend() {
+		await this.loadExtend("context", this.app.context);
+	}
+	/**
+	* mixin app.Helper.prototype
+	* @function EggLoader#loadHelperExtend
+	* @since 1.0.0
+	*/
+	async loadHelperExtend() {
+		if (this.app.Helper) await this.loadExtend("helper", this.app.Helper.prototype);
+	}
+	/**
+	* Find all extend file paths by name
+	* can be override in top level framework to support load `app/extends/{name}.js`
+	*
+	* @param {String} name - filename which may be `app/extend/{name}.js`
+	* @returns {Array} filepaths extend file paths
+	* @private
+	*/
+	getExtendFilePaths(name) {
+		return this.getLoadUnits().map((unit) => path.join(unit.path, "app/extend", name));
+	}
+	/**
+	* Loader app/extend/xx.js to `prototype`,
+	* @function loadExtend
+	* @param {String} name - filename which may be `app/extend/{name}.js`
+	* @param {Object} proto - prototype that mixed
+	* @since 1.0.0
+	*/
+	async loadExtend(name, proto) {
+		this.timing.start(`Load extend/${name}.js`);
+		const filepaths = this.getExtendFilePaths(name);
+		const needUnittest = "EGG_MOCK_SERVER_ENV" in process.env && this.serverEnv !== "unittest";
+		const length = filepaths.length;
+		for (let i = 0; i < length; i++) {
+			const filepath = filepaths[i];
+			filepaths.push(filepath + `.${this.serverEnv}`);
+			if (needUnittest) filepaths.push(filepath + ".unittest");
+		}
+		debug$1("loadExtend %s, filepaths: %j", name, filepaths);
+		const mergeRecord = /* @__PURE__ */ new Map();
+		for (const rawFilepath of filepaths) {
+			const filepath = this.resolveModule(rawFilepath);
+			if (!filepath) continue;
+			if (filepath.endsWith("/index.js")) this.app.deprecate(`app/extend/${name}/index.js is deprecated, use app/extend/${name}.js instead`);
+			else if (filepath.endsWith("/index.ts")) this.app.deprecate(`app/extend/${name}/index.ts is deprecated, use app/extend/${name}.ts instead`);
+			let ext = await this.requireFile(filepath);
+			if (isClass(ext)) ext = ext.prototype;
+			const properties = Object.getOwnPropertyNames(ext).concat(Object.getOwnPropertySymbols(ext)).filter((name$1) => name$1 !== "constructor");
+			for (const property of properties) {
+				if (mergeRecord.has(property)) debug$1("Property: \"%s\" already exists in \"%s\"，it will be redefined by \"%s\"", property, mergeRecord.get(property), filepath);
+				let descriptor = Object.getOwnPropertyDescriptor(ext, property);
+				let originalDescriptor = Object.getOwnPropertyDescriptor(proto, property);
+				if (!originalDescriptor) {
+					const originalProto = originalPrototypes[name];
+					if (originalProto) originalDescriptor = Object.getOwnPropertyDescriptor(originalProto, property);
+				}
+				if (originalDescriptor) {
+					descriptor = { ...descriptor };
+					if (!descriptor.set && originalDescriptor.set) descriptor.set = originalDescriptor.set;
+					if (!descriptor.get && originalDescriptor.get) descriptor.get = originalDescriptor.get;
+				}
+				Object.defineProperty(proto, property, descriptor);
+				mergeRecord.set(property, filepath);
+			}
+			debug$1("merge %j to %s from %s", properties, name, filepath);
+		}
+		this.timing.end(`Load extend/${name}.js`);
+	}
+	/** end Extend loader */
+	/** start Custom loader */
+	/**
+	* load app.js
+	*
+	* @example
+	* - old:
+	*
+	* ```js
+	* module.exports = function(app) {
+	*   doSomething();
+	* }
+	* ```
+	*
+	* - new:
+	*
+	* ```js
+	* module.exports = class Boot {
+	*   constructor(app) {
+	*     this.app = app;
+	*   }
+	*   configDidLoad() {
+	*     doSomething();
+	*   }
+	* }
+	* @since 1.0.0
+	*/
+	async loadCustomApp() {
+		await this.#loadBootHook("app");
+		this.lifecycle.triggerConfigWillLoad();
+	}
+	/**
+	* Load agent.js, same as {@link EggLoader#loadCustomApp}
+	*/
+	async loadCustomAgent() {
+		await this.#loadBootHook("agent");
+		this.lifecycle.triggerConfigWillLoad();
+	}
+	loadBootHook() {}
+	async #loadBootHook(fileName) {
+		this.timing.start(`Load ${fileName}.js`);
+		for (const unit of this.getLoadUnits()) {
+			const bootFile = path.join(unit.path, fileName);
+			const bootFilePath = this.resolveModule(bootFile);
+			if (!bootFilePath) {
+				debug$1("[loadBootHook:ignore] %o not found", bootFile);
+				continue;
+			}
+			debug$1("[loadBootHook:success] %o => %o", bootFile, bootFilePath);
+			const bootHook = await this.requireFile(bootFilePath);
+			if (isClass(bootHook)) {
+				bootHook.prototype.fullPath = bootFilePath;
+				this.lifecycle.addBootHook(bootHook);
+				debug$1("[loadBootHook] add BootHookClass from %o", bootFilePath);
+			} else if (typeof bootHook === "function") {
+				this.lifecycle.addFunctionAsBootHook(bootHook, bootFilePath);
+				debug$1("[loadBootHook] add bootHookFunction from %o", bootFilePath);
+			} else this.options.logger.warn("[@eggjs/core/egg_loader] %s must exports a boot class", bootFilePath);
+		}
+		this.lifecycle.init();
+		this.timing.end(`Load ${fileName}.js`);
+	}
+	/** end Custom loader */
+	/** start Service loader */
+	/**
+	* Load app/service
+	* @function EggLoader#loadService
+	* @param {Object} options - LoaderOptions
+	* @since 1.0.0
+	*/
+	async loadService(options) {
+		this.timing.start("Load Service");
+		const servicePaths = this.getLoadUnits().map((unit) => path.join(unit.path, "app/service"));
+		options = {
+			call: true,
+			caseStyle: CaseStyle.lower,
+			fieldClass: "serviceClasses",
+			directory: servicePaths,
+			...options
+		};
+		debug$1("[loadService] options: %o", options);
+		await this.loadToContext(servicePaths, "service", options);
+		this.timing.end("Load Service");
+	}
+	/** end Service loader */
+	/** start Middleware loader */
+	/**
+	* Load app/middleware
+	*
+	* app.config.xx is the options of the middleware xx that has same name as config
+	*
+	* @function EggLoader#loadMiddleware
+	* @param {Object} opt - LoaderOptions
+	* @example
+	* ```js
+	* // app/middleware/status.js
+	* module.exports = function(options, app) {
+	*   // options == app.config.status
+	*   return async next => {
+	*     await next();
+	*   }
+	* }
+	* ```
+	* @since 1.0.0
+	*/
+	async loadMiddleware(opt) {
+		this.timing.start("Load Middleware");
+		const app = this.app;
+		const middlewarePaths = this.getLoadUnits().map((unit) => path.join(unit.path, "app/middleware"));
+		opt = {
+			call: false,
+			override: true,
+			caseStyle: CaseStyle.lower,
+			directory: middlewarePaths,
+			...opt
+		};
+		await this.loadToApp(middlewarePaths, "middlewares", opt);
+		debug$1("[loadMiddleware] middlewarePaths: %j", middlewarePaths);
+		for (const name in app.middlewares) Object.defineProperty(app.middleware, name, {
+			get() {
+				return app.middlewares[name];
+			},
+			enumerable: false,
+			configurable: false
+		});
+		this.options.logger.info("Use coreMiddleware order: %j", this.config.coreMiddleware);
+		this.options.logger.info("Use appMiddleware order: %j", this.config.appMiddleware);
+		const middlewareNames = this.config.coreMiddleware.concat(this.config.appMiddleware);
+		debug$1("[loadMiddleware] middlewareNames: %j", middlewareNames);
+		const middlewaresMap = /* @__PURE__ */ new Map();
+		for (const name of middlewareNames) {
+			const createMiddleware = app.middlewares[name];
+			if (!createMiddleware) throw new TypeError(`Middleware ${name} not found`);
+			if (middlewaresMap.has(name)) throw new TypeError(`Middleware ${name} redefined`);
+			middlewaresMap.set(name, true);
+			const options = this.config[name] || {};
+			let mw$1 = createMiddleware(options, app);
+			assert(typeof mw$1 === "function", `Middleware ${name} must be a function, but actual is ${inspect(mw$1)}`);
+			if (isGeneratorFunction(mw$1)) {
+				const fullpath = Reflect.get(createMiddleware, FULLPATH);
+				throw new TypeError(`Support for generators was removed, middleware: ${name}, fullpath: ${fullpath}`);
+			}
+			mw$1._name = name;
+			mw$1 = wrapMiddleware(mw$1, options);
+			if (mw$1) {
+				if (debug$1.enabled) mw$1 = debugMiddlewareWrapper(mw$1);
+				app.use(mw$1);
+				debug$1("[loadMiddleware] Use middleware: %s with options: %j", name, options);
+				this.options.logger.info("[@eggjs/core/egg_loader] Use middleware: %s", name);
+			} else this.options.logger.info("[@eggjs/core/egg_loader] Disable middleware: %s", name);
+		}
+		this.options.logger.info("[@eggjs/core/egg_loader] Loaded middleware from %j", middlewarePaths);
+		this.timing.end("Load Middleware");
+		const mw = this.app.router.middleware();
+		Reflect.set(mw, "_name", "routerMiddleware");
+		this.app.use(mw);
+	}
+	/** end Middleware loader */
+	/** start Controller loader */
+	/**
+	* Load app/controller
+	* @param {Object} opt - LoaderOptions
+	* @since 1.0.0
+	*/
+	async loadController(opt) {
+		this.timing.start("Load Controller");
+		const controllerBase = path.join(this.options.baseDir, "app/controller");
+		opt = {
+			caseStyle: CaseStyle.lower,
+			directory: controllerBase,
+			initializer: (obj, opt$1) => {
+				if (isGeneratorFunction(obj)) throw new TypeError(`Support for generators was removed, fullpath: ${opt$1.path}`);
+				if (!isClass(obj) && !isAsyncFunction(obj) && typeof obj === "function") {
+					obj = obj(this.app);
+					debug$1("[loadController] after init(app) => %o, meta: %j", obj, opt$1);
+					if (isGeneratorFunction(obj)) throw new TypeError(`Support for generators was removed, fullpath: ${opt$1.path}`);
+				}
+				if (isClass(obj)) {
+					obj.prototype.pathName = opt$1.pathName;
+					obj.prototype.fullPath = opt$1.path;
+					return wrapControllerClass(obj, opt$1.path);
+				}
+				if (isObject(obj)) return wrapObject(obj, opt$1.path);
+				if (isAsyncFunction(obj)) return wrapObject({ "module.exports": obj }, opt$1.path)["module.exports"];
+				return obj;
+			},
+			...opt
+		};
+		await this.loadToApp(controllerBase, "controller", opt);
+		debug$1("[loadController] app.controller => %o", this.app.controller);
+		this.options.logger.info("[@eggjs/core/egg_loader] Controller loaded: %s", controllerBase);
+		this.timing.end("Load Controller");
+	}
+	/** end Controller loader */
+	/** start Router loader */
+	/**
+	* Load app/router.js
+	* @function EggLoader#loadRouter
+	* @since 1.0.0
+	*/
+	async loadRouter() {
+		this.timing.start("Load Router");
+		await this.loadFile(path.join(this.options.baseDir, "app/router"));
+		this.timing.end("Load Router");
+	}
+	/** end Router loader */
+	/** start CustomLoader loader */
+	async loadCustomLoader() {
+		assert(this.config, "should loadConfig first");
+		const customLoader = this.config.customLoader || {};
+		for (const property of Object.keys(customLoader)) {
+			const loaderConfig = { ...customLoader[property] };
+			assert(loaderConfig.directory, `directory is required for config.customLoader.${property}`);
+			let directory;
+			if (loaderConfig.loadunit === true) directory = this.getLoadUnits().map((unit) => path.join(unit.path, loaderConfig.directory));
+			else directory = path.join(this.appInfo.baseDir, loaderConfig.directory);
+			const inject = loaderConfig.inject || "app";
+			debug$1("[loadCustomLoader] loaderConfig: %o, inject: %o, directory: %o", loaderConfig, inject, directory);
+			switch (inject) {
+				case "ctx": {
+					assert(!(property in this.app.context), `customLoader should not override ctx.${property}`);
+					const options = {
+						caseStyle: CaseStyle.lower,
+						fieldClass: `${property}Classes`,
+						...loaderConfig,
+						directory
+					};
+					await this.loadToContext(directory, property, options);
+					break;
+				}
+				case "app": {
+					assert(!(property in this.app), `customLoader should not override app.${property}`);
+					const options = {
+						caseStyle: CaseStyle.lower,
+						initializer: (Clazz) => {
+							return isClass(Clazz) ? new Clazz(this.app) : Clazz;
+						},
+						...loaderConfig,
+						directory
+					};
+					await this.loadToApp(directory, property, options);
+					break;
+				}
+				default: throw new Error("inject only support app or ctx");
+			}
+		}
+	}
+	/** end CustomLoader loader */
+	/**
+	* Load single file, will invoke when export is function
+	*
+	* @param {String} filepath - fullpath
+	* @param {Array} inject - pass rest arguments into the function when invoke
+	* @returns {Object} exports
+	* @example
+	* ```js
+	* app.loader.loadFile(path.join(app.options.baseDir, 'config/router.js'));
+	* ```
+	* @since 1.0.0
+	*/
+	async loadFile(filepath, ...inject) {
+		const fullpath = filepath && this.resolveModule(filepath);
+		if (!fullpath) return null;
+		if (inject.length === 0) inject = [this.app];
+		let mod = await this.requireFile(fullpath);
+		if (typeof mod === "function" && !isClass(mod)) {
+			mod = mod(...inject);
+			if (isPromise(mod)) mod = await mod;
+		}
+		return mod;
+	}
+	/**
+	* @param {String} filepath - fullpath
+	* @private
+	*/
+	async requireFile(filepath) {
+		const timingKey = `Require(${this.#requiredCount++}) ${utils_default.getResolvedFilename(filepath, this.options.baseDir)}`;
+		this.timing.start(timingKey);
+		const mod = await utils_default.loadFile(filepath);
+		this.timing.end(timingKey);
+		return mod;
+	}
+	/**
+	* Get all loadUnit
+	*
+	* loadUnit is a directory that can be loaded by EggLoader, it has the same structure.
+	* loadUnit has a path and a type(app, framework, plugin).
+	*
+	* The order of the loadUnits:
+	*
+	* 1. plugin
+	* 2. framework
+	* 3. app
+	*
+	* @returns {Array} loadUnits
+	* @since 1.0.0
+	*/
+	getLoadUnits() {
+		if (this.dirs) return this.dirs;
+		this.dirs = [];
+		if (this.orderPlugins) for (const plugin of this.orderPlugins) this.dirs.push({
+			path: plugin.path,
+			type: "plugin"
+		});
+		for (const eggPath of this.eggPaths) this.dirs.push({
+			path: eggPath,
+			type: "framework"
+		});
+		this.dirs.push({
+			path: this.options.baseDir,
+			type: "app"
+		});
+		debug$1("Loaded dirs %j", this.dirs);
+		return this.dirs;
+	}
+	/**
+	* Load files using {@link FileLoader}, inject to {@link Application}
+	* @param {String|Array} directory - see {@link FileLoader}
+	* @param {String} property - see {@link FileLoader}, e.g.: 'controller', 'middlewares'
+	* @param {Object} options - see {@link FileLoader}
+	* @since 1.0.0
+	*/
+	async loadToApp(directory, property, options) {
+		const target = {};
+		Reflect.set(this.app, property, target);
+		const loadOptions = {
+			...options,
+			directory: options?.directory ?? directory,
+			target,
+			inject: this.app
+		};
+		const timingKey = `Load "${String(property)}" to Application`;
+		this.timing.start(timingKey);
+		await new FileLoader(loadOptions).load();
+		this.timing.end(timingKey);
+	}
+	/**
+	* Load files using {@link ContextLoader}
+	* @param {String|Array} directory - see {@link ContextLoader}
+	* @param {String} property - see {@link ContextLoader}
+	* @param {Object} options - see {@link ContextLoader}
+	* @since 1.0.0
+	*/
+	async loadToContext(directory, property, options) {
+		const loadOptions = {
+			...options,
+			directory: options?.directory || directory,
+			property,
+			inject: this.app
+		};
+		const timingKey = `Load "${String(property)}" to Context`;
+		this.timing.start(timingKey);
+		await new ContextLoader(loadOptions).load();
+		this.timing.end(timingKey);
+	}
+	/**
+	* @member {FileLoader} EggLoader#FileLoader
+	* @since 1.0.0
+	*/
+	get FileLoader() {
+		return FileLoader;
+	}
+	/**
+	* @member {ContextLoader} EggLoader#ContextLoader
+	* @since 1.0.0
+	*/
+	get ContextLoader() {
+		return ContextLoader;
+	}
+	getTypeFiles(filename) {
+		const files = [`${filename}.default`];
+		if (this.serverScope) files.push(`${filename}.${this.serverScope}`);
+		if (this.serverEnv === "default") return files;
+		files.push(`${filename}.${this.serverEnv}`);
+		if (this.serverScope) files.push(`${filename}.${this.serverScope}_${this.serverEnv}`);
+		return files;
+	}
+	resolveModule(filepath) {
+		let fullPath;
+		try {
+			fullPath = utils_default.resolvePath(filepath);
+		} catch {
+			return;
+		}
+		return fullPath;
+	}
+};
+function depCompatible(plugin) {
+	if (plugin.dep && !(Array.isArray(plugin.dependencies) && plugin.dependencies.length > 0)) {
+		plugin.dependencies = plugin.dep;
+		delete plugin.dep;
+	}
+}
+function isValidatePackageName(name) {
+	if (name.startsWith(".")) return false;
+	if (name.startsWith("/")) return false;
+	if (name.includes(":")) return false;
+	return true;
+}
+function wrapMiddleware(mw, options) {
+	if (options.enable === false) return null;
+	if (!options.match && !options.ignore) return mw;
+	const match = pathMatching(options);
+	const fn = (ctx, next) => {
+		if (!match(ctx)) return next();
+		return mw(ctx, next);
+	};
+	fn._name = `${mw._name}middlewareWrapper`;
+	return fn;
+}
+function debugMiddlewareWrapper(mw) {
+	const fn = async (ctx, next) => {
+		const startTime = now();
+		debug$1("[debugMiddlewareWrapper] [%s %s] enter middleware: %s", ctx.method, ctx.url, mw._name);
+		await mw(ctx, next);
+		const rt = diff(startTime);
+		debug$1("[debugMiddlewareWrapper] [%s %s] after middleware: %s [%sms]", ctx.method, ctx.url, mw._name, rt);
+	};
+	fn._name = `${mw._name}DebugWrapper`;
+	return fn;
+}
+function wrapControllerClass(Controller, fullPath) {
+	let proto = Controller.prototype;
+	const ret = {};
+	while (proto !== Object.prototype) {
+		const keys = Object.getOwnPropertyNames(proto);
+		for (const key of keys) {
+			if (key === "constructor") continue;
+			const d = Object.getOwnPropertyDescriptor(proto, key);
+			if (typeof d?.value === "function" && !Object.hasOwn(ret, key)) {
+				const controllerMethodName = `${Controller.name}.${key}`;
+				if (isGeneratorFunction(d.value)) throw new TypeError(`Support for generators was removed, controller \`${controllerMethodName}\`, fullpath: ${fullPath}`);
+				ret[key] = controllerMethodToMiddleware(Controller, key);
+				ret[key][FULLPATH] = `${fullPath}#${controllerMethodName}()`;
+			}
+		}
+		proto = Object.getPrototypeOf(proto);
+	}
+	return ret;
+}
+function controllerMethodToMiddleware(Controller, key) {
+	return function classControllerMiddleware(...args) {
+		const controller = new Controller(this);
+		if (!this.app.config.controller?.supportParams) args = [this];
+		return controller[key](...args);
+	};
+}
+function wrapObject(obj, fullPath, prefix) {
+	const keys = Object.keys(obj);
+	const ret = {};
+	prefix = prefix ?? "";
+	for (const key of keys) {
+		const controllerMethodName = `${prefix}${key}`;
+		const item = obj[key];
+		if (isGeneratorFunction(item)) throw new TypeError(`Support for generators was removed, controller \`${controllerMethodName}\`, fullpath: ${fullPath}`);
+		if (typeof item === "function") {
+			if (getParamNames(item)[0] === "next") throw new Error(`controller \`${controllerMethodName}\` should not use next as argument from file ${fullPath}`);
+			ret[key] = objectFunctionToMiddleware(item);
+			ret[key][FULLPATH] = `${fullPath}#${controllerMethodName}()`;
+		} else if (isObject(item)) ret[key] = wrapObject(item, fullPath, `${controllerMethodName}.`);
+	}
+	debug$1("[wrapObject] fullPath: %s, prefix: %s => %o", fullPath, prefix, ret);
+	return ret;
+}
+function objectFunctionToMiddleware(func) {
+	async function objectControllerMiddleware(...args) {
+		if (!this.app.config.controller?.supportParams) args = [this];
+		return await func.apply(this, args);
+	}
+	for (const key in func) Reflect.set(objectControllerMiddleware, key, Reflect.get(func, key));
+	return objectControllerMiddleware;
+}
+
+//#endregion
+//#region src/singleton.ts
+var Singleton = class {
+	clients = /* @__PURE__ */ new Map();
+	app;
+	create;
+	name;
+	options;
+	constructor(options) {
+		assert(options.name, "[egg/core/singleton] Singleton#constructor options.name is required");
+		assert(options.app, "[egg/core/singleton] Singleton#constructor options.app is required");
+		assert(options.create, "[egg/core/singleton] Singleton#constructor options.create is required");
+		assert(!(options.name in options.app), `[egg/core/singleton] ${options.name} is already exists in app`);
+		this.app = options.app;
+		this.name = options.name;
+		this.create = options.create;
+		this.options = options.app.config[this.name] ?? {};
+	}
+	init() {
+		return isAsyncFunction(this.create) ? this.initAsync() : this.initSync();
+	}
+	initSync() {
+		const options = this.options;
+		assert(!(options.client && options.clients), `[egg/core/singleton] ${this.name} can not set options.client and options.clients both`);
+		if (options.client) {
+			const client = this.createInstance(options.client, options.name);
+			this.#setClientToApp(client);
+			this.#extendDynamicMethods(client);
+			return;
+		}
+		if (options.clients) {
+			for (const id of Object.keys(options.clients)) {
+				const client = this.createInstance(options.clients[id], id);
+				this.clients.set(id, client);
+			}
+			this.#setClientToApp(this);
+			return;
+		}
+		this.#setClientToApp(this);
+	}
+	async initAsync() {
+		const options = this.options;
+		assert(!(options.client && options.clients), `[egg/core/singleton] ${this.name} can not set options.client and options.clients both`);
+		if (options.client) {
+			const client = await this.createInstanceAsync(options.client, options.name);
+			this.#setClientToApp(client);
+			this.#extendDynamicMethods(client);
+			return;
+		}
+		if (options.clients) {
+			await Promise.all(Object.keys(options.clients).map((id) => {
+				return this.createInstanceAsync(options.clients[id], id).then((client) => this.clients.set(id, client));
+			}));
+			this.#setClientToApp(this);
+			return;
+		}
+		this.#setClientToApp(this);
+	}
+	#setClientToApp(client) {
+		Reflect.set(this.app, this.name, client);
+	}
+	/**
+	* @deprecated please use `getSingletonInstance(id)` instead
+	*/
+	get(id) {
+		return this.clients.get(id);
+	}
+	/**
+	* Get singleton instance by id
+	*/
+	getSingletonInstance(id) {
+		return this.clients.get(id);
+	}
+	createInstance(config, clientName) {
+		assert(!isAsyncFunction(this.create), `[egg/core/singleton] ${this.name} only support asynchronous creation, please use createInstanceAsync`);
+		config = {
+			...this.options.default,
+			...config
+		};
+		return this.create(config, this.app, clientName);
+	}
+	async createInstanceAsync(config, clientName) {
+		config = {
+			...this.options.default,
+			...config
+		};
+		return await this.create(config, this.app, clientName);
+	}
+	#extendDynamicMethods(client) {
+		assert(!client.createInstance, "[egg/core/singleton] singleton instance should not have createInstance method");
+		assert(!client.createInstanceAsync, "[egg/core/singleton] singleton instance should not have createInstanceAsync method");
+		try {
+			let extendable = client;
+			if (!Object.isExtensible(client) || Object.isFrozen(client)) extendable = client.__proto__ || client;
+			extendable.createInstance = this.createInstance.bind(this);
+			extendable.createInstanceAsync = this.createInstanceAsync.bind(this);
+		} catch (err) {
+			this.app.coreLogger.warn("[egg/core/singleton] %s dynamic create is disabled because of client is un-extendable", this.name);
+			this.app.coreLogger.warn(err);
+		}
+	}
+};
+
+//#endregion
+//#region src/egg.ts
+const debug = debuglog("egg/core/egg");
+const EGG_LOADER = Symbol.for("egg#loader");
+var Request = class extends KoaRequest {};
+var Response = class extends KoaResponse {};
+var Context = class extends KoaContext {
+	/**
+	* Returns map of URL parameters for given `path` and `paramNames`.
+	* @example
+	* ##### ctx.params.id {string}
+	*
+	* `GET /api/users/1` => `'1'`
+	*
+	* ##### ctx.params.per_page {string}
+	*
+	* The number of every page, `GET /api/users?per_page=20` => `20`
+	*/
+	params;
+	/**
+	* Returns array of router regexp url path captures.
+	*/
+	captures;
+	/**
+	* Returns the name of the matched router.
+	*/
+	routerName;
+	/**
+	* Returns the path of the matched router.
+	*/
+	routerPath;
+};
+var EggCore = class EggCore extends KoaApplication {
+	options;
+	timing;
+	console;
+	BaseContextClass;
+	Controller;
+	Service;
+	Helper;
+	lifecycle;
+	loader;
+	#closePromise;
+	#router;
+	/** auto inject on loadService() */
+	serviceClasses = {};
+	/** auto inject on loadController() */
+	controller = {};
+	/** auto inject on loadMiddleware() */
+	middlewares = {};
+	/**
+	* @class
+	* @param {Object} options - options
+	* @param {String} [options.baseDir] - the directory of application
+	* @param {String} [options.type] - whether it's running in app worker or agent worker
+	* @param {Object} [options.plugins] - custom plugins
+	* @since 1.0.0
+	*/
+	constructor(options = {}) {
+		options.baseDir = options.baseDir ?? process.cwd();
+		options.type = options.type ?? "application";
+		assert(typeof options.baseDir === "string", "options.baseDir required, and must be a string");
+		assert(options.type === "application" || options.type === "agent", "options.type should be application or agent");
+		super();
+		this.timing = new Timing();
+		/**
+		* @member {Object} EggCore#options
+		* @private
+		* @since 1.0.0
+		*/
+		this.options = options;
+		/**
+		* logging for EggCore, avoid using console directly
+		* @member {Logger} EggCore#console
+		* @private
+		* @since 1.0.0
+		*/
+		this.console = new EggConsoleLogger();
+		/**
+		* @member {BaseContextClass} EggCore#BaseContextClass
+		* @since 1.0.0
+		*/
+		this.BaseContextClass = BaseContextClass;
+		/**
+		* Retrieve base controller
+		* @member {Controller} EggCore#Controller
+		* @since 1.0.0
+		*/
+		this.Controller = this.BaseContextClass;
+		/**
+		* Retrieve base service
+		* @member {Service} EggCore#Service
+		* @since 1.0.0
+		*/
+		this.Service = this.BaseContextClass;
+		this.lifecycle = new Lifecycle({
+			baseDir: options.baseDir,
+			app: this,
+			logger: this.console
+		});
+		this.lifecycle.on("error", (err) => this.emit("error", err));
+		this.lifecycle.on("ready_timeout", (id) => this.emit("ready_timeout", id));
+		this.lifecycle.on("ready_stat", (data) => this.emit("ready_stat", data));
+		/**
+		* The loader instance, the default class is {@link EggLoader}.
+		* If you want define
+		* @member {EggLoader} EggCore#loader
+		* @since 1.0.0
+		*/
+		const Loader = this[EGG_LOADER];
+		assert(Loader, "Symbol.for('egg#loader') is required");
+		this.loader = new Loader({
+			baseDir: options.baseDir,
+			app: this,
+			plugins: options.plugins,
+			logger: this.console,
+			serverScope: options.serverScope,
+			env: options.env ?? "",
+			EggCoreClass: EggCore
+		});
+	}
+	get logger() {
+		return this.console;
+	}
+	get coreLogger() {
+		return this.console;
+	}
+	/**
+	* create a singleton instance
+	* @param {String} name - unique name for singleton
+	* @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
+	*/
+	addSingleton(name, create) {
+		const initPromise = new Singleton({
+			name,
+			create,
+			app: this
+		}).init();
+		if (initPromise) this.lifecycle.registerBeforeStart(async () => {
+			await initPromise;
+		}, `${name}-singleton-init`);
+	}
+	/**
+	* override koa's app.use, support generator function
+	* @since 1.0.0
+	*/
+	use(fn) {
+		assert(typeof fn === "function", "app.use() requires a function");
+		debug("[use] add middleware: %o", fn._name || fn.name || "-");
+		this.middleware.push(fn);
+		return this;
+	}
+	/**
+	* Whether `application` or `agent`
+	* @member {String}
+	* @since 1.0.0
+	*/
+	get type() {
+		return this.options.type;
+	}
+	/**
+	* The current directory of application
+	* @member {String}
+	* @see {@link AppInfo#baseDir}
+	* @since 1.0.0
+	*/
+	get baseDir() {
+		return this.options.baseDir;
+	}
+	/**
+	* Alias to {@link https://npmjs.com/package/depd}
+	* @member {Function}
+	* @since 1.0.0
+	*/
+	get deprecate() {
+		return utils_default.deprecated;
+	}
+	/**
+	* The name of application
+	* @member {String}
+	* @see {@link AppInfo#name}
+	* @since 1.0.0
+	*/
+	get name() {
+		return this.loader ? this.loader.pkg.name : "";
+	}
+	/**
+	* Retrieve enabled plugins
+	* @member {Object}
+	* @since 1.0.0
+	*/
+	get plugins() {
+		return this.loader ? this.loader.plugins : {};
+	}
+	/**
+	* The configuration of application
+	* @member {Config}
+	* @since 1.0.0
+	*/
+	get config() {
+		return this.loader ? this.loader.config : {};
+	}
+	/**
+	* Execute scope after loaded and before app start.
+	*
+	* Notice:
+	* This method is now NOT recommended and regarded as a deprecated one,
+	* For plugin development, we should use `didLoad` instead.
+	* For application development, we should use `willReady` instead.
+	*
+	* @see https://eggjs.org/en/advanced/loader.html#beforestart
+	*
+	* @param  {Function} scope function will execute before app start
+	* @param {string} [name] scope name, default is empty string
+	*/
+	beforeStart(scope, name) {
+		this.deprecate("`beforeStart` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		this.lifecycle.registerBeforeStart(scope, name ?? "");
+	}
+	ready(flagOrFunction) {
+		if (flagOrFunction === void 0) return this.lifecycle.ready();
+		return this.lifecycle.ready(flagOrFunction);
+	}
+	/**
+	* If a client starts asynchronously, you can register `readyCallback`,
+	* then the application will wait for the callback to ready
+	*
+	* It will log when the callback is not invoked after 10s
+	*
+	* Recommend to use {@link EggCore#beforeStart}
+	* @since 1.0.0
+	*
+	* @param {String} name - readyCallback task name
+	* @param {object} opts -
+	*   - {Number} [timeout=10000] - emit `ready_timeout` when it doesn't finish but reach the timeout
+	*   - {Boolean} [isWeakDep=false] - whether it's a weak dependency
+	* @returns {Function} - a callback
+	* @example
+	* const done = app.readyCallback('mysql');
+	* mysql.ready(done);
+	*/
+	readyCallback(name, opts) {
+		this.deprecate("`readyCallback` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		return this.lifecycle.legacyReadyCallback(name, opts);
+	}
+	/**
+	* Register a function that will be called when app close.
+	*
+	* Notice:
+	* This method is now NOT recommended directly used,
+	* Developers SHOULDN'T use app.beforeClose directly now,
+	* but in the form of class to implement beforeClose instead.
+	*
+	* @see https://eggjs.org/en/advanced/loader.html#beforeclose
+	*
+	* @param {Function} fn - the function that can be generator function or async function.
+	*/
+	beforeClose(fn, name) {
+		this.deprecate("`beforeClose` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		this.lifecycle.registerBeforeClose(fn, name);
+	}
+	/**
+	* Close all, it will close
+	* - callbacks registered by beforeClose
+	* - emit `close` event
+	* - remove add listeners
+	*
+	* If error is thrown when it's closing, the promise will reject.
+	* It will also reject after following call.
+	* @returns {Promise} promise
+	* @since 1.0.0
+	*/
+	async close() {
+		if (this.#closePromise) return this.#closePromise;
+		this.#closePromise = this.lifecycle.close();
+		return this.#closePromise;
+	}
+	/**
+	* get router
+	* @member {Router} EggCore#router
+	* @since 1.0.0
+	*/
+	get router() {
+		if (this.#router) return this.#router;
+		this.#router = new Router({ sensitive: true }, this);
+		return this.#router;
+	}
+	/**
+	* Alias to {@link Router#url}
+	* @param {String} name - Router name
+	* @param {Object} params - more parameters
+	* @returns {String} url
+	*/
+	url(name, params) {
+		return this.router.url(name, params);
+	}
+	head(...args) {
+		this.router.head.apply(this.router, args);
+		return this;
+	}
+	get(...args) {
+		this.router.get.apply(this.router, args);
+		return this;
+	}
+	put(...args) {
+		this.router.put.apply(this.router, args);
+		return this;
+	}
+	patch(...args) {
+		this.router.patch.apply(this.router, args);
+		return this;
+	}
+	post(...args) {
+		this.router.post.apply(this.router, args);
+		return this;
+	}
+	delete(...args) {
+		this.router.delete.apply(this.router, args);
+		return this;
+	}
+	del(...args) {
+		this.router.del.apply(this.router, args);
+		return this;
+	}
+	all(...args) {
+		this.router.all.apply(this.router, args);
+		return this;
+	}
+	resources(...args) {
+		this.router.resources.apply(this.router, args);
+		return this;
+	}
+	redirect(source, destination, status = 301) {
+		this.router.redirect(source, destination, status);
+		return this;
+	}
+	register(path$1, methods, middleware, opts) {
+		this.router.register(path$1, methods, middleware, opts);
+		return this;
+	}
+	get [EGG_LOADER]() {
+		return EggLoader;
+	}
+};
+
+//#endregion
 export { BaseContextClass, CaseStyle, ClassLoader, Context, ContextLoader, EGG_LOADER, EXPORTS, EggCore, EggLoader, FULLPATH, FileLoader, KoaApplication, KoaContext, KoaRequest, KoaResponse, Lifecycle, Request, Response, Router, Singleton, Timing, sequencify, utils_default as utils };