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

package/dist/index.d.ts

@@ -1,7 +1,120 @@
-import { EggModuleLoader, EggModuleLoaderOptions } from "./EggModuleLoader.js";
-import { ModuleDependency, Runner, RunnerOptions } from "./Runner.js";
-import { main, preLoad } from "./main.js";
-import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
-import { StandaloneContext } from "./StandaloneContext.js";
-import { StandaloneInnerObject } from "./StandaloneInnerObject.js";
+import { EggPrototype, EggPrototypeLifecycleContext, InjectObjectProto, LoadUnit } from "@eggjs/tegg-metadata";
+import { ModuleReference, ReadModuleReferenceOptions } from "@eggjs/tegg-common-util";
+import { AbstractEggContext, EggContext, EggObject, LoadUnitInstance } from "@eggjs/tegg-runtime";
+import { AccessLevel, EggObjectName, EggProtoImplClass, EggPrototypeName, Id, Logger, MetaDataKey, ModuleConfigHolder, ObjectInitTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg";
+
+//#region src/EggModuleLoader.d.ts
+interface EggModuleLoaderOptions {
+  logger: Logger;
+  baseDir: string;
+  dump?: boolean;
+}
+declare class EggModuleLoader {
+  private moduleReferences;
+  private globalGraph;
+  private options;
+  constructor(moduleReferences: readonly ModuleReference[], options: EggModuleLoaderOptions);
+  init(): Promise<void>;
+  private static generateAppGraph;
+  load(): Promise<LoadUnit[]>;
+  static preLoad(moduleReferences: readonly ModuleReference[], options: EggModuleLoaderOptions): Promise<void>;
+}
+//#endregion
+//#region src/StandaloneLoadUnit.d.ts
+interface InnerObject {
+  obj: object;
+  qualifiers?: QualifierInfo[];
+}
+//#endregion
+//#region src/Runner.d.ts
+interface ModuleDependency extends ReadModuleReferenceOptions {
+  baseDir: string;
+}
+interface RunnerOptions {
+  /**
+   * @deprecated
+   * use inner object handlers instead
+   */
+  innerObjects?: Record<string, object>;
+  env?: string;
+  name?: string;
+  innerObjectHandlers?: Record<string, InnerObject[]>;
+  dependencies?: (string | ModuleDependency)[];
+  dump?: boolean;
+}
+declare class Runner {
+  readonly cwd: string;
+  readonly moduleReferences: readonly ModuleReference[];
+  readonly moduleConfigs: Record<string, ModuleConfigHolder>;
+  readonly env?: string;
+  readonly name?: string;
+  readonly options?: RunnerOptions;
+  private loadUnitLoader;
+  private runnerProto;
+  private configSourceEggPrototypeHook;
+  private loadUnitMultiInstanceProtoHook;
+  private dalTableEggPrototypeHook;
+  private dalModuleLoadUnitHook;
+  private transactionPrototypeHook;
+  private crosscutAdviceFactory;
+  private loadUnitAopHook;
+  private eggPrototypeCrossCutHook;
+  private eggObjectAopHook;
+  loadUnits: LoadUnit[];
+  loadUnitInstances: LoadUnitInstance[];
+  innerObjects: Record<string, InnerObject[]>;
+  constructor(cwd: string, options?: RunnerOptions);
+  load(): Promise<LoadUnit[]>;
+  static getModuleReferences(cwd: string, dependencies?: RunnerOptions['dependencies']): readonly ModuleReference[];
+  static preLoad(cwd: string, dependencies?: RunnerOptions['dependencies']): Promise<void>;
+  private initLoaderInstance;
+  init(): Promise<void>;
+  run<T>(aCtx?: EggContext): Promise<T>;
+  destroy(): Promise<void>;
+}
+//#endregion
+//#region src/main.d.ts
+declare function preLoad(cwd: string, dependencies?: RunnerOptions['dependencies']): Promise<void>;
+declare function main<T = void>(cwd: string, options?: RunnerOptions): Promise<T>;
+//#endregion
+//#region src/StandaloneInnerObjectProto.d.ts
+declare class StandaloneInnerObjectProto implements EggPrototype {
+  [key: symbol]: PropertyDescriptor;
+  private readonly clazz;
+  private readonly qualifiers;
+  readonly id: string;
+  readonly name: EggPrototypeName;
+  readonly initType: ObjectInitTypeLike;
+  readonly accessLevel: AccessLevel;
+  readonly injectObjects: InjectObjectProto[];
+  readonly loadUnitId: Id;
+  constructor(id: string, name: EggPrototypeName, clazz: EggProtoImplClass, initType: ObjectInitTypeLike, loadUnitId: Id, qualifiers: QualifierInfo[]);
+  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
+  verifyQualifier(qualifier: QualifierInfo): boolean;
+  constructEggObject(): object;
+  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
+  getQualifier(attribute: string): QualifierValue | undefined;
+  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
+}
+//#endregion
+//#region src/StandaloneContext.d.ts
+declare class StandaloneContext extends AbstractEggContext {
+  id: string;
+  constructor();
+}
+//#endregion
+//#region src/StandaloneInnerObject.d.ts
+declare const OBJ: unique symbol;
+declare class StandaloneInnerObject implements EggObject {
+  readonly isReady: boolean;
+  private [OBJ];
+  readonly proto: StandaloneInnerObjectProto;
+  readonly name: EggObjectName;
+  readonly id: string;
+  constructor(name: EggObjectName, proto: StandaloneInnerObjectProto);
+  get obj(): object;
+  injectProperty(): void;
+  static createObject(name: EggObjectName, proto: EggPrototype): Promise<StandaloneInnerObject>;
+}
+//#endregion
 export { EggModuleLoader, EggModuleLoaderOptions, ModuleDependency, Runner, RunnerOptions, StandaloneContext, StandaloneInnerObject, StandaloneInnerObjectProto, main, preLoad };

package/dist/index.js

@@ -1,8 +1,415 @@
-import { EggModuleLoader } from "./EggModuleLoader.js";
-import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
-import { StandaloneContext } from "./StandaloneContext.js";
-import { Runner } from "./Runner.js";
-import { main, preLoad } from "./main.js";
-import { StandaloneInnerObject } from "./StandaloneInnerObject.js";
+import { EggLoadUnitType, EggPrototypeFactory, EggPrototypeLifecycleUtil, GlobalGraph, LoadUnitFactory, LoadUnitLifecycleUtil, LoadUnitMultiInstanceProtoHook, ModuleDescriptorDumper } from "@eggjs/tegg-metadata";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+import { MapUtil, ModuleConfigUtil } from "@eggjs/tegg-common-util";
+import { AbstractEggContext, ContextHandler, EggContainerFactory, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, ModuleLoadUnitInstance } from "@eggjs/tegg-runtime";
+import { AccessLevel, ConfigSourceQualifier, ConfigSourceQualifierAttribute, IdenticalUtil, MetadataUtil, ModuleConfigs, ObjectInitType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+import { StandaloneUtil } from "@eggjs/tegg/standalone";
+import { CrosscutAdviceFactory } from "@eggjs/tegg/aop";
+import { EggObjectAopHook, EggPrototypeCrossCutHook, LoadUnitAopHook, crossCutGraphHook, pointCutGraphHook } from "@eggjs/tegg-aop-runtime";
+import { DalModuleLoadUnitHook, DalTableEggPrototypeHook, MysqlDataSourceManager, SqlMapManager, TableModelManager, TransactionPrototypeHook } from "@eggjs/tegg-dal-plugin";
+import { IdenticalUtil as IdenticalUtil$1 } from "@eggjs/tegg-lifecycle";
+import { AsyncLocalStorage } from "node:async_hooks";
 
+//#region src/EggModuleLoader.ts
+var EggModuleLoader = class EggModuleLoader {
+	moduleReferences;
+	globalGraph;
+	options;
+	constructor(moduleReferences, options) {
+		this.moduleReferences = moduleReferences;
+		this.options = options;
+	}
+	async init() {
+		GlobalGraph.instance = this.globalGraph = await EggModuleLoader.generateAppGraph(this.moduleReferences, this.options);
+	}
+	static async generateAppGraph(moduleReferences, options) {
+		const moduleDescriptors = await LoaderFactory.loadApp(moduleReferences);
+		if (options.dump !== false) for (const moduleDescriptor of moduleDescriptors) ModuleDescriptorDumper.dump(moduleDescriptor, { dumpDir: options.baseDir }).catch((e) => {
+			e.message = "dump module descriptor failed: " + e.message;
+			options.logger.warn(e);
+		});
+		return await GlobalGraph.create(moduleDescriptors);
+	}
+	async load() {
+		const loadUnits = [];
+		this.globalGraph.build();
+		this.globalGraph.sort();
+		const moduleConfigList = GlobalGraph.instance.moduleConfigList;
+		for (const moduleConfig of moduleConfigList) {
+			const modulePath = moduleConfig.path;
+			const loader = LoaderFactory.createLoader(modulePath, EggLoadUnitType.MODULE);
+			const loadUnit = await LoadUnitFactory.createLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
+			loadUnits.push(loadUnit);
+		}
+		return loadUnits;
+	}
+	static async preLoad(moduleReferences, options) {
+		const loadUnits = [];
+		const loaderCache = /* @__PURE__ */ new Map();
+		const globalGraph = GlobalGraph.instance = await EggModuleLoader.generateAppGraph(moduleReferences, options);
+		globalGraph.sort();
+		const moduleConfigList = globalGraph.moduleConfigList;
+		for (const moduleConfig of moduleConfigList) {
+			const modulePath = moduleConfig.path;
+			const loader = loaderCache.get(modulePath);
+			const loadUnit = await LoadUnitFactory.createPreloadLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
+			loadUnits.push(loadUnit);
+		}
+		for (const load of loadUnits) await load.preLoad?.();
+	}
+};
+
+//#endregion
+//#region src/StandaloneInnerObjectProto.ts
+var StandaloneInnerObjectProto = class StandaloneInnerObjectProto {
+	clazz;
+	qualifiers;
+	id;
+	name;
+	initType;
+	accessLevel;
+	injectObjects;
+	loadUnitId;
+	constructor(id, name, clazz, initType, loadUnitId, qualifiers) {
+		this.id = id;
+		this.clazz = clazz;
+		this.name = name;
+		this.initType = initType;
+		this.accessLevel = AccessLevel.PUBLIC;
+		this.injectObjects = [];
+		this.loadUnitId = loadUnitId;
+		this.qualifiers = qualifiers;
+	}
+	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;
+	}
+	constructEggObject() {
+		return Reflect.apply(this.clazz, null, []);
+	}
+	getMetaData(metadataKey) {
+		return MetadataUtil.getMetaData(metadataKey, this.clazz);
+	}
+	getQualifier(attribute) {
+		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
+	}
+	static create(ctx) {
+		const { clazz, loadUnit } = ctx;
+		const name = ctx.prototypeInfo.name;
+		const id = IdenticalUtil.createProtoId(loadUnit.id, name);
+		return new StandaloneInnerObjectProto(id, name, clazz, ctx.prototypeInfo.initType, loadUnit.id, QualifierUtil.getProtoQualifiers(clazz));
+	}
+};
+
+//#endregion
+//#region src/StandaloneLoadUnit.ts
+const StandaloneLoadUnitType = "StandaloneLoadUnitType";
+var StandaloneLoadUnit = class {
+	id = "StandaloneLoadUnit";
+	name = "StandaloneLoadUnit";
+	unitPath = "MockStandaloneLoadUnitPath";
+	type = StandaloneLoadUnitType;
+	innerObject;
+	protoMap = /* @__PURE__ */ new Map();
+	constructor(innerObject) {
+		this.innerObject = innerObject;
+	}
+	async init() {
+		for (const [name, objs] of Object.entries(this.innerObject)) for (const { obj, qualifiers } of objs) {
+			const proto = new StandaloneInnerObjectProto(IdenticalUtil$1.createProtoId(this.id, name), name, (() => obj), ObjectInitType.SINGLETON, this.id, qualifiers || []);
+			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.values()) 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();
+	}
+};
+
+//#endregion
+//#region src/StandaloneContext.ts
+var StandaloneContext = class extends AbstractEggContext {
+	id;
+	constructor() {
+		super();
+		this.id = IdenticalUtil$1.createContextId();
+	}
+};
+
+//#endregion
+//#region src/StandaloneContextHandler.ts
+var StandaloneContextHandler = class StandaloneContextHandler {
+	static storage = new AsyncLocalStorage();
+	static register() {
+		ContextHandler.getContextCallback = () => {
+			return StandaloneContextHandler.storage.getStore();
+		};
+		ContextHandler.runInContextCallback = (context, fn) => {
+			return StandaloneContextHandler.storage.run(context, fn);
+		};
+	}
+};
+
+//#endregion
+//#region src/ConfigSourceLoadUnitHook.ts
+/**
+* Hook for inject moduleConfig.
+* Add default qualifier value is current module name.
+*/
+var ConfigSourceLoadUnitHook = class {
+	async preCreate(ctx, loadUnit) {
+		const classList = await ctx.loader.load();
+		for (const clazz of classList) {
+			const moduleConfigObject = PrototypeUtil.getInjectObjects(clazz).find((t) => t.objName === "moduleConfig");
+			const configSourceQualifier = QualifierUtil.getProperQualifier(clazz, "moduleConfig", ConfigSourceQualifierAttribute);
+			if (moduleConfigObject && !configSourceQualifier) ConfigSourceQualifier(loadUnit.name)(clazz.prototype, moduleConfigObject.refName);
+		}
+	}
+};
+
+//#endregion
+//#region src/Runner.ts
+var Runner = class Runner {
+	cwd;
+	moduleReferences;
+	moduleConfigs;
+	env;
+	name;
+	options;
+	loadUnitLoader;
+	runnerProto;
+	configSourceEggPrototypeHook;
+	loadUnitMultiInstanceProtoHook;
+	dalTableEggPrototypeHook;
+	dalModuleLoadUnitHook;
+	transactionPrototypeHook;
+	crosscutAdviceFactory;
+	loadUnitAopHook;
+	eggPrototypeCrossCutHook;
+	eggObjectAopHook;
+	loadUnits = [];
+	loadUnitInstances = [];
+	innerObjects;
+	constructor(cwd, options) {
+		this.cwd = cwd;
+		this.env = options?.env;
+		this.name = options?.name;
+		this.options = options;
+		this.moduleReferences = Runner.getModuleReferences(this.cwd, options?.dependencies);
+		this.moduleConfigs = {};
+		this.innerObjects = {
+			moduleConfigs: [{ obj: new ModuleConfigs(this.moduleConfigs) }],
+			moduleConfig: []
+		};
+		const runtimeConfig = {
+			baseDir: this.cwd,
+			name: this.name,
+			env: this.env
+		};
+		this.innerObjects.runtimeConfig = [{ obj: runtimeConfig }];
+		if (!ModuleConfigUtil.configNames) ModuleConfigUtil.configNames = ["module.default", `module.${this.env}`];
+		for (const reference of this.moduleReferences) {
+			const absoluteRef = {
+				path: ModuleConfigUtil.resolveModuleDir(reference.path, this.cwd),
+				name: reference.name
+			};
+			const moduleName = ModuleConfigUtil.readModuleNameSync(absoluteRef.path);
+			this.moduleConfigs[moduleName] = {
+				name: moduleName,
+				reference: absoluteRef,
+				config: ModuleConfigUtil.loadModuleConfigSync(absoluteRef.path)
+			};
+		}
+		for (const moduleConfig of Object.values(this.moduleConfigs)) this.innerObjects.moduleConfig.push({
+			obj: moduleConfig.config,
+			qualifiers: [{
+				attribute: ConfigSourceQualifierAttribute,
+				value: moduleConfig.name
+			}]
+		});
+		if (options?.innerObjects) for (const [name, obj] of Object.entries(options.innerObjects)) this.innerObjects[name] = [{ obj }];
+		else if (options?.innerObjectHandlers) Object.assign(this.innerObjects, options.innerObjectHandlers);
+	}
+	async load() {
+		StandaloneContextHandler.register();
+		LoadUnitFactory.registerLoadUnitCreator(StandaloneLoadUnitType, () => {
+			return new StandaloneLoadUnit(this.innerObjects);
+		});
+		LoadUnitInstanceFactory.registerLoadUnitInstanceClass(StandaloneLoadUnitType, ModuleLoadUnitInstance.createModuleLoadUnitInstance);
+		const standaloneLoadUnit = await LoadUnitFactory.createLoadUnit("MockStandaloneLoadUnitPath", StandaloneLoadUnitType, { async load() {
+			return [];
+		} });
+		const loadUnits = await this.loadUnitLoader.load();
+		return [standaloneLoadUnit, ...loadUnits];
+	}
+	static getModuleReferences(cwd, dependencies) {
+		return (dependencies || []).concat(cwd).reduce((list, baseDir) => {
+			const module = typeof baseDir === "string" ? { baseDir } : baseDir;
+			return list.concat(...ModuleConfigUtil.readModuleReference(module.baseDir, module));
+		}, []);
+	}
+	static async preLoad(cwd, dependencies) {
+		const moduleReferences = Runner.getModuleReferences(cwd, dependencies);
+		await EggModuleLoader.preLoad(moduleReferences, {
+			baseDir: cwd,
+			logger: console,
+			dump: false
+		});
+	}
+	async initLoaderInstance() {
+		this.loadUnitLoader = new EggModuleLoader(this.moduleReferences, {
+			logger: (this.innerObjects.logger && this.innerObjects.logger[0])?.obj || console,
+			baseDir: this.cwd,
+			dump: this.options?.dump
+		});
+		await this.loadUnitLoader.init();
+		GlobalGraph.instance.registerBuildHook(crossCutGraphHook);
+		GlobalGraph.instance.registerBuildHook(pointCutGraphHook);
+		const configSourceEggPrototypeHook = new ConfigSourceLoadUnitHook();
+		LoadUnitLifecycleUtil.registerLifecycle(configSourceEggPrototypeHook);
+		this.crosscutAdviceFactory = new CrosscutAdviceFactory();
+		this.loadUnitAopHook = new LoadUnitAopHook(this.crosscutAdviceFactory);
+		this.eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook(this.crosscutAdviceFactory);
+		this.eggObjectAopHook = new EggObjectAopHook();
+		EggPrototypeLifecycleUtil.registerLifecycle(this.eggPrototypeCrossCutHook);
+		LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitAopHook);
+		EggObjectLifecycleUtil.registerLifecycle(this.eggObjectAopHook);
+		this.loadUnitMultiInstanceProtoHook = new LoadUnitMultiInstanceProtoHook();
+		LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitMultiInstanceProtoHook);
+		const logger = (this.innerObjects.logger && this.innerObjects.logger[0])?.obj || console;
+		this.dalModuleLoadUnitHook = new DalModuleLoadUnitHook(this.env ?? "", this.moduleConfigs, logger);
+		this.dalTableEggPrototypeHook = new DalTableEggPrototypeHook(logger);
+		this.transactionPrototypeHook = new TransactionPrototypeHook(this.moduleConfigs, logger);
+		EggPrototypeLifecycleUtil.registerLifecycle(this.dalTableEggPrototypeHook);
+		EggPrototypeLifecycleUtil.registerLifecycle(this.transactionPrototypeHook);
+		LoadUnitLifecycleUtil.registerLifecycle(this.dalModuleLoadUnitHook);
+	}
+	async init() {
+		await this.initLoaderInstance();
+		this.loadUnits = await this.load();
+		const instances = [];
+		for (const loadUnit of this.loadUnits) {
+			const instance = await LoadUnitInstanceFactory.createLoadUnitInstance(loadUnit);
+			instances.push(instance);
+		}
+		this.loadUnitInstances = instances;
+		const runnerClass = StandaloneUtil.getMainRunner();
+		if (!runnerClass) throw new Error("not found runner class. Do you add @Runner decorator?");
+		const proto = PrototypeUtil.getClazzProto(runnerClass);
+		if (!proto) throw new Error(`can not get proto for clazz ${runnerClass.name}`);
+		this.runnerProto = proto;
+	}
+	async run(aCtx) {
+		const lifecycle = {};
+		const ctx = aCtx || new StandaloneContext();
+		return await ContextHandler.run(ctx, async () => {
+			if (ctx.init) await ctx.init(lifecycle);
+			const runner = (await EggContainerFactory.getOrCreateEggObject(this.runnerProto)).obj;
+			try {
+				return await runner.main();
+			} finally {
+				if (ctx.destroy) ctx.destroy(lifecycle).catch((e) => {
+					e.message = `[tegg/standalone] destroy tegg context failed: ${e.message}`;
+					console.warn(e);
+				});
+			}
+		});
+	}
+	async destroy() {
+		if (this.loadUnitInstances) for (const instance of this.loadUnitInstances) await LoadUnitInstanceFactory.destroyLoadUnitInstance(instance);
+		if (this.loadUnits) for (const loadUnit of this.loadUnits) await LoadUnitFactory.destroyLoadUnit(loadUnit);
+		if (this.configSourceEggPrototypeHook) LoadUnitLifecycleUtil.deleteLifecycle(this.configSourceEggPrototypeHook);
+		if (this.eggPrototypeCrossCutHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.eggPrototypeCrossCutHook);
+		if (this.loadUnitAopHook) LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitAopHook);
+		if (this.eggObjectAopHook) EggObjectLifecycleUtil.deleteLifecycle(this.eggObjectAopHook);
+		if (this.loadUnitMultiInstanceProtoHook) LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitMultiInstanceProtoHook);
+		if (this.dalTableEggPrototypeHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.dalTableEggPrototypeHook);
+		if (this.dalModuleLoadUnitHook) LoadUnitLifecycleUtil.deleteLifecycle(this.dalModuleLoadUnitHook);
+		if (this.transactionPrototypeHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.transactionPrototypeHook);
+		MysqlDataSourceManager.instance.clear();
+		SqlMapManager.instance.clear();
+		TableModelManager.instance.clear();
+		ModuleConfigUtil.setConfigNames(void 0);
+	}
+};
+
+//#endregion
+//#region src/main.ts
+async function preLoad(cwd, dependencies) {
+	try {
+		await Runner.preLoad(cwd, dependencies);
+	} catch (e) {
+		if (e instanceof Error) e.message = `[tegg/standalone] bootstrap standalone preLoad failed: ${e.message}`;
+		throw e;
+	}
+}
+async function main(cwd, options) {
+	const runner = new Runner(cwd, options);
+	try {
+		await runner.init();
+	} catch (e) {
+		if (e instanceof Error) e.message = `[tegg/standalone] bootstrap tegg failed: ${e.message}`;
+		throw e;
+	}
+	try {
+		return await runner.run();
+	} finally {
+		runner.destroy().catch((e) => {
+			e.message = `[tegg/standalone] destroy tegg failed: ${e.message}`;
+			console.warn(e);
+		});
+	}
+}
+
+//#endregion
+//#region src/StandaloneInnerObject.ts
+const OBJ = Symbol("EggCompatibleObject#obj");
+var StandaloneInnerObject = class StandaloneInnerObject {
+	isReady = true;
+	[OBJ];
+	proto;
+	name;
+	id;
+	constructor(name, proto) {
+		this.proto = proto;
+		this.name = name;
+		this.id = IdenticalUtil.createObjectId(this.proto.id);
+	}
+	get obj() {
+		if (!this[OBJ]) this[OBJ] = this.proto.constructEggObject();
+		return this[OBJ];
+	}
+	injectProperty() {}
+	static async createObject(name, proto) {
+		return new StandaloneInnerObject(name, proto);
+	}
+};
+EggObjectFactory.registerEggObjectCreateMethod(StandaloneInnerObjectProto, StandaloneInnerObject.createObject);
+
+//#endregion
 export { EggModuleLoader, Runner, StandaloneContext, StandaloneInnerObject, StandaloneInnerObjectProto, main, preLoad };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eggjs/tegg-standalone",
   "description": "tegg standalone",
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0-beta.8",
   "keywords": [
     "egg",
     "typescript",
@@ -33,14 +33,14 @@
   "author": "killagu <killa123@126.com>",
   "license": "MIT",
   "dependencies": {
-    "@eggjs/tegg": "4.0.0-beta.6",
-    "@eggjs/tegg-common-util": "4.0.0-beta.6",
-    "@eggjs/tegg-dal-plugin": "4.0.0-beta.6",
-    "@eggjs/tegg-aop-runtime": "4.0.0-beta.6",
-    "@eggjs/tegg-lifecycle": "4.0.0-beta.6",
-    "@eggjs/tegg-loader": "4.0.0-beta.6",
-    "@eggjs/tegg-runtime": "4.0.0-beta.6",
-    "@eggjs/tegg-metadata": "4.0.0-beta.6"
+    "@eggjs/tegg": "4.0.0-beta.8",
+    "@eggjs/tegg-aop-runtime": "4.0.0-beta.8",
+    "@eggjs/tegg-common-util": "4.0.0-beta.8",
+    "@eggjs/tegg-dal-plugin": "4.0.0-beta.8",
+    "@eggjs/tegg-loader": "4.0.0-beta.8",
+    "@eggjs/tegg-metadata": "4.0.0-beta.8",
+    "@eggjs/tegg-lifecycle": "4.0.0-beta.8",
+    "@eggjs/tegg-runtime": "4.0.0-beta.8"
   },
   "publishConfig": {
     "access": "public"
@@ -54,9 +54,9 @@
     "typescript": "^5.9.3",
     "tsdown": "^0.15.6",
     "unplugin-unused": "^0.5.3",
-    "@eggjs/core-decorator": "4.0.0-beta.6",
-    "@eggjs/dal-decorator": "4.0.0-beta.6",
-    "@eggjs/tegg-ajv-plugin": "4.0.0-beta.6"
+    "@eggjs/tegg-ajv-plugin": "4.0.0-beta.8",
+    "@eggjs/core-decorator": "4.0.0-beta.8",
+    "@eggjs/dal-decorator": "4.0.0-beta.8"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/ConfigSourceLoadUnitHook.js

@@ -1,21 +0,0 @@
-import "@eggjs/tegg-metadata";
-import { ConfigSourceQualifier, ConfigSourceQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
-
-//#region src/ConfigSourceLoadUnitHook.ts
-/**
-* Hook for inject moduleConfig.
-* Add default qualifier value is current module name.
-*/
-var ConfigSourceLoadUnitHook = class {
-	async preCreate(ctx, loadUnit) {
-		const classList = await ctx.loader.load();
-		for (const clazz of classList) {
-			const moduleConfigObject = PrototypeUtil.getInjectObjects(clazz).find((t) => t.objName === "moduleConfig");
-			const configSourceQualifier = QualifierUtil.getProperQualifier(clazz, "moduleConfig", ConfigSourceQualifierAttribute);
-			if (moduleConfigObject && !configSourceQualifier) ConfigSourceQualifier(loadUnit.name)(clazz.prototype, moduleConfigObject.refName);
-		}
-	}
-};
-
-//#endregion
-export { ConfigSourceLoadUnitHook };

package/dist/EggModuleLoader.d.ts

@@ -1,22 +0,0 @@
-import { LoadUnit } from "@eggjs/tegg-metadata";
-import { ModuleReference } from "@eggjs/tegg-common-util";
-import { Logger } from "@eggjs/tegg";
-
-//#region src/EggModuleLoader.d.ts
-interface EggModuleLoaderOptions {
-  logger: Logger;
-  baseDir: string;
-  dump?: boolean;
-}
-declare class EggModuleLoader {
-  private moduleReferences;
-  private globalGraph;
-  private options;
-  constructor(moduleReferences: readonly ModuleReference[], options: EggModuleLoaderOptions);
-  init(): Promise<void>;
-  private static generateAppGraph;
-  load(): Promise<LoadUnit[]>;
-  static preLoad(moduleReferences: readonly ModuleReference[], options: EggModuleLoaderOptions): Promise<void>;
-}
-//#endregion
-export { EggModuleLoader, EggModuleLoaderOptions };

package/dist/EggModuleLoader.js

@@ -1,54 +0,0 @@
-import { EggLoadUnitType, GlobalGraph, LoadUnitFactory, ModuleDescriptorDumper } from "@eggjs/tegg-metadata";
-import { LoaderFactory } from "@eggjs/tegg-loader";
-
-//#region src/EggModuleLoader.ts
-var EggModuleLoader = class EggModuleLoader {
-	moduleReferences;
-	globalGraph;
-	options;
-	constructor(moduleReferences, options) {
-		this.moduleReferences = moduleReferences;
-		this.options = options;
-	}
-	async init() {
-		GlobalGraph.instance = this.globalGraph = await EggModuleLoader.generateAppGraph(this.moduleReferences, this.options);
-	}
-	static async generateAppGraph(moduleReferences, options) {
-		const moduleDescriptors = await LoaderFactory.loadApp(moduleReferences);
-		if (options.dump !== false) for (const moduleDescriptor of moduleDescriptors) ModuleDescriptorDumper.dump(moduleDescriptor, { dumpDir: options.baseDir }).catch((e) => {
-			e.message = "dump module descriptor failed: " + e.message;
-			options.logger.warn(e);
-		});
-		return await GlobalGraph.create(moduleDescriptors);
-	}
-	async load() {
-		const loadUnits = [];
-		this.globalGraph.build();
-		this.globalGraph.sort();
-		const moduleConfigList = GlobalGraph.instance.moduleConfigList;
-		for (const moduleConfig of moduleConfigList) {
-			const modulePath = moduleConfig.path;
-			const loader = LoaderFactory.createLoader(modulePath, EggLoadUnitType.MODULE);
-			const loadUnit = await LoadUnitFactory.createLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
-			loadUnits.push(loadUnit);
-		}
-		return loadUnits;
-	}
-	static async preLoad(moduleReferences, options) {
-		const loadUnits = [];
-		const loaderCache = /* @__PURE__ */ new Map();
-		const globalGraph = GlobalGraph.instance = await EggModuleLoader.generateAppGraph(moduleReferences, options);
-		globalGraph.sort();
-		const moduleConfigList = globalGraph.moduleConfigList;
-		for (const moduleConfig of moduleConfigList) {
-			const modulePath = moduleConfig.path;
-			const loader = loaderCache.get(modulePath);
-			const loadUnit = await LoadUnitFactory.createPreloadLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
-			loadUnits.push(loadUnit);
-		}
-		for (const load of loadUnits) await load.preLoad?.();
-	}
-};
-
-//#endregion
-export { EggModuleLoader };

package/dist/Runner.d.ts

@@ -1,54 +0,0 @@
-import { InnerObject } from "./StandaloneLoadUnit.js";
-import { LoadUnit } from "@eggjs/tegg-metadata";
-import { ModuleReference, ReadModuleReferenceOptions } from "@eggjs/tegg-common-util";
-import { EggContext, LoadUnitInstance } from "@eggjs/tegg-runtime";
-import { ModuleConfigHolder } from "@eggjs/tegg";
-
-//#region src/Runner.d.ts
-interface ModuleDependency extends ReadModuleReferenceOptions {
-  baseDir: string;
-}
-interface RunnerOptions {
-  /**
-   * @deprecated
-   * use inner object handlers instead
-   */
-  innerObjects?: Record<string, object>;
-  env?: string;
-  name?: string;
-  innerObjectHandlers?: Record<string, InnerObject[]>;
-  dependencies?: (string | ModuleDependency)[];
-  dump?: boolean;
-}
-declare class Runner {
-  readonly cwd: string;
-  readonly moduleReferences: readonly ModuleReference[];
-  readonly moduleConfigs: Record<string, ModuleConfigHolder>;
-  readonly env?: string;
-  readonly name?: string;
-  readonly options?: RunnerOptions;
-  private loadUnitLoader;
-  private runnerProto;
-  private configSourceEggPrototypeHook;
-  private loadUnitMultiInstanceProtoHook;
-  private dalTableEggPrototypeHook;
-  private dalModuleLoadUnitHook;
-  private transactionPrototypeHook;
-  private crosscutAdviceFactory;
-  private loadUnitAopHook;
-  private eggPrototypeCrossCutHook;
-  private eggObjectAopHook;
-  loadUnits: LoadUnit[];
-  loadUnitInstances: LoadUnitInstance[];
-  innerObjects: Record<string, InnerObject[]>;
-  constructor(cwd: string, options?: RunnerOptions);
-  load(): Promise<LoadUnit[]>;
-  static getModuleReferences(cwd: string, dependencies?: RunnerOptions['dependencies']): readonly ModuleReference[];
-  static preLoad(cwd: string, dependencies?: RunnerOptions['dependencies']): Promise<void>;
-  private initLoaderInstance;
-  init(): Promise<void>;
-  run<T>(aCtx?: EggContext): Promise<T>;
-  destroy(): Promise<void>;
-}
-//#endregion
-export { ModuleDependency, Runner, RunnerOptions };

package/dist/Runner.js

@@ -1,181 +0,0 @@
-import { EggModuleLoader } from "./EggModuleLoader.js";
-import { StandaloneLoadUnit, StandaloneLoadUnitType } from "./StandaloneLoadUnit.js";
-import { StandaloneContext } from "./StandaloneContext.js";
-import { StandaloneContextHandler } from "./StandaloneContextHandler.js";
-import { ConfigSourceLoadUnitHook } from "./ConfigSourceLoadUnitHook.js";
-import { EggPrototypeLifecycleUtil, GlobalGraph, LoadUnitFactory, LoadUnitLifecycleUtil, LoadUnitMultiInstanceProtoHook } from "@eggjs/tegg-metadata";
-import { ModuleConfigUtil } from "@eggjs/tegg-common-util";
-import { ContextHandler, EggContainerFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, ModuleLoadUnitInstance } from "@eggjs/tegg-runtime";
-import { ConfigSourceQualifierAttribute, ModuleConfigs, PrototypeUtil } from "@eggjs/tegg";
-import { StandaloneUtil } from "@eggjs/tegg/standalone";
-import { CrosscutAdviceFactory } from "@eggjs/tegg/aop";
-import { EggObjectAopHook, EggPrototypeCrossCutHook, LoadUnitAopHook, crossCutGraphHook, pointCutGraphHook } from "@eggjs/tegg-aop-runtime";
-import { DalModuleLoadUnitHook, DalTableEggPrototypeHook, MysqlDataSourceManager, SqlMapManager, TableModelManager, TransactionPrototypeHook } from "@eggjs/tegg-dal-plugin";
-
-//#region src/Runner.ts
-var Runner = class Runner {
-	cwd;
-	moduleReferences;
-	moduleConfigs;
-	env;
-	name;
-	options;
-	loadUnitLoader;
-	runnerProto;
-	configSourceEggPrototypeHook;
-	loadUnitMultiInstanceProtoHook;
-	dalTableEggPrototypeHook;
-	dalModuleLoadUnitHook;
-	transactionPrototypeHook;
-	crosscutAdviceFactory;
-	loadUnitAopHook;
-	eggPrototypeCrossCutHook;
-	eggObjectAopHook;
-	loadUnits = [];
-	loadUnitInstances = [];
-	innerObjects;
-	constructor(cwd, options) {
-		this.cwd = cwd;
-		this.env = options?.env;
-		this.name = options?.name;
-		this.options = options;
-		this.moduleReferences = Runner.getModuleReferences(this.cwd, options?.dependencies);
-		this.moduleConfigs = {};
-		this.innerObjects = {
-			moduleConfigs: [{ obj: new ModuleConfigs(this.moduleConfigs) }],
-			moduleConfig: []
-		};
-		const runtimeConfig = {
-			baseDir: this.cwd,
-			name: this.name,
-			env: this.env
-		};
-		this.innerObjects.runtimeConfig = [{ obj: runtimeConfig }];
-		if (!ModuleConfigUtil.configNames) ModuleConfigUtil.configNames = ["module.default", `module.${this.env}`];
-		for (const reference of this.moduleReferences) {
-			const absoluteRef = {
-				path: ModuleConfigUtil.resolveModuleDir(reference.path, this.cwd),
-				name: reference.name
-			};
-			const moduleName = ModuleConfigUtil.readModuleNameSync(absoluteRef.path);
-			this.moduleConfigs[moduleName] = {
-				name: moduleName,
-				reference: absoluteRef,
-				config: ModuleConfigUtil.loadModuleConfigSync(absoluteRef.path)
-			};
-		}
-		for (const moduleConfig of Object.values(this.moduleConfigs)) this.innerObjects.moduleConfig.push({
-			obj: moduleConfig.config,
-			qualifiers: [{
-				attribute: ConfigSourceQualifierAttribute,
-				value: moduleConfig.name
-			}]
-		});
-		if (options?.innerObjects) for (const [name, obj] of Object.entries(options.innerObjects)) this.innerObjects[name] = [{ obj }];
-		else if (options?.innerObjectHandlers) Object.assign(this.innerObjects, options.innerObjectHandlers);
-	}
-	async load() {
-		StandaloneContextHandler.register();
-		LoadUnitFactory.registerLoadUnitCreator(StandaloneLoadUnitType, () => {
-			return new StandaloneLoadUnit(this.innerObjects);
-		});
-		LoadUnitInstanceFactory.registerLoadUnitInstanceClass(StandaloneLoadUnitType, ModuleLoadUnitInstance.createModuleLoadUnitInstance);
-		const standaloneLoadUnit = await LoadUnitFactory.createLoadUnit("MockStandaloneLoadUnitPath", StandaloneLoadUnitType, { async load() {
-			return [];
-		} });
-		const loadUnits = await this.loadUnitLoader.load();
-		return [standaloneLoadUnit, ...loadUnits];
-	}
-	static getModuleReferences(cwd, dependencies) {
-		return (dependencies || []).concat(cwd).reduce((list, baseDir) => {
-			const module = typeof baseDir === "string" ? { baseDir } : baseDir;
-			return list.concat(...ModuleConfigUtil.readModuleReference(module.baseDir, module));
-		}, []);
-	}
-	static async preLoad(cwd, dependencies) {
-		const moduleReferences = Runner.getModuleReferences(cwd, dependencies);
-		await EggModuleLoader.preLoad(moduleReferences, {
-			baseDir: cwd,
-			logger: console,
-			dump: false
-		});
-	}
-	async initLoaderInstance() {
-		this.loadUnitLoader = new EggModuleLoader(this.moduleReferences, {
-			logger: (this.innerObjects.logger && this.innerObjects.logger[0])?.obj || console,
-			baseDir: this.cwd,
-			dump: this.options?.dump
-		});
-		await this.loadUnitLoader.init();
-		GlobalGraph.instance.registerBuildHook(crossCutGraphHook);
-		GlobalGraph.instance.registerBuildHook(pointCutGraphHook);
-		const configSourceEggPrototypeHook = new ConfigSourceLoadUnitHook();
-		LoadUnitLifecycleUtil.registerLifecycle(configSourceEggPrototypeHook);
-		this.crosscutAdviceFactory = new CrosscutAdviceFactory();
-		this.loadUnitAopHook = new LoadUnitAopHook(this.crosscutAdviceFactory);
-		this.eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook(this.crosscutAdviceFactory);
-		this.eggObjectAopHook = new EggObjectAopHook();
-		EggPrototypeLifecycleUtil.registerLifecycle(this.eggPrototypeCrossCutHook);
-		LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitAopHook);
-		EggObjectLifecycleUtil.registerLifecycle(this.eggObjectAopHook);
-		this.loadUnitMultiInstanceProtoHook = new LoadUnitMultiInstanceProtoHook();
-		LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitMultiInstanceProtoHook);
-		const logger = (this.innerObjects.logger && this.innerObjects.logger[0])?.obj || console;
-		this.dalModuleLoadUnitHook = new DalModuleLoadUnitHook(this.env ?? "", this.moduleConfigs, logger);
-		this.dalTableEggPrototypeHook = new DalTableEggPrototypeHook(logger);
-		this.transactionPrototypeHook = new TransactionPrototypeHook(this.moduleConfigs, logger);
-		EggPrototypeLifecycleUtil.registerLifecycle(this.dalTableEggPrototypeHook);
-		EggPrototypeLifecycleUtil.registerLifecycle(this.transactionPrototypeHook);
-		LoadUnitLifecycleUtil.registerLifecycle(this.dalModuleLoadUnitHook);
-	}
-	async init() {
-		await this.initLoaderInstance();
-		this.loadUnits = await this.load();
-		const instances = [];
-		for (const loadUnit of this.loadUnits) {
-			const instance = await LoadUnitInstanceFactory.createLoadUnitInstance(loadUnit);
-			instances.push(instance);
-		}
-		this.loadUnitInstances = instances;
-		const runnerClass = StandaloneUtil.getMainRunner();
-		if (!runnerClass) throw new Error("not found runner class. Do you add @Runner decorator?");
-		const proto = PrototypeUtil.getClazzProto(runnerClass);
-		if (!proto) throw new Error(`can not get proto for clazz ${runnerClass.name}`);
-		this.runnerProto = proto;
-	}
-	async run(aCtx) {
-		const lifecycle = {};
-		const ctx = aCtx || new StandaloneContext();
-		return await ContextHandler.run(ctx, async () => {
-			if (ctx.init) await ctx.init(lifecycle);
-			const runner = (await EggContainerFactory.getOrCreateEggObject(this.runnerProto)).obj;
-			try {
-				return await runner.main();
-			} finally {
-				if (ctx.destroy) ctx.destroy(lifecycle).catch((e) => {
-					e.message = `[tegg/standalone] destroy tegg context failed: ${e.message}`;
-					console.warn(e);
-				});
-			}
-		});
-	}
-	async destroy() {
-		if (this.loadUnitInstances) for (const instance of this.loadUnitInstances) await LoadUnitInstanceFactory.destroyLoadUnitInstance(instance);
-		if (this.loadUnits) for (const loadUnit of this.loadUnits) await LoadUnitFactory.destroyLoadUnit(loadUnit);
-		if (this.configSourceEggPrototypeHook) LoadUnitLifecycleUtil.deleteLifecycle(this.configSourceEggPrototypeHook);
-		if (this.eggPrototypeCrossCutHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.eggPrototypeCrossCutHook);
-		if (this.loadUnitAopHook) LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitAopHook);
-		if (this.eggObjectAopHook) EggObjectLifecycleUtil.deleteLifecycle(this.eggObjectAopHook);
-		if (this.loadUnitMultiInstanceProtoHook) LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitMultiInstanceProtoHook);
-		if (this.dalTableEggPrototypeHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.dalTableEggPrototypeHook);
-		if (this.dalModuleLoadUnitHook) LoadUnitLifecycleUtil.deleteLifecycle(this.dalModuleLoadUnitHook);
-		if (this.transactionPrototypeHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.transactionPrototypeHook);
-		MysqlDataSourceManager.instance.clear();
-		SqlMapManager.instance.clear();
-		TableModelManager.instance.clear();
-		ModuleConfigUtil.setConfigNames(void 0);
-	}
-};
-
-//#endregion
-export { Runner };

