@eggjs/tegg-metadata 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/index.js

@@ -1,28 +1,1260 @@
-import { EggPrototypeNotFound, IncompatibleProtoInject, MultiPrototypeFound, TeggError } from "./errors.js";
-import { EggPrototypeFactory } from "./factory/EggPrototypeFactory.js";
-import { AbstractProtoDescriptor } from "./model/ProtoDescriptor/AbstractProtoDescriptor.js";
-import { ClassProtoDescriptor } from "./model/ProtoDescriptor/ClassProtoDescriptor.js";
-import { ProtoDescriptorHelper } from "./model/ProtoDescriptorHelper.js";
-import { ProtoDependencyMeta, ProtoNode } from "./model/graph/ProtoNode.js";
-import { GlobalModuleNode, ModuleDependencyMeta } from "./model/graph/GlobalModuleNode.js";
-import { GlobalModuleNodeBuilder } from "./model/graph/GlobalModuleNodeBuilder.js";
-import { GlobalGraph } from "./model/graph/GlobalGraph.js";
-import { AppGraph, ClazzMap, ModuleNode } from "./model/AppGraph.js";
-import { EggPrototypeLifecycleUtil } from "./model/EggPrototype.js";
-import { LoadUnitLifecycleUtil } from "./model/LoadUnit.js";
-import { ModuleDescriptorDumper } from "./model/ModuleDescriptor.js";
-import "./model/index.js";
-import { EggPrototypeCreatorFactory } from "./factory/EggPrototypeCreatorFactory.js";
-import { LoadUnitFactory } from "./factory/LoadUnitFactory.js";
-import "./factory/index.js";
-import { ClassUtil } from "./util/ClassUtil.js";
-import "./util/index.js";
-import { EggPrototypeImpl } from "./impl/EggPrototypeImpl.js";
-import { EggPrototypeBuilder } from "./impl/EggPrototypeBuilder.js";
-import { LoadUnitMultiInstanceProtoHook } from "./impl/LoadUnitMultiInstanceProtoHook.js";
-import { ModuleGraph, ModuleLoadUnit } from "./impl/ModuleLoadUnit.js";
-import "./impl/index.js";
+import { Graph, GraphNode, MapUtil, ModuleConfigUtil } from "@eggjs/tegg-common-util";
+import { AccessLevel, DEFAULT_PROTO_IMPL_TYPE, EggLoadUnitType, ErrorCodes, INIT_TYPE_TRY_ORDER, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, MultiInstanceType, ObjectInitType, ProtoDescriptorType } from "@eggjs/tegg-types";
+import { FrameworkBaseError, FrameworkErrorFormater } from "egg-errors";
+import assert from "node:assert";
+import util, { debuglog } from "node:util";
+import { InitTypeQualifierAttribute as InitTypeQualifierAttribute$1, InjectType, LoadUnitNameQualifierAttribute as LoadUnitNameQualifierAttribute$1, MetadataUtil, PrototypeUtil, QualifierUtil } from "@eggjs/core-decorator";
+import { IdenticalUtil, LifecycleUtil } from "@eggjs/tegg-lifecycle";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 
 export * from "@eggjs/tegg-types/metadata"
 