package/dist/StandaloneContext.d.ts

@@ -1,9 +0,0 @@
-import { AbstractEggContext } from "@eggjs/tegg-runtime";
-
-//#region src/StandaloneContext.d.ts
-declare class StandaloneContext extends AbstractEggContext {
-  id: string;
-  constructor();
-}
-//#endregion
-export { StandaloneContext };

package/dist/StandaloneContext.js

@@ -1,14 +0,0 @@
-import { AbstractEggContext } from "@eggjs/tegg-runtime";
-import { IdenticalUtil } from "@eggjs/tegg-lifecycle";
-
-//#region src/StandaloneContext.ts
-var StandaloneContext = class extends AbstractEggContext {
-	id;
-	constructor() {
-		super();
-		this.id = IdenticalUtil.createContextId();
-	}
-};
-
-//#endregion
-export { StandaloneContext };

package/dist/StandaloneContextHandler.js

@@ -1,18 +0,0 @@
-import { ContextHandler } from "@eggjs/tegg-runtime";
-import { AsyncLocalStorage } from "node:async_hooks";
-
-//#region src/StandaloneContextHandler.ts
-var StandaloneContextHandler = class StandaloneContextHandler {
-	static storage = new AsyncLocalStorage();
-	static register() {
-		ContextHandler.getContextCallback = () => {
-			return StandaloneContextHandler.storage.getStore();
-		};
-		ContextHandler.runInContextCallback = (context, fn) => {
-			return StandaloneContextHandler.storage.run(context, fn);
-		};
-	}
-};
-
-//#endregion
-export { StandaloneContextHandler };

package/dist/StandaloneInnerObject.d.ts

@@ -1,20 +0,0 @@
-import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
-import { EggPrototype } from "@eggjs/tegg-metadata";
-import { EggObject } from "@eggjs/tegg-runtime";
-import { EggObjectName } from "@eggjs/tegg";
-
-//#region src/StandaloneInnerObject.d.ts
-declare const OBJ: unique symbol;
-declare class StandaloneInnerObject implements EggObject {
-  readonly isReady: boolean;
-  private [OBJ];
-  readonly proto: StandaloneInnerObjectProto;
-  readonly name: EggObjectName;
-  readonly id: string;
-  constructor(name: EggObjectName, proto: StandaloneInnerObjectProto);
-  get obj(): object;
-  injectProperty(): void;
-  static createObject(name: EggObjectName, proto: EggPrototype): Promise<StandaloneInnerObject>;
-}
-//#endregion
-export { StandaloneInnerObject };

package/dist/StandaloneInnerObject.js

@@ -1,31 +0,0 @@
-import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
-import "@eggjs/tegg-metadata";
-import { EggObjectFactory } from "@eggjs/tegg-runtime";
-import { IdenticalUtil } from "@eggjs/tegg";
-
-//#region src/StandaloneInnerObject.ts
-const OBJ = Symbol("EggCompatibleObject#obj");
-var StandaloneInnerObject = class StandaloneInnerObject {
-	isReady = true;
-	[OBJ];
-	proto;
-	name;
-	id;
-	constructor(name, proto) {
-		this.proto = proto;
-		this.name = name;
-		this.id = IdenticalUtil.createObjectId(this.proto.id);
-	}
-	get obj() {
-		if (!this[OBJ]) this[OBJ] = this.proto.constructEggObject();
-		return this[OBJ];
-	}
-	injectProperty() {}
-	static async createObject(name, proto) {
-		return new StandaloneInnerObject(name, proto);
-	}
-};
-EggObjectFactory.registerEggObjectCreateMethod(StandaloneInnerObjectProto, StandaloneInnerObject.createObject);
-
-//#endregion
-export { StandaloneInnerObject };