+//#region src/errors.ts
+var TeggError = class extends FrameworkBaseError {
+	get module() {
+		return "TEGG";
+	}
+};
+var EggPrototypeNotFound = class extends TeggError {
+	constructor(protoName, loadUnitId) {
+		const msg = loadUnitId ? `Object ${String(protoName)} not found in ${loadUnitId}` : `Object ${String(protoName)} not found`;
+		super(msg, ErrorCodes.EGG_PROTO_NOT_FOUND);
+	}
+};
+var MultiPrototypeFound = class extends TeggError {
+	constructor(name, qualifier, result) {
+		const msg = `multi proto found for name:${String(name)} and qualifiers ${JSON.stringify(qualifier)}${result ? `, result is ${result}` : ""}`;
+		super(msg, ErrorCodes.MULTI_PROTO_FOUND);
+	}
+};
+var IncompatibleProtoInject = class extends TeggError {
+	constructor(msg) {
+		super(msg, ErrorCodes.INCOMPATIBLE_PROTO_INJECT);
+	}
+};
+
+//#endregion
+//#region src/factory/EggPrototypeFactory.ts
+var EggPrototypeFactory = class EggPrototypeFactory {
+	static instance = new EggPrototypeFactory();
+	publicProtoMap = /* @__PURE__ */ new Map();
+	registerPrototype(proto, loadUnit) {
+		if (proto.accessLevel === AccessLevel.PUBLIC) MapUtil.getOrStore(this.publicProtoMap, proto.name, []).push(proto);
+		loadUnit.registerEggPrototype(proto);
+	}
+	deletePrototype(proto, loadUnit) {
+		if (proto.accessLevel === AccessLevel.PUBLIC) {
+			const protos = this.publicProtoMap.get(proto.name);
+			if (protos) {
+				const index = protos.indexOf(proto);
+				if (index !== -1) protos.splice(index, 1);
+			}
+		}
+		loadUnit.deletePrototype(proto);
+	}
+	getPrototype(name, loadUnit, qualifiers) {
+		qualifiers = qualifiers || [];
+		const protos = this.doGetPrototype(name, qualifiers, loadUnit);
+		if (!protos.length) throw FrameworkErrorFormater.formatError(new EggPrototypeNotFound(name, loadUnit?.id));
+		if (protos.length === 1) return protos[0];
+		throw FrameworkErrorFormater.formatError(new MultiPrototypeFound(name, qualifiers));
+	}
+	doGetPrototype(name, qualifiers, loadUnit) {
+		if (loadUnit) {
+			const protos = loadUnit.getEggPrototype(name, qualifiers);
+			if (protos.length) return protos;
+		}
+		return this.publicProtoMap.get(name)?.filter((proto) => proto.verifyQualifiers(qualifiers)) || [];
+	}
+};
+
+//#endregion
+//#region src/model/ProtoDescriptor/AbstractProtoDescriptor.ts
+var AbstractProtoDescriptor = class {
+	name;
+	accessLevel;
+	initType;
+	qualifiers;
+	injectObjects;
+	protoImplType;
+	defineModuleName;
+	defineUnitPath;
+	instanceModuleName;
+	instanceDefineUnitPath;
+	className;
+	properQualifiers;
+	type;
+	constructor(options) {
+		this.name = options.name;
+		this.accessLevel = options.accessLevel;
+		this.initType = options.initType;
+		this.qualifiers = options.qualifiers;
+		this.protoImplType = options.protoImplType;
+		this.injectObjects = options.injectObjects;
+		this.defineModuleName = options.defineModuleName;
+		this.defineUnitPath = options.defineUnitPath;
+		this.instanceModuleName = options.instanceModuleName;
+		this.instanceDefineUnitPath = options.instanceDefineUnitPath;
+		this.type = options.type;
+		this.properQualifiers = options.properQualifiers;
+	}
+};
+
+//#endregion
+//#region src/model/ProtoDescriptor/ClassProtoDescriptor.ts
+var ClassProtoDescriptor = class ClassProtoDescriptor extends AbstractProtoDescriptor {
+	clazz;
+	clazzName;
+	static isClassProtoDescriptor(descriptor) {
+		return descriptor.type === ProtoDescriptorType.CLASS;
+	}
+	constructor(options) {
+		super({
+			type: ProtoDescriptorType.CLASS,
+			...options
+		});
+		this.clazz = options.clazz;
+		this.className = this.clazz.name;
+	}
+	equal(protoDescriptor) {
+		if (!ClassProtoDescriptor.isClassProtoDescriptor(protoDescriptor)) return false;
+		return this.clazz === protoDescriptor.clazz && this.name === protoDescriptor.name && this.accessLevel === protoDescriptor.accessLevel && this.initType === protoDescriptor.initType && this.instanceModuleName === protoDescriptor.instanceModuleName && QualifierUtil.equalQualifiers(this.qualifiers, protoDescriptor.qualifiers);
+	}
+};
+
+//#endregion
+//#region src/model/ProtoDescriptorHelper.ts
+var ProtoDescriptorHelper = class ProtoDescriptorHelper {
+	static addDefaultQualifier(qualifiers, initType, loadUnitName) {
+		const defaultQualifiers = [{
+			attribute: InitTypeQualifierAttribute,
+			value: initType
+		}, {
+			attribute: LoadUnitNameQualifierAttribute,
+			value: loadUnitName
+		}];
+		const res = [...qualifiers];
+		for (const defaultQualifier of defaultQualifiers) if (!qualifiers.find((t) => t.attribute === defaultQualifier.attribute)) res.push(defaultQualifier);
+		return res;
+	}
+	static async createByMultiInstanceClazz(clazz, options) {
+		assert(PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not MultiInstancePrototype`);
+		const type = PrototypeUtil.getEggMultiInstancePrototypeType(clazz);
+		if (type === MultiInstanceType.DYNAMIC) return await ProtoDescriptorHelper.createByDynamicMultiInstanceClazz(clazz, options);
+		else if (type === MultiInstanceType.STATIC) {
+			if (options.defineModuleName === options.instanceModuleName) return ProtoDescriptorHelper.createByStaticMultiInstanceClazz(clazz, options);
+		}
+		return [];
+	}
+	static async createByDynamicMultiInstanceClazz(clazz, options) {
+		assert(PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not MultiInstancePrototype`);
+		const instanceProperty = await PrototypeUtil.getDynamicMultiInstanceProperty(clazz, {
+			moduleName: options.instanceModuleName,
+			unitPath: options.instanceDefineUnitPath
+		});
+		assert(instanceProperty, `not found PrototypeInfo for clazz ${clazz.name}`);
+		return ProtoDescriptorHelper.#createByMultiInstanceClazz(clazz, instanceProperty, options);
+	}
+	static createByStaticMultiInstanceClazz(clazz, options) {
+		assert(PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not MultiInstancePrototype`);
+		const instanceProperty = PrototypeUtil.getStaticMultiInstanceProperty(clazz);
+		assert(instanceProperty, `not found PrototypeInfo for clazz ${clazz.name}`);
+		return ProtoDescriptorHelper.#createByMultiInstanceClazz(clazz, instanceProperty, options);
+	}
+	static #createByMultiInstanceClazz(clazz, instanceProperty, options) {
+		const res = [];
+		for (const obj of instanceProperty.objects) {
+			let qualifiers = QualifierUtil.mergeQualifiers(QualifierUtil.getProtoQualifiers(clazz), obj.qualifiers);
+			qualifiers = ProtoDescriptorHelper.addDefaultQualifier(qualifiers, instanceProperty.initType, options.instanceModuleName);
+			const injectObjects = PrototypeUtil.getInjectObjects(clazz).map((t) => {
+				const qualifiers$1 = QualifierUtil.getProperQualifiers(clazz, t.refName);
+				const instanceQualifier = obj.properQualifiers?.[t.refName] ?? [];
+				return {
+					...t,
+					qualifiers: QualifierUtil.mergeQualifiers(qualifiers$1, instanceQualifier)
+				};
+			});
+			res.push(new ClassProtoDescriptor({
+				name: obj.name,
+				accessLevel: instanceProperty.accessLevel,
+				initType: instanceProperty.initType,
+				protoImplType: instanceProperty.protoImplType,
+				qualifiers,
+				injectObjects,
+				instanceModuleName: options.instanceModuleName,
+				instanceDefineUnitPath: options.instanceDefineUnitPath,
+				defineModuleName: options.defineModuleName,
+				defineUnitPath: options.defineUnitPath,
+				clazz,
+				properQualifiers: obj.properQualifiers || {}
+			}));
+		}
+		return res;
+	}
+	static createByInstanceClazz(clazz, ctx) {
+		assert(PrototypeUtil.isEggPrototype(clazz), `clazz ${clazz.name} is not EggPrototype`);
+		assert(!PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not Prototype`);
+		const property = PrototypeUtil.getProperty(clazz);
+		assert(property, `not found PrototypeInfo for clazz ${clazz.name}`);
+		const protoQualifiers = ProtoDescriptorHelper.addDefaultQualifier(QualifierUtil.getProtoQualifiers(clazz), property.initType, ctx.moduleName);
+		const injectObjects = PrototypeUtil.getInjectObjects(clazz).map((t) => {
+			const qualifiers = QualifierUtil.getProperQualifiers(clazz, t.refName);
+			return {
+				...t,
+				qualifiers
+			};
+		});
+		return new ClassProtoDescriptor({
+			name: property.name,
+			protoImplType: property.protoImplType,
+			accessLevel: property.accessLevel,
+			initType: property.initType,
+			qualifiers: protoQualifiers,
+			injectObjects,
+			instanceDefineUnitPath: ctx.unitPath,
+			instanceModuleName: ctx.moduleName,
+			defineUnitPath: ctx.unitPath,
+			defineModuleName: ctx.moduleName,
+			clazz,
+			properQualifiers: {}
+		});
+	}
+	static selectProto(proto, ctx) {
+		if (proto.name !== ctx.name) return false;
+		if (proto.accessLevel !== AccessLevel.PUBLIC && proto.instanceModuleName !== ctx.moduleName) return false;
+		if (!QualifierUtil.matchQualifiers(proto.qualifiers, ctx.qualifiers)) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region src/model/graph/ProtoNode.ts
+var ProtoDependencyMeta = class {
+	injectObj;
+	constructor({ injectObj }) {
+		this.injectObj = injectObj;
+	}
+	equal(meta) {
+		return this.injectObj === meta.injectObj;
+	}
+	toString() {
+		return `inject ${String(this.injectObj)}`;
+	}
+};
+var ProtoNode = class ProtoNode {
+	id;
+	proto;
+	constructor(proto) {
+		this.id = ProtoNode.createProtoId(proto);
+		this.proto = proto;
+	}
+	toString() {
+		return `${String(this.proto.name)}@${this.proto.instanceDefineUnitPath}`;
+	}
+	selectProto(ctx) {
+		return ProtoDescriptorHelper.selectProto(this.proto, ctx);
+	}
+	static createProtoId(proto) {
+		return [
+			proto.name,
+			proto.instanceModuleName,
+			proto.initType,
+			...proto.qualifiers.map((t) => String(t.attribute) + String(t.value))
+		].join("@");
+	}
+};
+
+//#endregion
+//#region src/model/graph/GlobalModuleNode.ts
+var ModuleDependencyMeta = class {
+	obj;
+	injectObj;
+	constructor(obj, injectObj) {
+		this.obj = obj;
+		this.injectObj = injectObj;
+	}
+	equal(meta) {
+		return this.obj.equal(meta.obj) && this.injectObj === meta.injectObj;
+	}
+	toString() {
+		return `Object ${String(this.obj.name)} inject ${String(this.injectObj)}`;
+	}
+};
+var GlobalModuleNode = class {
+	id;
+	name;
+	unitPath;
+	optional;
+	protos;
+	constructor(options) {
+		this.id = options.unitPath;
+		this.name = options.name;
+		this.unitPath = options.unitPath;
+		this.optional = options.optional;
+		this.protos = [];
+	}
+	addProto(proto) {
+		this.protos.push(new GraphNode(new ProtoNode(proto)));
+	}
+	toString() {
+		return `${this.name}@${this.unitPath}`;
+	}
+};
+
+//#endregion
+//#region src/model/graph/GlobalModuleNodeBuilder.ts
+var GlobalModuleNodeBuilder = class GlobalModuleNodeBuilder {
+	name;
+	unitPath;
+	optional;
+	protos;
+	constructor(options) {
+		this.name = options.name;
+		this.unitPath = options.unitPath;
+		this.optional = options.optional;
+		this.protos = [];
+	}
+	addClazz(clazz) {
+		const proto = ProtoDescriptorHelper.createByInstanceClazz(clazz, {
+			moduleName: this.name,
+			unitPath: this.unitPath
+		});
+		this.protos.push(proto);
+		return this;
+	}
+	async addMultiInstanceClazz(clazz, defineModuleName, defineUnitPath) {
+		const protos = await ProtoDescriptorHelper.createByMultiInstanceClazz(clazz, {
+			defineModuleName,
+			defineUnitPath,
+			instanceModuleName: this.name,
+			instanceDefineUnitPath: this.unitPath
+		});
+		this.protos.push(...protos);
+		return this;
+	}
+	build() {
+		const node = new GlobalModuleNode({
+			name: this.name,
+			unitPath: this.unitPath,
+			optional: this.optional
+		});
+		for (const proto of this.protos) node.addProto(proto);
+		return node;
+	}
+	static create(unitPath, optional = false) {
+		const name = ModuleConfigUtil.readModuleNameSync(unitPath);
+		return new GlobalModuleNodeBuilder({
+			name,
+			unitPath,
+			optional
+		});
+	}
+};
+
+//#endregion
+//#region src/model/graph/GlobalGraph.ts
+const debug$2 = debuglog("tegg/core/metadata/model/graph/GlobalGraph");
+/**
+* Sort all prototypes and modules in app.
+* - 1. LoaderFactory.loadApp: get ModuleDescriptors
+* - 2. GlobalGraph.create: create global graph instance
+* - 3. graph.build:
+*   - check duplicated prototypes exits
+*   - check inject object exists (only in strict mode,
+*   can register proto in hooks now, in next major version,
+*   should use load to create dynamic ProtoDescriptor and delete
+*   strict false options
+*   )
+* - 4. graph.sort: build moduleConfigList and moduleProtoDescriptorMap
+*/
+var GlobalGraph = class GlobalGraph {
+	/**
+	* Vertex: ModuleNode, collect prototypes in module
+	* Edge: ModuleDependencyMeta, prototype and it's inject object
+	* @private
+	*/
+	moduleGraph;
+	/**
+	* Vertex: ProtoNode, collect all prototypes in app
+	* Edge: ProtoDependencyMeta, inject object
+	* @private
+	*/
+	protoGraph;
+	/**
+	* The order of the moduleConfigList is the order in which they are instantiated
+	*/
+	moduleConfigList;
+	/**
+	* key: module name
+	* value: ProtoDescriptor in module, the order is the order in which they are instantiated
+	*/
+	moduleProtoDescriptorMap;
+	strict;
+	buildHooks;
+	/**
+	* The global instance used in ModuleLoadUnit
+	*/
+	static instance;
+	constructor(options) {
+		this.moduleGraph = new Graph();
+		this.protoGraph = new Graph();
+		this.strict = options?.strict ?? false;
+		this.moduleProtoDescriptorMap = /* @__PURE__ */ new Map();
+		this.buildHooks = [];
+	}
+	registerBuildHook(hook) {
+		this.buildHooks.push(hook);
+	}
+	addModuleNode(moduleNode) {
+		if (!this.moduleGraph.addVertex(new GraphNode(moduleNode))) throw new Error(`duplicate module: ${moduleNode}`);
+		for (const protoNode of moduleNode.protos) if (!this.protoGraph.addVertex(protoNode)) throw new Error(`duplicate proto: ${protoNode.val}`);
+	}
+	build() {
+		for (const moduleNode of this.moduleGraph.nodes.values()) for (const protoNode of moduleNode.val.protos) for (const injectObj of protoNode.val.proto.injectObjects) this.buildInjectEdge(moduleNode, protoNode, injectObj);
+		for (const buildHook of this.buildHooks) buildHook(this);
+	}
+	buildInjectEdge(moduleNode, protoNode, injectObj) {
+		const injectProto = this.findDependencyProtoNode(protoNode.val.proto, injectObj);
+		if (!injectProto) {
+			if (!this.strict) return;
+			throw FrameworkErrorFormater.formatError(new EggPrototypeNotFound(injectObj.objName, protoNode.val.proto.instanceModuleName));
+		}
+		this.addInject(moduleNode, protoNode, injectProto, injectObj.objName);
+	}
+	addInject(moduleNode, protoNode, injectNode, injectName) {
+		this.protoGraph.addEdge(protoNode, injectNode, new ProtoDependencyMeta({ injectObj: injectName }));
+		const injectModule = this.findModuleNode(injectNode.val.proto.instanceModuleName);
+		if (!injectModule) {
+			if (!this.strict) return;
+			throw new Error(`not found module ${injectNode.val.proto.instanceModuleName}`);
+		}
+		if (moduleNode.val.id !== injectModule.val.id) this.moduleGraph.addEdge(moduleNode, injectModule, new ModuleDependencyMeta(protoNode.val.proto, injectName));
+	}
+	findInjectProto(proto, injectObject) {
+		return this.protoGraph.findToNode(ProtoNode.createProtoId(proto), new ProtoDependencyMeta({ injectObj: injectObject.objName }))?.val.proto;
+	}
+	#findDependencyProtoWithDefaultQualifiers(proto, injectObject, qualifiers) {
+		const result = [];
+		for (const node of this.protoGraph.nodes.values()) if (node.val.selectProto({
+			name: injectObject.objName,
+			qualifiers: QualifierUtil.mergeQualifiers(injectObject.qualifiers, qualifiers),
+			moduleName: proto.instanceModuleName
+		})) result.push(node);
+		return result;
+	}
+	findDependencyProtoNode(proto, injectObject) {
+		const protos = this.#findDependencyProtoWithDefaultQualifiers(proto, injectObject, []);
+		if (protos.length === 0) return;
+		if (protos.length === 1) return protos[0];
+		const protoWithContext = this.#findDependencyProtoWithDefaultQualifiers(proto, injectObject, [{
+			attribute: InitTypeQualifierAttribute,
+			value: ObjectInitType.CONTEXT
+		}]);
+		if (protoWithContext.length === 1) return protoWithContext[0];
+		const protoWithSelfInitType = this.#findDependencyProtoWithDefaultQualifiers(proto, injectObject, [{
+			attribute: InitTypeQualifierAttribute,
+			value: proto.initType
+		}]);
+		if (protoWithSelfInitType.length === 1) return protoWithSelfInitType[0];
+		if (!injectObject.qualifiers.find((t) => t.attribute === LoadUnitNameQualifierAttribute)) return this.findDependencyProtoNode(proto, {
+			...injectObject,
+			qualifiers: QualifierUtil.mergeQualifiers(injectObject.qualifiers, [{
+				attribute: LoadUnitNameQualifierAttribute,
+				value: proto.instanceModuleName
+			}])
+		});
+		throw FrameworkErrorFormater.formatError(new MultiPrototypeFound(injectObject.objName, injectObject.qualifiers));
+	}
+	findModuleNode(moduleName) {
+		for (const node of this.moduleGraph.nodes.values()) if (node.val.name === moduleName) return node;
+	}
+	#sortModule() {
+		const loopPath = this.moduleGraph.loopPath();
+		if (loopPath) throw new Error("module has recursive deps: " + loopPath);
+		debug$2("sortModule, loopPath: %o", loopPath);
+		this.moduleConfigList = this.moduleGraph.sort().filter((t) => {
+			return t.val.optional !== true || t.fromNodeMap.size > 0;
+		}).map((t) => {
+			return {
+				name: t.val.name,
+				path: t.val.unitPath,
+				optional: t.val.optional
+			};
+		});
+	}
+	#sortClazz() {
+		const loopPath = this.protoGraph.loopPath();
+		if (loopPath) throw new Error("proto has recursive deps: " + loopPath);
+		debug$2("sortClazz, loopPath: %o", loopPath);
+		for (const proto of this.protoGraph.sort()) {
+			const instanceModuleName = proto.val.proto.instanceModuleName;
+			let moduleProtoList = this.moduleProtoDescriptorMap.get(instanceModuleName);
+			if (!moduleProtoList) {
+				moduleProtoList = [];
+				this.moduleProtoDescriptorMap.set(instanceModuleName, moduleProtoList);
+			}
+			moduleProtoList.push(proto.val.proto);
+		}
+	}
+	sort() {
+		this.#sortModule();
+		this.#sortClazz();
+	}
+	static async create(moduleDescriptors, options) {
+		const graph = new GlobalGraph(options);
+		for (const moduleDescriptor of moduleDescriptors) {
+			const moduleNodeBuilder = new GlobalModuleNodeBuilder({
+				name: moduleDescriptor.name,
+				unitPath: moduleDescriptor.unitPath,
+				optional: moduleDescriptor.optional ?? false
+			});
+			for (const clazz of moduleDescriptor.clazzList) moduleNodeBuilder.addClazz(clazz);
+			for (const clazz of moduleDescriptor.multiInstanceClazzList) await moduleNodeBuilder.addMultiInstanceClazz(clazz, moduleDescriptor.name, moduleDescriptor.unitPath);
+			graph.addModuleNode(moduleNodeBuilder.build());
+		}
+		return graph;
+	}
+};
+
+//#endregion
+//#region src/model/AppGraph.ts
+function verifyQualifier(clazzQualifiers, qualifier) {
+	return clazzQualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
+}
+function verifyQualifiers(clazzQualifiers, qualifiers) {
+	for (const qualifier of qualifiers) if (!verifyQualifier(clazzQualifiers, qualifier)) return false;
+	return true;
+}
+var ClazzMap = class {
+	clazzMap;
+	graph;
+	constructor(graph) {
+		this.graph = graph;
+	}
+	async build() {
+		const graph = this.graph;
+		/**
+		* 1. iterate all module get all MultiInstanceClazz
+		* 2. iterate MultiInstanceClazz and all module get object meta
+		* 3. iterate object meta and build clazz map
+		*/
+		const clazzMap = {};
+		for (const ownerNode of graph.nodes.values()) for (const clazz of ownerNode.val.getClazzList()) {
+			const qualifiers = QualifierUtil.getProtoQualifiers(clazz);
+			if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) for (const instanceNode of graph.nodes.values()) {
+				const property = await PrototypeUtil.getMultiInstanceProperty(clazz, {
+					unitPath: instanceNode.val.moduleConfig.path,
+					moduleName: instanceNode.val.moduleConfig.name
+				});
+				assert(property, `multi instance property not found for ${clazz.name}`);
+				for (const info of property.objects) {
+					const instanceQualifiers = [...qualifiers, ...info.qualifiers];
+					clazzMap[info.name] = clazzMap[info.name] || [];
+					clazzMap[info.name].push({
+						name: info.name,
+						accessLevel: await PrototypeUtil.getAccessLevel(clazz, {
+							unitPath: instanceNode.val.moduleConfig.path,
+							moduleName: instanceNode.val.moduleConfig.name
+						}),
+						qualifiers: instanceQualifiers,
+						properQualifiers: info.properQualifiers || {},
+						instanceModule: instanceNode,
+						ownerModule: ownerNode
+					});
+				}
+			}
+			else {
+				const property = PrototypeUtil.getProperty(clazz);
+				assert(property, `property not found for ${clazz.name}`);
+				clazzMap[property.name] = clazzMap[property.name] || [];
+				clazzMap[property.name].push({
+					name: property.name,
+					accessLevel: await PrototypeUtil.getAccessLevel(clazz, {
+						unitPath: ownerNode.val.moduleConfig.path,
+						moduleName: ownerNode.val.moduleConfig.name
+					}),
+					qualifiers,
+					properQualifiers: {},
+					ownerModule: ownerNode,
+					instanceModule: ownerNode
+				});
+			}
+		}
+		this.clazzMap = clazzMap;
+	}
+	findDependencyModule(objName, properQualifiers, intoModule) {
+		const result = /* @__PURE__ */ new Set();
+		const objInfo = this.clazzMap[objName];
+		if (!objInfo) return [];
+		let mayObjs = objInfo.filter((obj) => {
+			if (obj.instanceModule !== intoModule && obj.accessLevel === AccessLevel.PRIVATE) return false;
+			return verifyQualifiers(obj.qualifiers, properQualifiers);
+		});
+		if (mayObjs.length > 1) {
+			const initTypeQualifiers = INIT_TYPE_TRY_ORDER.map((type) => ({
+				attribute: InitTypeQualifierAttribute,
+				value: type
+			}));
+			for (const initTypeQualifier of initTypeQualifiers) {
+				const mayInitTypeObjs = mayObjs.filter((obj) => {
+					return verifyQualifiers(obj.qualifiers, [...properQualifiers, initTypeQualifier]);
+				});
+				if (mayInitTypeObjs.length > 0) mayObjs = mayInitTypeObjs;
+			}
+		}
+		if (mayObjs.length > 1) {
+			const moduleNameQualifiers = {
+				attribute: LoadUnitNameQualifierAttribute,
+				value: intoModule.val.name
+			};
+			const mayLoadUnitNameObjs = mayObjs.filter((obj) => {
+				return verifyQualifiers(obj.qualifiers, [...properQualifiers, moduleNameQualifiers]);
+			});
+			if (mayLoadUnitNameObjs.length > 0) mayObjs = mayLoadUnitNameObjs;
+		}
+		if (mayObjs.length > 1) {
+			const message = util.format("multi class found for %s@%o in module %j", objName, properQualifiers, mayObjs.map((t) => {
+				return t.instanceModule.val.moduleConfig.path;
+			}));
+			throw new Error(message);
+		}
+		for (const obj of mayObjs) result.add(obj.instanceModule);
+		return Array.from(result);
+	}
+};
+var ModuleNode = class {
+	id;
+	name;
+	moduleConfig;
+	clazzList;
+	constructor(moduleConfig) {
+		this.moduleConfig = moduleConfig;
+		this.id = moduleConfig.path;
+		this.name = ModuleConfigUtil.readModuleNameSync(moduleConfig.path);
+		this.clazzList = [];
+	}
+	async addClazz(clazz) {
+		if (!this.clazzList.includes(clazz)) this.clazzList.push(clazz);
+		if (!PrototypeUtil.isEggMultiInstancePrototype(clazz)) {
+			const initTypeQualifierAttributeValue = await PrototypeUtil.getInitType(clazz, {
+				unitPath: this.moduleConfig.path,
+				moduleName: this.moduleConfig.name
+			});
+			const defaultQualifier = [{
+				attribute: InitTypeQualifierAttribute,
+				value: initTypeQualifierAttributeValue
+			}, {
+				attribute: LoadUnitNameQualifierAttribute,
+				value: this.name
+			}];
+			for (const qualifier of defaultQualifier) QualifierUtil.addProtoQualifier(clazz, qualifier.attribute, qualifier.value);
+		}
+	}
+	toString() {
+		return `${this.name}@${this.moduleConfig.path}`;
+	}
+	getClazzList() {
+		return this.clazzList;
+	}
+};
+var AppGraph = class {
+	graph;
+	clazzMap;
+	moduleConfigList;
+	constructor() {
+		this.graph = new Graph();
+	}
+	addNode(moduleNode) {
+		if (!this.graph.addVertex(new GraphNode(moduleNode))) throw new Error(`duplicate module: ${moduleNode}`);
+	}
+	getClazzList() {
+		const clazzSet = /* @__PURE__ */ new Set();
+		for (const node of this.graph.nodes.values()) for (const clazz of node.val.getClazzList()) clazzSet.add(clazz);
+		return Array.from(clazzSet);
+	}
+	async build() {
+		this.clazzMap = new ClazzMap(this.graph);
+		await this.clazzMap.build();
+		for (const node of this.graph.nodes.values()) for (const clazz of node.val.getClazzList()) {
+			const injectObjects = PrototypeUtil.getInjectObjects(clazz);
+			for (const injectObject of injectObjects) if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) for (const instanceNode of this.graph.nodes.values()) {
+				const property = await PrototypeUtil.getMultiInstanceProperty(clazz, {
+					unitPath: instanceNode.val.moduleConfig.path,
+					moduleName: instanceNode.val.moduleConfig.name
+				});
+				for (const info of property?.objects || []) {
+					const properQualifiers = [...QualifierUtil.getProperQualifiers(clazz, injectObject.refName), ...info.properQualifiers?.[injectObject.refName] ?? []];
+					const dependencyModules = this.clazzMap.findDependencyModule(injectObject.objName, properQualifiers, node);
+					for (const moduleNode of dependencyModules) if (instanceNode !== moduleNode) this.graph.addEdge(instanceNode, moduleNode);
+				}
+			}
+			else {
+				const properQualifiers = [...QualifierUtil.getProperQualifiers(clazz, injectObject.refName)];
+				const dependencyModules = this.clazzMap.findDependencyModule(injectObject.objName, properQualifiers, node);
+				for (const moduleNode of dependencyModules) if (node !== moduleNode) this.graph.addEdge(node, moduleNode);
+			}
+		}
+	}
+	sort() {
+		const loopPath = this.graph.loopPath();
+		if (loopPath) throw new Error("module has recursive deps: " + loopPath);
+		this.moduleConfigList = this.graph.sort().filter((t) => {
+			return t.val.moduleConfig.optional !== true || t.fromNodeMap.size > 0;
+		}).map((t) => t.val.moduleConfig);
+	}
+};
+
+//#endregion
+//#region src/model/EggPrototype.ts
+const EggPrototypeLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+//#region src/model/LoadUnit.ts
+const LoadUnitLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+//#region src/model/ModuleDescriptor.ts
+const DUMP_PATH = process.env.MODULE_DUMP_PATH;
+var ModuleDescriptorDumper = class ModuleDescriptorDumper {
+	static stringifyDescriptor(moduleDescriptor) {
+		return `{"name": "${moduleDescriptor.name}","unitPath": "${moduleDescriptor.unitPath}",` + (typeof moduleDescriptor.optional !== "undefined" ? `"optional": ${moduleDescriptor.optional},` : "") + `"clazzList": [${moduleDescriptor.clazzList.map((t) => {
+			return ModuleDescriptorDumper.stringifyClazz(t, moduleDescriptor);
+		}).join(",")}],"multiInstanceClazzList": [${moduleDescriptor.multiInstanceClazzList.map((t) => {
+			return ModuleDescriptorDumper.stringifyClazz(t, moduleDescriptor);
+		}).join(",")}],"protos": [${moduleDescriptor.protos.map((t) => {
+			return JSON.stringify(t);
+		}).join(",")}]}`;
+	}
+	static stringifyClazz(clazz, moduleDescriptor) {
+		return `{"name": "${clazz.name}",` + (PrototypeUtil.getFilePath(clazz) ? `"filePath": "${path.relative(moduleDescriptor.unitPath, PrototypeUtil.getFilePath(clazz))}"` : "") + "}";
+	}
+	static dumpPath(desc, options) {
+		const dumpDir = DUMP_PATH ?? options?.dumpDir ?? desc.unitPath;
+		return path.join(dumpDir, ".egg", `${desc.name}_module_desc.json`);
+	}
+	static async dump(desc, options) {
+		const dumpPath = ModuleDescriptorDumper.dumpPath(desc, options);
+		await fs.mkdir(path.dirname(dumpPath), { recursive: true });
+		await fs.writeFile(dumpPath, ModuleDescriptorDumper.stringifyDescriptor(desc));
+	}
+};
+
+//#endregion
+//#region src/factory/EggPrototypeCreatorFactory.ts
+const debug$1 = debuglog("tegg/core/metadata/factory/EggPrototypeCreatorFactory");
+var EggPrototypeCreatorFactory = class {
+	static creatorMap = /* @__PURE__ */ new Map();
+	static registerPrototypeCreator(type, creator) {
+		this.creatorMap.set(type, creator);
+	}
+	static getPrototypeCreator(type) {
+		return this.creatorMap.get(type);
+	}
+	static async createProto(clazz, loadUnit) {
+		let properties = [];
+		const initTypeQualifierAttributeValue = await PrototypeUtil.getInitType(clazz, {
+			unitPath: loadUnit.unitPath,
+			moduleName: loadUnit.name
+		});
+		const defaultQualifier = [{
+			attribute: InitTypeQualifierAttribute$1,
+			value: initTypeQualifierAttributeValue
+		}, {
+			attribute: LoadUnitNameQualifierAttribute$1,
+			value: loadUnit.name
+		}];
+		if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) {
+			const multiInstanceProtoInfo = await PrototypeUtil.getMultiInstanceProperty(clazz, {
+				unitPath: loadUnit.unitPath,
+				moduleName: loadUnit.name
+			});
+			assert(multiInstanceProtoInfo, `multiInstanceProtoInfo is undefined, clazz: ${clazz.name}, unitPath: ${loadUnit.unitPath}, moduleName: ${loadUnit.name}`);
+			for (const obj of multiInstanceProtoInfo.objects) {
+				defaultQualifier.forEach((qualifier) => {
+					if (!obj.qualifiers.find((t) => t.attribute === qualifier.attribute)) obj.qualifiers.push(qualifier);
+				});
+				properties.push({
+					name: obj.name,
+					protoImplType: multiInstanceProtoInfo.protoImplType,
+					initType: multiInstanceProtoInfo.initType,
+					accessLevel: multiInstanceProtoInfo.accessLevel,
+					qualifiers: obj.qualifiers,
+					properQualifiers: obj.properQualifiers,
+					className: multiInstanceProtoInfo.className
+				});
+			}
+		} else {
+			const property = PrototypeUtil.getProperty(clazz);
+			if (!property.qualifiers) property.qualifiers = [];
+			defaultQualifier.forEach((qualifier) => {
+				if (!property.qualifiers.find((t) => t.attribute === qualifier.attribute)) property.qualifiers.push(qualifier);
+			});
+			properties = [property];
+		}
+		const protos = [];
+		for (const property of properties) {
+			const creator = this.getPrototypeCreator(property.protoImplType);
+			if (!creator) throw new Error(`not found proto creator for type: ${property.protoImplType}`);
+			const ctx = {
+				clazz,
+				loadUnit,
+				prototypeInfo: property
+			};
+			const proto = creator(ctx);
+			await EggPrototypeLifecycleUtil.objectPreCreate(ctx, proto);
+			if (proto.init) await proto.init(ctx);
+			await EggPrototypeLifecycleUtil.objectPostCreate(ctx, proto);
+			PrototypeUtil.setClazzProto(clazz, proto);
+			protos.push(proto);
+		}
+		if (debug$1.enabled && loadUnit.name === "egg-app") debug$1("createProto, get protos:%o, from clazz:%o, from loadUnit:%o:%o:%o", protos.map((t) => t.name), clazz.name, loadUnit.type, loadUnit.name, loadUnit.unitPath);
+		return protos;
+	}
+	static async createProtoByDescriptor(protoDescriptor, loadUnit) {
+		const creator = this.getPrototypeCreator(protoDescriptor.protoImplType);
+		if (!creator) throw new Error(`not found proto creator for type: ${protoDescriptor.protoImplType}`);
+		const ctx = {
+			clazz: protoDescriptor.clazz,
+			loadUnit,
+			prototypeInfo: protoDescriptor
+		};
+		const proto = creator(ctx);
+		await EggPrototypeLifecycleUtil.objectPreCreate(ctx, proto);
+		if (proto.init) await proto.init(ctx);
+		await EggPrototypeLifecycleUtil.objectPostCreate(ctx, proto);
+		PrototypeUtil.setClazzProto(protoDescriptor.clazz, proto);
+		return proto;
+	}
+};
+
+//#endregion
+//#region src/factory/LoadUnitFactory.ts
+var LoadUnitFactory = class LoadUnitFactory {
+	static loadUnitCreatorMap = /* @__PURE__ */ new Map();
+	static loadUnitMap = /* @__PURE__ */ new Map();
+	static loadUnitIdMap = /* @__PURE__ */ new Map();
+	static async getLoanUnit(ctx, type) {
+		const creator = LoadUnitFactory.loadUnitCreatorMap.get(type);
+		if (!creator) throw new Error(`not find creator for load unit type ${type}`);
+		return await creator(ctx);
+	}
+	static async createLoadUnit(unitPath, type, loader) {
+		if (LoadUnitFactory.loadUnitMap.has(unitPath)) return LoadUnitFactory.loadUnitMap.get(unitPath).loadUnit;
+		const ctx = {
+			unitPath,
+			loader
+		};
+		const loadUnit = await LoadUnitFactory.getLoanUnit(ctx, type);
+		await LoadUnitLifecycleUtil.objectPreCreate(ctx, loadUnit);
+		if (loadUnit.init) await loadUnit.init(ctx);
+		await LoadUnitLifecycleUtil.objectPostCreate(ctx, loadUnit);
+		LoadUnitFactory.loadUnitMap.set(unitPath, {
+			loadUnit,
+			ctx
+		});
+		LoadUnitFactory.loadUnitIdMap.set(loadUnit.id, loadUnit);
+		return loadUnit;
+	}
+	static async createPreloadLoadUnit(unitPath, type, loader) {
+		const ctx = {
+			unitPath,
+			loader
+		};
+		return await LoadUnitFactory.getLoanUnit(ctx, type);
+	}
+	static async destroyLoadUnit(loadUnit) {
+		const { ctx } = LoadUnitFactory.loadUnitMap.get(loadUnit.unitPath);
+		try {
+			await LoadUnitLifecycleUtil.objectPreDestroy(ctx, loadUnit);
+			if (loadUnit.destroy) await loadUnit.destroy(ctx);
+		} finally {
+			LoadUnitFactory.loadUnitMap.delete(loadUnit.unitPath);
+			LoadUnitFactory.loadUnitIdMap.delete(loadUnit.id);
+			LoadUnitLifecycleUtil.clearObjectLifecycle(loadUnit);
+		}
+	}
+	static getLoadUnitById(id$1) {
+		return LoadUnitFactory.loadUnitIdMap.get(id$1);
+	}
+	static registerLoadUnitCreator(type, creator) {
+		LoadUnitFactory.loadUnitCreatorMap.set(type, creator);
+	}
+};
+
+//#endregion
+//#region src/util/ClassUtil.ts
+var ClassUtil = class {
+	static classDescription(clazz) {
+		const filePath = PrototypeUtil.getFilePath(clazz);
+		const name = this.className(clazz);
+		let desc = `class:${String(name)}`;
+		if (filePath) desc += `@${filePath}`;
+		return desc;
+	}
+	static className(clazz) {
+		return PrototypeUtil.getProperty(clazz)?.name || clazz.name;
+	}
+};
+
+//#endregion
+//#region src/impl/EggPrototypeImpl.ts
+var EggPrototypeImpl = class {
+	clazz;
+	qualifiers;
+	filepath;
+	id;
+	name;
+	initType;
+	accessLevel;
+	injectObjects;
+	injectType;
+	loadUnitId;
+	className;
+	multiInstanceConstructorIndex;
+	multiInstanceConstructorAttributes;
+	constructor(id$1, name, clazz, filepath, initType, accessLevel, injectObjectMap, loadUnitId, qualifiers, className, injectType, multiInstanceConstructorIndex, multiInstanceConstructorAttributes) {
+		this.id = id$1;
+		this.clazz = clazz;
+		this.name = name;
+		this.filepath = filepath;
+		this.initType = initType;
+		this.accessLevel = accessLevel;
+		this.injectObjects = injectObjectMap;
+		this.loadUnitId = loadUnitId;
+		this.qualifiers = qualifiers;
+		this.className = className;
+		this.injectType = injectType || InjectType.PROPERTY;
+		this.multiInstanceConstructorIndex = multiInstanceConstructorIndex;
+		this.multiInstanceConstructorAttributes = multiInstanceConstructorAttributes;
+	}
+	verifyQualifiers(qualifiers) {
+		for (const qualifier of qualifiers) if (!this.verifyQualifier(qualifier)) return false;
+		return true;
+	}
+	verifyQualifier(qualifier) {
+		return this.qualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
+	}
+	getQualifier(attribute) {
+		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
+	}
+	constructEggObject(...args) {
+		return Reflect.construct(this.clazz, args);
+	}
+	getMetaData(metadataKey) {
+		return MetadataUtil.getMetaData(metadataKey, this.clazz);
+	}
+};
+
+//#endregion
+//#region src/impl/EggPrototypeBuilder.ts
+var EggPrototypeBuilder = class EggPrototypeBuilder {
+	clazz;
+	name;
+	initType;
+	accessLevel;
+	filepath;
+	injectType;
+	injectObjects = [];
+	loadUnit;
+	qualifiers = [];
+	properQualifiers = {};
+	className;
+	multiInstanceConstructorIndex;
+	multiInstanceConstructorAttributes;
+	static create(ctx) {
+		const { clazz, loadUnit } = ctx;
+		const filepath = PrototypeUtil.getFilePath(clazz);
+		assert(filepath, "not find filepath");
+		const builder = new EggPrototypeBuilder();
+		builder.clazz = clazz;
+		builder.name = ctx.prototypeInfo.name;
+		builder.className = ctx.prototypeInfo.className;
+		builder.initType = ctx.prototypeInfo.initType;
+		builder.accessLevel = ctx.prototypeInfo.accessLevel;
+		builder.filepath = filepath;
+		builder.injectType = PrototypeUtil.getInjectType(clazz);
+		builder.injectObjects = PrototypeUtil.getInjectObjects(clazz) || [];
+		builder.loadUnit = loadUnit;
+		builder.qualifiers = QualifierUtil.mergeQualifiers(QualifierUtil.getProtoQualifiers(clazz), ctx.prototypeInfo.qualifiers ?? []);
+		builder.properQualifiers = ctx.prototypeInfo.properQualifiers ?? {};
+		builder.multiInstanceConstructorIndex = PrototypeUtil.getMultiInstanceConstructorIndex(clazz);
+		builder.multiInstanceConstructorAttributes = PrototypeUtil.getMultiInstanceConstructorAttributes(clazz);
+		return builder.build();
+	}
+	tryFindDefaultPrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		const multiInstancePropertyQualifiers = this.properQualifiers[injectObject.refName] ?? [];
+		return EggPrototypeFactory.instance.getPrototype(injectObject.objName, this.loadUnit, QualifierUtil.mergeQualifiers(propertyQualifiers, multiInstancePropertyQualifiers));
+	}
+	tryFindContextPrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		const multiInstancePropertyQualifiers = this.properQualifiers[injectObject.refName] ?? [];
+		return EggPrototypeFactory.instance.getPrototype(injectObject.objName, this.loadUnit, QualifierUtil.mergeQualifiers(propertyQualifiers, multiInstancePropertyQualifiers, [{
+			attribute: InitTypeQualifierAttribute,
+			value: ObjectInitType.CONTEXT
+		}]));
+	}
+	tryFindSelfInitTypePrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		const multiInstancePropertyQualifiers = this.properQualifiers[injectObject.refName] ?? [];
+		return EggPrototypeFactory.instance.getPrototype(injectObject.objName, this.loadUnit, QualifierUtil.mergeQualifiers(propertyQualifiers, multiInstancePropertyQualifiers, [{
+			attribute: InitTypeQualifierAttribute,
+			value: this.initType
+		}]));
+	}
+	findInjectObjectPrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		try {
+			return this.tryFindDefaultPrototype(injectObject);
+		} catch (e) {
+			if (!(e instanceof MultiPrototypeFound && !propertyQualifiers.find((t) => t.attribute === InitTypeQualifierAttribute))) throw e;
+		}
+		try {
+			return this.tryFindContextPrototype(injectObject);
+		} catch (e) {
+			if (!(e instanceof EggPrototypeNotFound)) throw e;
+		}
+		return this.tryFindSelfInitTypePrototype(injectObject);
+	}
+	build() {
+		const injectObjectProtos = [];
+		for (const injectObject of this.injectObjects) {
+			const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+			try {
+				const proto = this.findInjectObjectPrototype(injectObject);
+				let injectObjectProto;
+				if (this.injectType === InjectType.PROPERTY) injectObjectProto = {
+					refName: injectObject.refName,
+					objName: injectObject.objName,
+					qualifiers: propertyQualifiers,
+					proto
+				};
+				else injectObjectProto = {
+					refIndex: injectObject.refIndex,
+					refName: injectObject.refName,
+					objName: injectObject.objName,
+					qualifiers: propertyQualifiers,
+					proto
+				};
+				if (injectObject.optional) injectObject.optional = true;
+				injectObjectProtos.push(injectObjectProto);
+			} catch (e) {
+				if (e instanceof EggPrototypeNotFound && injectObject.optional) continue;
+				throw e;
+			}
+		}
+		const id$1 = IdenticalUtil.createProtoId(this.loadUnit.id, this.name);
+		return new EggPrototypeImpl(id$1, this.name, this.clazz, this.filepath, this.initType, this.accessLevel, injectObjectProtos, this.loadUnit.id, this.qualifiers, this.className, this.injectType, this.multiInstanceConstructorIndex, this.multiInstanceConstructorAttributes);
+	}
+};
+EggPrototypeCreatorFactory.registerPrototypeCreator(DEFAULT_PROTO_IMPL_TYPE, EggPrototypeBuilder.create);
+
+//#endregion
+//#region src/impl/LoadUnitMultiInstanceProtoHook.ts
+var LoadUnitMultiInstanceProtoHook = class {
+	static multiInstanceClazzSet = /* @__PURE__ */ new Set();
+	static setAllClassList(clazzList) {
+		for (const clazz of clazzList) if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) this.multiInstanceClazzSet.add(clazz);
+	}
+	static clear() {
+		this.multiInstanceClazzSet.clear();
+	}
+	async preCreate() {}
+};
+
+//#endregion
+//#region src/impl/ModuleLoadUnit.ts
+const debug = debuglog("tegg/core/metadata/impl/ModuleLoadUnit");
+let id = 0;
+var ProtoNode$1 = class {
+	clazz;
+	name;
+	id;
+	qualifiers;
+	initType;
+	PrototypeUtil;
+	constructor(clazz, objName, initType, qualifiers) {
+		this.name = objName;
+		this.id = "" + id++;
+		this.clazz = clazz;
+		this.qualifiers = qualifiers;
+		this.initType = initType;
+	}
+	verifyQualifiers(qualifiers) {
+		for (const qualifier of qualifiers) if (!this.verifyQualifier(qualifier)) return false;
+		return true;
+	}
+	verifyQualifier(qualifier) {
+		return this.qualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
+	}
+	toString() {
+		return `${this.clazz.name}@${this.PrototypeUtil.getFilePath(this.clazz)}`;
+	}
+};
+var ModuleGraph = class {
+	graph;
+	clazzList;
+	unitPath;
+	name;
+	constructor(clazzList, unitPath, name) {
+		this.clazzList = clazzList;
+		this.graph = new Graph();
+		this.unitPath = unitPath;
+		this.name = name;
+		debug("ModuleGraph constructor on moduleName: %o, unitPath: %o, clazzList size: %o", this.name, this.unitPath, this.clazzList.length);
+	}
+	findInjectNode(objName, qualifiers, parentInitTye) {
+		let nodes = Array.from(this.graph.nodes.values()).filter((t) => t.val.name === objName).filter((t) => t.val.verifyQualifiers(qualifiers));
+		if (nodes.length === 0) return;
+		if (nodes.length === 1) return nodes[0];
+		const initTypeQualifier = {
+			attribute: InitTypeQualifierAttribute,
+			value: parentInitTye
+		};
+		nodes = nodes.filter((t) => t.val.verifyQualifiers([initTypeQualifier]));
+		if (nodes.length === 1) return nodes[0];
+		const temp = /* @__PURE__ */ new Map();
+		for (const node of nodes) temp.set(node.val.clazz, node);
+		nodes = Array.from(temp.values());
+		if (nodes.length === 1) return nodes[0];
+		const result = nodes.map((node) => node.val.toString());
+		throw FrameworkErrorFormater.formatError(new MultiPrototypeFound(String(objName), qualifiers, JSON.stringify(result)));
+	}
+	async build() {
+		const protoGraphNodes = [];
+		for (const clazz of this.clazzList) if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) {
+			const properties = await PrototypeUtil.getMultiInstanceProperty(clazz, {
+				unitPath: this.unitPath,
+				moduleName: this.name
+			});
+			if (properties) {
+				const qualifiers = QualifierUtil.getProtoQualifiers(clazz);
+				for (const obj of properties.objects || []) {
+					const instanceQualifiers = [...qualifiers, ...obj.qualifiers];
+					protoGraphNodes.push(new GraphNode(new ProtoNode$1(clazz, obj.name, properties.initType, instanceQualifiers)));
+				}
+			}
+		} else {
+			const qualifiers = QualifierUtil.getProtoQualifiers(clazz);
+			const property = PrototypeUtil.getProperty(clazz);
+			if (property) protoGraphNodes.push(new GraphNode(new ProtoNode$1(clazz, property.name, property.initType, qualifiers)));
+		}
+		for (const node of protoGraphNodes) if (!this.graph.addVertex(node)) throw new Error(`duplicate proto: ${node.val.id}`);
+		for (const node of protoGraphNodes) if (PrototypeUtil.isEggMultiInstancePrototype(node.val.clazz)) {
+			const property = await PrototypeUtil.getMultiInstanceProperty(node.val.clazz, {
+				moduleName: this.name,
+				unitPath: this.unitPath
+			});
+			for (const objectInfo of property?.objects || []) {
+				const injectObjects = PrototypeUtil.getInjectObjects(node.val.clazz);
+				for (const injectObject of injectObjects) {
+					const qualifiers = [...QualifierUtil.getProperQualifiers(node.val.clazz, injectObject.refName), ...objectInfo.properQualifiers?.[injectObject.refName] ?? []];
+					const injectNode = this.findInjectNode(injectObject.objName, qualifiers, node.val.initType);
+					if (injectNode) this.graph.addEdge(node, injectNode);
+				}
+			}
+		} else {
+			const injectObjects = PrototypeUtil.getInjectObjects(node.val.clazz);
+			for (const injectObject of injectObjects) {
+				const qualifiers = QualifierUtil.getProperQualifiers(node.val.clazz, injectObject.refName);
+				const injectNode = this.findInjectNode(injectObject.objName, qualifiers, node.val.initType);
+				if (injectNode) this.graph.addEdge(node, injectNode);
+			}
+		}
+	}
+	sort() {
+		const loopPath = this.graph.loopPath();
+		if (loopPath) throw new Error("proto has recursive deps: " + loopPath);
+		const clazzSet = /* @__PURE__ */ new Set();
+		for (const clazz of this.graph.sort()) clazzSet.add(clazz.val.clazz);
+		this.clazzList = Array.from(clazzSet);
+	}
+};
+var ModuleLoadUnit = class ModuleLoadUnit {
+	protoMap = /* @__PURE__ */ new Map();
+	protos;
+	clazzList;
+	id;
+	name;
+	unitPath;
+	type = EggLoadUnitType.MODULE;
+	get globalGraph() {
+		return GlobalGraph.instance;
+	}
+	constructor(name, unitPath) {
+		this.id = IdenticalUtil.createLoadUnitId(name);
+		this.name = name;
+		this.unitPath = unitPath;
+		debug("ModuleLoadUnit constructor on moduleName: %o, unitPath: %o, id: %o", this.name, this.unitPath, this.id);
+	}
+	doLoadClazz() {
+		const protos = this.globalGraph.moduleProtoDescriptorMap.get(this.name);
+		if (protos) {
+			this.protos = protos.filter((t) => ClassProtoDescriptor.isClassProtoDescriptor(t));
+			this.clazzList = this.protos.map((t) => t.clazz);
+		} else {
+			this.protos = [];
+			this.clazzList = [];
+		}
+		debug("doLoadClazz on moduleName: %o, protos size: %o, clazzList size: %o", this.name, this.protos.length, this.clazzList.length);
+	}
+	loadClazz() {
+		if (!this.clazzList) this.doLoadClazz();
+	}
+	async preLoad() {
+		this.loadClazz();
+		for (const protoClass of this.clazzList) {
+			const fnName = LifecycleUtil.getStaticLifecycleHook("preLoad", protoClass);
+			if (fnName) {
+				const lifecycleHook = Reflect.get(protoClass, fnName);
+				if (typeof lifecycleHook === "function") await lifecycleHook();
+			}
+		}
+	}
+	async init() {
+		this.loadClazz();
+		for (const protoDescriptor of this.protos) {
+			const proto = await EggPrototypeCreatorFactory.createProtoByDescriptor(protoDescriptor, this);
+			EggPrototypeFactory.instance.registerPrototype(proto, this);
+		}
+	}
+	containPrototype(proto) {
+		return !!this.protoMap.get(proto.name)?.find((t) => t === proto);
+	}
+	getEggPrototype(name, qualifiers) {
+		return this.protoMap.get(name)?.filter((proto) => proto.verifyQualifiers(qualifiers)) || [];
+	}
+	registerEggPrototype(proto) {
+		MapUtil.getOrStore(this.protoMap, proto.name, []).push(proto);
+	}
+	deletePrototype(proto) {
+		const protos = this.protoMap.get(proto.name);
+		if (protos) {
+			const index = protos.indexOf(proto);
+			if (index !== -1) protos.splice(index, 1);
+		}
+	}
+	async destroy() {
+		for (const namedProtoMap of this.protoMap.values()) for (const proto of namedProtoMap.slice()) EggPrototypeFactory.instance.deletePrototype(proto, this);
+		this.protoMap.clear();
+	}
+	iterateEggPrototype() {
+		return Array.from(this.protoMap.values()).reduce((p, c) => {
+			p = p.concat(c);
+			return p;
+		}, []).values();
+	}
+	static createModule(ctx) {
+		const pkgPath = path.join(ctx.unitPath, "package.json");
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		assert(pkg.eggModule, `module config not found in package ${pkgPath}`);
+		const { name } = pkg.eggModule;
+		return new ModuleLoadUnit(name, ctx.unitPath);
+	}
+};
+LoadUnitFactory.registerLoadUnitCreator(EggLoadUnitType.MODULE, ModuleLoadUnit.createModule);
+
+//#endregion
 export { AbstractProtoDescriptor, AppGraph, ClassProtoDescriptor, ClassUtil, ClazzMap, EggPrototypeBuilder, EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeImpl, EggPrototypeLifecycleUtil, EggPrototypeNotFound, GlobalGraph, GlobalModuleNode, GlobalModuleNodeBuilder, IncompatibleProtoInject, LoadUnitFactory, LoadUnitLifecycleUtil, LoadUnitMultiInstanceProtoHook, ModuleDependencyMeta, ModuleDescriptorDumper, ModuleGraph, ModuleLoadUnit, ModuleNode, MultiPrototypeFound, ProtoDependencyMeta, ProtoDescriptorHelper, ProtoNode, TeggError };