package/dist/StandaloneInnerObjectProto.d.ts

@@ -1,24 +0,0 @@
-import { EggPrototype, EggPrototypeLifecycleContext, InjectObjectProto } from "@eggjs/tegg-metadata";
-import { AccessLevel, EggProtoImplClass, EggPrototypeName, Id, MetaDataKey, ObjectInitTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg";
-
-//#region src/StandaloneInnerObjectProto.d.ts
-declare class StandaloneInnerObjectProto implements EggPrototype {
-  [key: symbol]: PropertyDescriptor;
-  private readonly clazz;
-  private readonly qualifiers;
-  readonly id: string;
-  readonly name: EggPrototypeName;
-  readonly initType: ObjectInitTypeLike;
-  readonly accessLevel: AccessLevel;
-  readonly injectObjects: InjectObjectProto[];
-  readonly loadUnitId: Id;
-  constructor(id: string, name: EggPrototypeName, clazz: EggProtoImplClass, initType: ObjectInitTypeLike, loadUnitId: Id, qualifiers: QualifierInfo[]);
-  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
-  verifyQualifier(qualifier: QualifierInfo): boolean;
-  constructEggObject(): object;
-  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
-  getQualifier(attribute: string): QualifierValue | undefined;
-  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
-}
-//#endregion
-export { StandaloneInnerObjectProto };

package/dist/StandaloneInnerObjectProto.js

@@ -1,49 +0,0 @@
-import "@eggjs/tegg-metadata";
-import { AccessLevel, IdenticalUtil, MetadataUtil, QualifierUtil } from "@eggjs/tegg";
-
-//#region src/StandaloneInnerObjectProto.ts
-var StandaloneInnerObjectProto = class StandaloneInnerObjectProto {
-	clazz;
-	qualifiers;
-	id;
-	name;
-	initType;
-	accessLevel;
-	injectObjects;
-	loadUnitId;
-	constructor(id, name, clazz, initType, loadUnitId, qualifiers) {
-		this.id = id;
-		this.clazz = clazz;
-		this.name = name;
-		this.initType = initType;
-		this.accessLevel = AccessLevel.PUBLIC;
-		this.injectObjects = [];
-		this.loadUnitId = loadUnitId;
-		this.qualifiers = qualifiers;
-	}
-	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;
-	}
-	constructEggObject() {
-		return Reflect.apply(this.clazz, null, []);
-	}
-	getMetaData(metadataKey) {
-		return MetadataUtil.getMetaData(metadataKey, this.clazz);
-	}
-	getQualifier(attribute) {
-		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
-	}
-	static create(ctx) {
-		const { clazz, loadUnit } = ctx;
-		const name = ctx.prototypeInfo.name;
-		const id = IdenticalUtil.createProtoId(loadUnit.id, name);
-		return new StandaloneInnerObjectProto(id, name, clazz, ctx.prototypeInfo.initType, loadUnit.id, QualifierUtil.getProtoQualifiers(clazz));
-	}
-};
-
-//#endregion
-export { StandaloneInnerObjectProto };

package/dist/StandaloneLoadUnit.d.ts

@@ -1,10 +0,0 @@
-import { EggPrototype, LoadUnit } from "@eggjs/tegg-metadata";
-import { QualifierInfo } from "@eggjs/tegg";
-
-//#region src/StandaloneLoadUnit.d.ts
-interface InnerObject {
-  obj: object;
-  qualifiers?: QualifierInfo[];
-}
-//#endregion
-export { InnerObject };

package/dist/StandaloneLoadUnit.js

@@ -1,54 +0,0 @@
-import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
-import { EggPrototypeFactory } from "@eggjs/tegg-metadata";
-import { MapUtil } from "@eggjs/tegg-common-util";
-import { ObjectInitType } from "@eggjs/tegg";
-import { IdenticalUtil as IdenticalUtil$1 } from "@eggjs/tegg-lifecycle";
-
-//#region src/StandaloneLoadUnit.ts
-const StandaloneLoadUnitType = "StandaloneLoadUnitType";
-var StandaloneLoadUnit = class {
-	id = "StandaloneLoadUnit";
-	name = "StandaloneLoadUnit";
-	unitPath = "MockStandaloneLoadUnitPath";
-	type = StandaloneLoadUnitType;
-	innerObject;
-	protoMap = /* @__PURE__ */ new Map();
-	constructor(innerObject) {
-		this.innerObject = innerObject;
-	}
-	async init() {
-		for (const [name, objs] of Object.entries(this.innerObject)) for (const { obj, qualifiers } of objs) {
-			const proto = new StandaloneInnerObjectProto(IdenticalUtil$1.createProtoId(this.id, name), name, (() => obj), ObjectInitType.SINGLETON, this.id, qualifiers || []);
-			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.values()) 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();
-	}
-};
-
-//#endregion
-export { StandaloneLoadUnit, StandaloneLoadUnitType };

package/dist/main.d.ts

@@ -1,7 +0,0 @@
-import { RunnerOptions } from "./Runner.js";
-
-//#region src/main.d.ts
-declare function preLoad(cwd: string, dependencies?: RunnerOptions['dependencies']): Promise<void>;
-declare function main<T = void>(cwd: string, options?: RunnerOptions): Promise<T>;
-//#endregion
-export { main, preLoad };

package/dist/main.js

@@ -1,31 +0,0 @@
-import { Runner } from "./Runner.js";
-
-//#region src/main.ts
-async function preLoad(cwd, dependencies) {
-	try {
-		await Runner.preLoad(cwd, dependencies);
-	} catch (e) {
-		if (e instanceof Error) e.message = `[tegg/standalone] bootstrap standalone preLoad failed: ${e.message}`;
-		throw e;
-	}
-}
-async function main(cwd, options) {
-	const runner = new Runner(cwd, options);
-	try {
-		await runner.init();
-	} catch (e) {
-		if (e instanceof Error) e.message = `[tegg/standalone] bootstrap tegg failed: ${e.message}`;
-		throw e;
-	}
-	try {
-		return await runner.run();
-	} finally {
-		runner.destroy().catch((e) => {
-			e.message = `[tegg/standalone] destroy tegg failed: ${e.message}`;
-			console.warn(e);
-		});
-	}
-}
-
-//#endregion
-export { main, preLoad };