vona-core 5.0.104 → 5.0.106

package/dist/index.js

@@ -1,4 +1,3198 @@
 import '@cabloy/set';
 import '@cabloy/json5';
-export * from "./lib/index.js";
-export * from "./types/index.js";
+import { combineApiPathControllerAndActionRaw, combineApiPathControllerAndAction, combineApiPath, combineResourceName, sleep, isUndefined, isClass, isNilOrEmptyString, evaluateExpressions, catchErrorSync, isEmptyObject, hashkey } from '@cabloy/utils';
+import { toLowerCaseFirstChar, splitWords } from '@cabloy/word-utils';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { compose as compose$1 } from '@cabloy/compose';
+import { extend } from '@cabloy/extend';
+import fse from 'fs-extra';
+import * as uuid from 'uuid';
+import { setLocaleErrors, setLocaleAdapter, translateError } from '@cabloy/zod-errors-custom';
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import { setParseAdapter } from '@cabloy/zod-query';
+import 'reflect-metadata';
+import { parseModuleName as parseModuleName$1, parseModuleFile as parseModuleFile$1, ParseModuleNameLevelInit } from '@cabloy/module-info-pro';
+import * as localeutil from '@cabloy/localeutil';
+import { getOnionMetasMeta } from '@cabloy/module-info';
+import KoaApplication from 'koa';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import chalk from 'chalk';
+import * as Winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import os from 'node:os';
+import { MESSAGE, LEVEL } from 'triple-beam';
+import cluster from 'node:cluster';
+import { extendZodWithOpenApi } from '@cabloy/zod-to-openapi';
+import { z } from 'zod';
+import * as Retry from 'retry';
+export { Retry };
+
+function cast(source) {
+  return source;
+}
+
+class BeanSimple {
+  constructor() {
+    this.app = void 0;
+  }
+  get ctx() {
+    return this.app.currentContext;
+  }
+  get bean() {
+    return this.app.bean;
+  }
+}
+
+const localeDefault = {
+  modules: {}
+};
+
+const EnumAppEvent = {
+  AppStarted: 'eb:event:appStarted',
+  AppStartError: 'eb:event:appStartError'
+};
+
+function zodEnhance() {
+  setLocaleAdapter((text, iss) => {
+    const app = useApp();
+    return translateError((text, ...args) => {
+      return app.meta.text(text, ...args);
+    }, text, iss);
+  });
+  setParseAdapter(ZodMetadata);
+}
+function zodSetLocaleErrors(app, localeErrors, localeDefault) {
+  setLocaleErrors(() => {
+    return app.meta.locale.current;
+  }, localeErrors, localeDefault);
+}
+
+const SymbolProdRootPath = Symbol('SymbolProdRootPath');
+class AppUtil extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this[SymbolProdRootPath] = void 0;
+  }
+  instanceStarted(instanceName) {
+    return this.app.meta.appReadyInstances && this.app.meta.appReadyInstances[instanceName];
+  }
+  get protocol() {
+    const config = this.ctx ? this.ctx.config : this.app.config;
+    return config.server.serve.protocol || this.ctx?.protocol;
+  }
+  get host() {
+    const config = this.ctx ? this.ctx.config : this.app.config;
+    return config.server.serve.host || this.ctx?.host;
+  }
+  getAbsoluteUrl(path) {
+    const prefix = this.host ? `${this.protocol}://${this.host}` : '';
+    return `${prefix}${path || ''}`;
+  }
+  getAbsoluteUrlByApiPath(path) {
+    return this.getAbsoluteUrl(this.combineApiPath(path, '', true, true));
+  }
+  combineApiPathControllerAndActionRaw(moduleName, controllerPath, actionPath, simplify) {
+    return combineApiPathControllerAndActionRaw(moduleName, controllerPath, actionPath, simplify);
+  }
+  combineApiPathControllerAndAction(moduleName, controllerPath, actionPath, prefix, simplify) {
+    return combineApiPathControllerAndAction(moduleName, controllerPath, actionPath, prefix, simplify, this.app.config.server.globalPrefix);
+  }
+  combineApiPath(path, moduleName, prefix, simplify) {
+    return combineApiPath(path, moduleName, prefix, simplify, this.app.config.server.globalPrefix);
+  }
+  combineStaticPath(staticPath, moduleName) {
+    const globalPrefix = '/api/static';
+    if (!staticPath) staticPath = '';
+    // safe
+    staticPath = path.normalize(staticPath);
+    if (staticPath.includes('..')) throw new Error(`unsafe path: ${staticPath}`);
+    // ignore globalPrefix
+    if (staticPath.startsWith('//')) return staticPath.substring(1);
+    // ignore module path
+    if (staticPath.startsWith('/')) return `${globalPrefix}${staticPath}`;
+    // globalPrefix + module path + arg
+    if (!moduleName) throw new Error('should specify the moduleName');
+    if (typeof moduleName !== 'string') moduleName = moduleName.relativeName;
+    const parts = moduleName.split('-');
+    // path
+    return `${globalPrefix}/${parts[0]}/${parts[1]}/${staticPath}`;
+  }
+  combineResourceName(resourceName, moduleName, simplify, simplifyProviderId) {
+    return combineResourceName(resourceName, moduleName, simplify, simplifyProviderId);
+  }
+  async getPublicPathPhysical(subdir, ensure) {
+    const rootPath = this.app.config.server.publicDir;
+    // use instance.id, not instanceName
+    const dir = combineFilePathSafe(path.join(rootPath, cast(this.ctx).instance.id.toString()), subdir || '');
+    if (!dir) throw new Error('not valid path');
+    if (ensure) {
+      await fse.ensureDir(dir);
+    }
+    return dir;
+  }
+  get prodRootPath() {
+    if (!this.app.meta.isProd) throw new Error('only invoked in prod');
+    if (!this[SymbolProdRootPath]) {
+      this[SymbolProdRootPath] = import.meta.dirname;
+    }
+    return this[SymbolProdRootPath];
+  }
+  getAssetPathPhysical(moduleName, scene, assetPath) {
+    if (typeof moduleName !== 'string') moduleName = moduleName.relativeName;
+    if (this.app.meta.isProd) {
+      return combineFilePathSafe(path.join(this.prodRootPath, 'assets', scene, moduleName), assetPath || '');
+    } else {
+      const module = this.app.meta.modules[moduleName];
+      if (!module) throw new Error('module not found');
+      return combineFilePathSafe(path.join(module.root, 'assets', scene), assetPath || '');
+    }
+  }
+  createError(data, returnObject) {
+    const error = returnObject ? {} : new Error();
+    error.code = data.code !== undefined ? data.code : 500;
+    if (data.message && typeof data.message === 'object') {
+      error.message = JSON.stringify(data.message, null, 2);
+    } else {
+      error.message = data.message;
+    }
+    if (!this.app.meta.isProd) {
+      if (data.stack) error.stack = data.stack;
+      if (data.name) error.name = data.name;
+      if (data.errno) error.errno = data.errno;
+      if (data.sqlMessage) error.sqlMessage = data.sqlMessage;
+      if (data.sqlState) error.sqlState = data.sqlState;
+      if (data.index) error.index = data.index;
+      if (data.sql) error.sql = data.sql;
+    }
+    return error;
+  }
+  async monkeyModule(ebAppMonkey, ebModulesMonkey, monkeyName, moduleTarget, ...monkeyData) {
+    // self: main
+    if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+      // @ts-ignore ignore
+      await moduleTarget.mainInstance[monkeyName](...monkeyData);
+    }
+    // module monkey
+    for (const key in ebModulesMonkey) {
+      const moduleMonkey = ebModulesMonkey[key];
+      if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+        if (moduleTarget === undefined) {
+          // @ts-ignore ignore
+          await moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+        } else {
+          // @ts-ignore ignore
+          await moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+        }
+      }
+    }
+    // app monkey
+    if (ebAppMonkey && ebAppMonkey[monkeyName]) {
+      if (moduleTarget === undefined) {
+        await ebAppMonkey[monkeyName](...monkeyData);
+      } else {
+        await ebAppMonkey[monkeyName](moduleTarget, ...monkeyData);
+      }
+    }
+  }
+  monkeyModuleSync(ebAppMonkey, ebModulesMonkey, monkeyName, moduleTarget, ...monkeyData) {
+    // self: main
+    if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+      // @ts-ignore ignore
+      moduleTarget.mainInstance[monkeyName](...monkeyData);
+    }
+    // module monkey
+    for (const key in ebModulesMonkey) {
+      const moduleMonkey = ebModulesMonkey[key];
+      if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+        if (moduleTarget === undefined) {
+          // @ts-ignore ignore
+          moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+        } else {
+          // @ts-ignore ignore
+          moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+        }
+      }
+    }
+    // app monkey
+    if (ebAppMonkey && ebAppMonkey[monkeyName]) {
+      if (moduleTarget === undefined) {
+        ebAppMonkey[monkeyName](...monkeyData);
+      } else {
+        ebAppMonkey[monkeyName](moduleTarget, ...monkeyData);
+      }
+    }
+  }
+  detectErrorMessage(err) {
+    // detect json parse error
+    if (err.status === 400 && err.name === 'SyntaxError' && this.ctx.request.is('application/json', 'application/vnd.api+json', 'application/csp-report')) {
+      return 'Problems parsing JSON';
+    }
+    return err.message;
+  }
+  detectStatus(err) {
+    // detect status
+    let status = err.status || 500;
+    if (typeof status !== 'number') status = Number(status);
+    if (status < 200) {
+      // invalid status consider as 500, like urllib will return -1 status
+      status = 500;
+    }
+    return status;
+  }
+  accepts() {
+    if (this.ctx.acceptJSON) return 'json';
+    return 'html';
+  }
+  getModuleConfigRaw(moduleName) {
+    return this.app.config.modules[moduleName];
+  }
+  setLocaleErrors(localeErrors, localeDefault) {
+    return zodSetLocaleErrors(this.app, localeErrors, localeDefault);
+  }
+}
+function compose(chains, adapter) {
+  return compose$1(chains, adapter);
+}
+function instanceDesp(instanceName) {
+  if (instanceName === undefined || instanceName === null) return '~';
+  return instanceName || '-';
+}
+function requireDynamic(file) {
+  if (!file) throw new Error('file should not empty');
+  const require = createRequire(import.meta.url);
+  let instance = require(file);
+  const mtime = _requireDynamic_getFileTime(file);
+  if (instance.__requireDynamic_mtime === undefined) {
+    instance.__requireDynamic_mtime = mtime;
+  } else if (instance.__requireDynamic_mtime !== mtime) {
+    delete require.cache[require.resolve(file)];
+    instance = require(file);
+    instance.__requireDynamic_mtime = mtime;
+  }
+  return instance;
+}
+function _requireDynamic_getFileTime(file) {
+  if (!path.isAbsolute(file)) return null;
+  const exists = fse.pathExistsSync(file);
+  if (!exists) return null;
+  // stat
+  const stat = fse.statSync(file);
+  return stat.mtime.valueOf();
+}
+function deepExtend(target, ...args) {
+  return extend(true, target, ...args);
+}
+function uuidv4() {
+  return uuid.v4();
+}
+function createHash(str, encoding, algorithm, options) {
+  const hash = crypto.createHash(algorithm ?? 'sha256', options);
+  hash.update(str);
+  return hash.digest(encoding ?? 'hex');
+}
+async function disposeInstance(instance) {
+  await instance?.__dispose__?.();
+}
+function polyfillDispose(instance) {
+  if (!instance || instance.__dispose__) return;
+  Object.getPrototypeOf(instance).__dispose__ = () => {};
+}
+function pathToHref(fileName) {
+  return pathToFileURL(fileName).href;
+  // return Path.sep === '\\' ? pathToFileURL(fileName).href : fileName;
+}
+function prepareEnv(env) {
+  const env2 = {
+    ...env
+  };
+  for (const key of Object.keys(env2)) {
+    if (process.env[key] !== undefined) {
+      env2[key] = process.env[key];
+    }
+  }
+  return env2;
+}
+function beanFullNameFromOnionName(onionName, sceneName) {
+  return onionName.replace(':', `.${sceneName}.`);
+}
+function onionNameFromBeanFullName(beanFullName, sceneName) {
+  return beanFullName.replace(`.${sceneName}.`, ':');
+}
+function filterHeaders(headers, whitelist) {
+  if (!headers) return;
+  const res = {};
+  for (const key in headers) {
+    if (whitelist.includes(key)) {
+      res[key] = headers[key];
+    }
+  }
+  return res;
+}
+function combineFilePathSafe(dir, file) {
+  const fullPath = path.normalize(path.join(dir, file));
+  // files that can be accessd should be under options.dir
+  if (fullPath.indexOf(dir) !== 0) throw new Error(`unsafe dir: ${dir}`);
+  return fullPath;
+}
+async function loadJSONFile(fileName) {
+  const pkgContent = (await fse.readFile(fileName)).toString();
+  return JSON.parse(pkgContent);
+}
+async function saveJSONFile(fileName, json) {
+  await fse.writeFile(fileName, `${JSON.stringify(json, null, 2)}\n`);
+}
+
+function useApp() {
+  return globalThis.__app__;
+}
+async function closeApp(terminate) {
+  while (globalThis.__closing__) {
+    await sleep(50);
+  }
+  try {
+    globalThis.__closing__ = true;
+    if (globalThis.__app__) {
+      await globalThis.__app__.meta.close();
+      delete globalThis.__app__;
+    }
+  } finally {
+    globalThis.__closing__ = false;
+  }
+  if (terminate) {
+    process.kill(process.pid, 'SIGTERM');
+  }
+}
+async function createGeneralApp(projectPath, envRuntime) {
+  if (envRuntime) {
+    for (const key of Object.keys(envRuntime)) {
+      process.env[key] = envRuntime[key];
+    }
+  }
+  if (process.env.META_MODE === 'prod') {
+    const testFile = path.join(projectPath, `dist/${process.env.META_FLAVOR}/bootstrap.js`);
+    const testInstance = await import(pathToHref(testFile));
+    return await testInstance.appBootstrap;
+  } else {
+    const testFile = path.join(projectPath, '.vona/app.ts');
+    const testInstance = await import(pathToHref(testFile));
+    return await testInstance.createSingleApp();
+  }
+}
+
+// export async function reloadApp() {
+//   while (globalThis.__reloading__) {
+//     await sleep(100);
+//   }
+//   try {
+//     globalThis.__reloading__ = true;
+//     await closeApp();
+//     await createApp(globalThis.__bootstrapOptions__);
+//   } finally {
+//     globalThis.__reloading__ = false;
+//   }
+// }
+
+class AppMetadata {
+  defineMetadata(metadataKey, metadataValue, target, prop) {
+    if (isUndefined(prop)) {
+      Reflect.defineMetadata(metadataKey, metadataValue, target);
+    } else {
+      Reflect.defineMetadata(metadataKey, metadataValue, target, prop);
+    }
+  }
+  hasOwnMetadata(metadataKey, target, prop) {
+    if (isUndefined(prop)) return Reflect.hasOwnMetadata(metadataKey, target);
+    return Reflect.hasOwnMetadata(metadataKey, target, prop);
+  }
+  hasMetadata(metadataKey, target, prop) {
+    if (isUndefined(prop)) return Reflect.hasMetadata(metadataKey, target);
+    return Reflect.hasMetadata(metadataKey, target, prop);
+  }
+  getOwnMetadata(metadataKey, target, prop) {
+    if (isUndefined(prop)) return Reflect.getOwnMetadata(metadataKey, target);
+    return Reflect.getOwnMetadata(metadataKey, target, prop);
+  }
+  getMetadata(metadataKey, target, prop) {
+    if (isUndefined(prop)) return Reflect.getMetadata(metadataKey, target);
+    return Reflect.getMetadata(metadataKey, target, prop);
+  }
+  getOwnMetadataArray(inherit, metadataKey, target, prop) {
+    let own = this.getOwnMetadata(metadataKey, target, prop);
+    if (!own) {
+      if (!inherit) {
+        own = [];
+      } else {
+        const parent = this.getMetadata(metadataKey, target, prop);
+        if (parent) {
+          own = parent.slice();
+        } else {
+          own = [];
+        }
+      }
+      this.defineMetadata(metadataKey, own, target, prop);
+    }
+    return own;
+  }
+  getOwnMetadataMap(inherit, metadataKey, target, prop) {
+    let own = this.getOwnMetadata(metadataKey, target, prop);
+    if (!own) {
+      if (!inherit) {
+        own = {};
+      } else {
+        const parent = this.getMetadata(metadataKey, target, prop);
+        if (parent) {
+          own = Object.assign({}, parent);
+        } else {
+          own = {};
+        }
+      }
+      this.defineMetadata(metadataKey, own, target, prop);
+    }
+    return own;
+  }
+  getDesignType(target, prop) {
+    return this.getMetadata('design:type', target, prop);
+  }
+  getDesignParamtypes(target, prop) {
+    return this.getMetadata('design:paramtypes', target, prop);
+  }
+  getDesignReturntype(target, prop) {
+    return this.getMetadata('design:returntype', target, prop);
+  }
+}
+const appMetadata = new AppMetadata();
+
+const SymbolMappedClassMetadataKeys = Symbol('SymbolMappedClassMetakeys');
+
+function registerMappedClassMetadataKey(target, metadataKey, options) {
+  const metadataKeys = appMetadata.getOwnMetadataMap(true, SymbolMappedClassMetadataKeys, target);
+  if (!Object.hasOwn(metadataKeys, metadataKey)) {
+    metadataKeys[metadataKey] = options;
+  }
+}
+function getMappedClassMetadataKeys(target) {
+  return appMetadata.getMetadata(SymbolMappedClassMetadataKeys, target);
+}
+function setMappedClassMetadataKeys(target, metadataKeys) {
+  return appMetadata.defineMetadata(SymbolMappedClassMetadataKeys, metadataKeys, target);
+}
+function copyPropertiesOfClasses(target, sources, filter) {
+  for (const source of sources) {
+    copyProperties(target, source, ['constructor', 'prototype', 'length', 'name'], filter); // copy static
+    copyProperties(target.prototype, source.prototype, ['constructor', 'prototype'], filter); // copy prototype
+  }
+}
+function copyProperties(target, source, keysIgnore, filter) {
+  const protos = [];
+  let _proto = source;
+  while (_proto) {
+    if (!['Object'].includes(_proto.constructor?.name) && !Object.hasOwn(_proto, 'arguments')) {
+      protos.unshift(_proto);
+    }
+    _proto = Object.getPrototypeOf(_proto);
+  }
+  for (const proto of protos) {
+    for (const key of Reflect.ownKeys(proto)) {
+      if (keysIgnore.includes(key)) continue;
+      if (filter && !filter(key)) continue;
+      // desc
+      const desc = Object.getOwnPropertyDescriptor(proto, key);
+      Object.defineProperty(target, key, desc);
+      // metadata
+      const metaKeys = Reflect.getOwnMetadataKeys(proto, key);
+      for (const metaKey of metaKeys) {
+        const metaValue = Reflect.getOwnMetadata(metaKey, proto, key);
+        Reflect.defineMetadata(metaKey, metaValue, target, key);
+      }
+    }
+  }
+}
+function copyMetadataOfClasses(target, sources, transform) {
+  //
+  const metadataKeys = {};
+  for (const source of sources) {
+    const _metadataKeys = getMappedClassMetadataKeys(source);
+    if (_metadataKeys) {
+      Object.assign(metadataKeys, _metadataKeys);
+    }
+  }
+  setMappedClassMetadataKeys(target, metadataKeys);
+  //
+  for (const metadataKey of Object.getOwnPropertySymbols(metadataKeys)) {
+    const metadataKeyOptions = metadataKeys[metadataKey];
+    const rulesNew = {};
+    for (const source of sources) {
+      const rules = appMetadata.getMetadata(metadataKey, source);
+      if (!rules) continue;
+      if (!transform) {
+        Object.assign(rulesNew, rules);
+      } else {
+        for (const key in rules) {
+          const ruleNew = transform(rules, key, metadataKeyOptions);
+          if (ruleNew !== undefined) {
+            rulesNew[key] = ruleNew;
+          }
+        }
+      }
+    }
+    appMetadata.defineMetadata(metadataKey, rulesNew, target);
+  }
+}
+
+const SymbolDecoratorBeanFullName = Symbol('SymbolDecoratorBeanFullName');
+const SymbolDecoratorBeanInfo = Symbol('SymbolDecoratorBeanInfo');
+const SymbolDecoratorProxyDisable = Symbol('SymbolDecoratorProxyDisable');
+const SymbolDecoratorVirtual = Symbol('SymbolDecoratorVirtual');
+const SymbolDecoratorUse = Symbol('SymbolDecoratorUse');
+class AppResource extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this.beans = {};
+    this.scenes = {};
+  }
+  addUse(target, options) {
+    registerMappedClassMetadataKey(target, SymbolDecoratorUse);
+    const uses = appMetadata.getOwnMetadataMap(true, SymbolDecoratorUse, target);
+    uses[options.prop] = options;
+  }
+  getUses(target) {
+    return appMetadata.getMetadata(SymbolDecoratorUse, target);
+  }
+  addBean(beanOptions) {
+    let {
+      module,
+      scene,
+      name,
+      beanClass,
+      options,
+      optionsPrimitive
+    } = beanOptions;
+    // virtual
+    const virtual = appMetadata.getOwnMetadata(SymbolDecoratorVirtual, beanClass);
+    // name
+    name = this._parseBeanName(beanClass, scene, name);
+    // module
+    if (!module) {
+      throw new Error(`module name not parsed for bean: ${scene}.${name}`);
+    }
+    // beanFullName
+    const beanFullName = scene && scene !== 'bean' ? `${module}.${scene}.${name}` : name;
+    // moduleBelong
+    const moduleBelong = this._parseModuleBelong(module, beanClass, virtual);
+    // options
+    const options2 = this._prepareOnionOptions(options, optionsPrimitive, scene, `${module}:${name}`);
+    // beanOptions2
+    const beanOptions2 = {
+      ...beanOptions,
+      beanFullName,
+      name,
+      moduleBelong,
+      options: options2
+    };
+    // record
+    this.beans[beanFullName] = beanOptions2;
+    if (!this.scenes[scene]) this.scenes[scene] = {};
+    if (!this.scenes[scene][module]) this.scenes[scene][module] = {};
+    this.scenes[scene][module][beanFullName] = beanOptions2;
+    // set metadata
+    appMetadata.defineMetadata(SymbolDecoratorBeanFullName, beanFullName, beanOptions2.beanClass);
+    // ok
+    return beanOptions2;
+  }
+  getBeanFullName(beanFullName) {
+    if (!beanFullName) return beanFullName;
+    if (typeof beanFullName === 'function' && isClass(beanFullName)) {
+      return appMetadata.getOwnMetadata(SymbolDecoratorBeanFullName, beanFullName);
+    }
+    return beanFullName;
+  }
+  getBean(beanFullName) {
+    const fullName = this.getBeanFullName(beanFullName);
+    if (!fullName) return null;
+    return this.beans[fullName];
+  }
+  _parseBeanName(beanClass, scene, name) {
+    // name
+    if (name) return name;
+    // scene
+    if (!scene) scene = 'bean';
+    scene = scene.replace(/\./g, '');
+    // bean class name
+    const beanClassName = this._fixClassName(beanClass.name);
+    if (beanClassName.toLocaleUpperCase().startsWith(scene.toLocaleUpperCase())) {
+      name = beanClassName.substring(scene.length);
+    } else {
+      name = beanClassName;
+    }
+    // lowerCase
+    name = toLowerCaseFirstChar(name);
+    return name;
+  }
+  _parseModuleBelong(module, beanClass, virtual) {
+    if (!virtual) return module;
+    // check parent
+    let moduleBelong;
+    let parent = Object.getPrototypeOf(beanClass);
+    while (parent) {
+      const beanOptions = this.getBean(parent);
+      if (beanOptions && beanOptions.moduleBelong) {
+        moduleBelong = beanOptions.moduleBelong;
+        break;
+      }
+      parent = Object.getPrototypeOf(parent);
+    }
+    return moduleBelong;
+  }
+  _getModuleBelong(beanFullName) {
+    const beanOptions = this.getBean(beanFullName);
+    if (!beanOptions || !beanOptions.moduleBelong) throw new Error(`not found module belong: ${beanFullName}`);
+    return beanOptions.moduleBelong;
+  }
+  _getModuleName(beanFullName) {
+    const beanOptions = this.getBean(beanFullName);
+    return beanOptions?.module;
+  }
+  _fixClassName(className) {
+    while (className.endsWith('2')) {
+      className = className.substring(0, className.length - 1);
+    }
+    return className;
+  }
+  _prepareOnionOptions(options, optionsPrimitive, scene, name) {
+    const app = useApp();
+    if (!app?.config && scene !== 'scope') {
+      throw new Error('Should not import vona module in config');
+    }
+    const optionsConfig = cast(app?.config)?.onions?.[scene]?.[name];
+    if (optionsPrimitive) {
+      return optionsConfig === undefined ? options : optionsConfig;
+    } else {
+      return deepExtend({}, options, optionsConfig);
+    }
+  }
+}
+const appResource = new AppResource();
+
+const SymbolBeanFullName = Symbol('SymbolBeanFullName');
+const SymbolBeanInstanceKey = Symbol('SymbolBeanInstanceKey');
+const SymbolModuleBelong = Symbol('SymbolModuleBelong');
+const SymbolModuleName = Symbol('SymbolModuleName');
+class BeanBaseSimple extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this[SymbolBeanFullName] = void 0;
+  }
+  get [SymbolModuleBelong]() {
+    return appResource._getModuleBelong(this[SymbolBeanFullName]);
+  }
+  get [SymbolModuleName]() {
+    return appResource._getModuleName(this[SymbolBeanFullName]);
+  }
+  get $beanFullName() {
+    return this[SymbolBeanFullName];
+  }
+  get $beanOptions() {
+    return appResource.getBean(this[SymbolBeanFullName]);
+  }
+  get $onionName() {
+    const parts = this.$beanFullName.split('.');
+    return `${parts[0]}:${parts[2]}`;
+  }
+  get $onionOptions() {
+    return this.$beanOptions.options;
+  }
+}
+
+const SymbolText = Symbol('SymbolText');
+const SymbolLogger = Symbol('SymbolLogger');
+const SymbolLoggerChildren = Symbol('SymbolLoggerChildren');
+class BeanBase extends BeanBaseSimple {
+  constructor(...args) {
+    super(...args);
+    this[SymbolText] = void 0;
+    this[SymbolLogger] = {};
+    this[SymbolLoggerChildren] = {};
+  }
+  get $text() {
+    if (!this[SymbolText]) {
+      this[SymbolText] = this.app.meta.locale.createLocaleText(this[SymbolModuleBelong]);
+    }
+    return this[SymbolText];
+  }
+  get $logger() {
+    return this.$loggerClient('default');
+  }
+  $loggerClient(clientName = 'default') {
+    if (!this[SymbolLogger][clientName]) {
+      this[SymbolLogger][clientName] = this.app.meta.logger.get(clientName).child({
+        beanFullName: this.$beanFullName
+      });
+    }
+    return this[SymbolLogger][clientName];
+  }
+  $loggerChild(childName, clientName = 'default') {
+    if (!this[SymbolLoggerChildren][clientName]) this[SymbolLoggerChildren][clientName] = {};
+    if (!this[SymbolLoggerChildren][clientName][childName]) {
+      this[SymbolLoggerChildren][clientName][childName] = this.app.meta.logger.get(clientName).child({
+        beanFullName: this.$beanFullName,
+        name: childName
+      });
+    }
+    return this[SymbolLoggerChildren][clientName][childName];
+  }
+  $mutate(args) {
+    this.app.meta.hmr?.mutateBeanInstance(this.$beanFullName, this[SymbolBeanInstanceKey], args);
+  }
+  get $scope() {
+    return this.app.meta.scopeContainer;
+  }
+  get scope() {
+    return this.bean.scope(this[SymbolModuleBelong]);
+  }
+}
+
+class BeanAopBase extends BeanBase {}
+
+class BeanAopMethodBase extends BeanBase {}
+
+function BeanInfo(options) {
+  return function (target) {
+    // set metadata
+    appMetadata.defineMetadata(SymbolDecoratorBeanInfo, options, target);
+  };
+}
+
+class AppHmrDeps extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this._deps = {};
+    this._depsTemp = void 0;
+  }
+  get deps() {
+    return this._deps;
+  }
+  addBeans(classRefs) {
+    for (const classRef of classRefs) {
+      this.addBean(classRef);
+    }
+  }
+  addBean(classRef) {
+    const beanOptions = appResource.getBean(classRef);
+    if (beanOptions) {
+      this.add(beanOptions.beanFullName);
+    }
+  }
+  add(beanFullName) {
+    if (!this._depsTemp) this._depsTemp = new Set();
+    this._depsTemp.add(beanFullName);
+  }
+  end(beanFullName) {
+    if (!this._depsTemp || this._depsTemp.size === 0) return;
+    const depsTemp = this._depsTemp;
+    this._depsTemp = undefined;
+    for (const depTemp of depsTemp) {
+      if (!this._deps[depTemp]) this._deps[depTemp] = new Set();
+      this._deps[depTemp].add(beanFullName);
+    }
+  }
+}
+const appHmrDeps = new AppHmrDeps();
+
+const ParseModuleNameLevel = ParseModuleNameLevelInit + 5;
+function parseModuleName(beanClass) {
+  // beanInfo
+  const beanInfo = appMetadata.getOwnMetadata(SymbolDecoratorBeanInfo, beanClass);
+  return beanInfo?.module || parseModuleName$1(ParseModuleNameLevel);
+}
+function parseModuleFile() {
+  return parseModuleFile$1(ParseModuleNameLevel);
+}
+
+function createBeanDecorator(scene, options, optionsPrimitive, fn) {
+  return function (target) {
+    const beanClass = target;
+    // module
+    const module = parseModuleName(beanClass);
+    const file = process.env.META_MODE !== 'prod' ? parseModuleFile() : undefined;
+    // name
+    const name = scene === 'scope' ? 'module' : undefined;
+    // add
+    const beanOptions = appResource.addBean({
+      module,
+      scene,
+      name,
+      beanClass,
+      options,
+      optionsPrimitive,
+      file
+    });
+    // fn
+    fn?.(beanClass);
+    appHmrDeps.end(beanOptions.beanFullName);
+  };
+}
+
+function ProxyDisable() {
+  return function (target) {
+    // set metadata
+    appMetadata.defineMetadata(SymbolDecoratorProxyDisable, true, target);
+  };
+}
+
+function Use(options) {
+  return function (target, prop, descriptor) {
+    if (!options) options = {};
+    if (typeof options === 'string') {
+      options = {
+        beanFullName: options
+      };
+    }
+    // beanClass maybe has no specific class type
+    const beanClass = appMetadata.getDesignType(target, prop);
+    // beanFullName
+    let beanFullName = options.beanFullName;
+    if (!beanFullName) {
+      beanFullName = appResource.getBeanFullName(beanClass);
+      if (!beanFullName) {
+        throw new Error(`@Use not found valid beanFullName for: ${target.constructor.name}.${String(prop)}`);
+      }
+    }
+    // record
+    appResource.addUse(target, {
+      ...options,
+      prop,
+      beanFullName,
+      descriptor
+    });
+  };
+}
+function usePrepareArg(arg, withSelector) {
+  return {
+    withSelector,
+    args: [arg]
+  };
+}
+function usePrepareArgs(args, withSelector) {
+  return {
+    withSelector,
+    args
+  };
+}
+function __prepareInjectSelectorInfo(beanInstance, useOptions) {
+  let selectorInfo = __prepareInjectSelectorInfo_descriptor(beanInstance, useOptions);
+  if (!selectorInfo) {
+    selectorInfo = __prepareInjectSelectorInfo_init(beanInstance, useOptions);
+  }
+  if (!selectorInfo && !isNilOrEmptyString(useOptions.selector)) {
+    const selector = evaluateExpressions(useOptions.selector, {
+      self: beanInstance,
+      app: beanInstance.app,
+      ctx: beanInstance.ctx
+    });
+    return {
+      withSelector: true,
+      args: [selector]
+    };
+  }
+  return selectorInfo ?? {
+    withSelector: false,
+    args: []
+  };
+}
+function __prepareInjectSelectorInfo_descriptor(beanInstance, useOptions) {
+  const fnGet = useOptions.descriptor?.get;
+  if (!fnGet) return;
+  const res = fnGet.call(beanInstance);
+  if (!res) return;
+  const withSelector = res.withSelector ?? false;
+  const args = res.args.map(arg => typeof arg === 'function' ? arg() : arg);
+  return {
+    withSelector,
+    args
+  };
+}
+function __prepareInjectSelectorInfo_init(beanInstance, useOptions) {
+  const init = useOptions.init;
+  if (!init) return;
+  const withSelector = init.withSelector ?? false;
+  const _args = init.args ?? [init.arg];
+  if (!_args) return;
+  const args = _args.map(arg => evaluateExpressions(arg, {
+    self: beanInstance,
+    app: beanInstance.app,
+    ctx: beanInstance.ctx
+  }));
+  return {
+    withSelector,
+    args
+  };
+}
+
+function Virtual() {
+  return function (target) {
+    // set metadata
+    appMetadata.defineMetadata(SymbolDecoratorVirtual, true, target);
+  };
+}
+
+const functionNoop = () => {};
+
+const SymbolProxyMagic = Symbol('SymbolProxyMagic');
+const SymbolProxyAopMethod = Symbol('SymbolProxyAopMethod');
+const SymbolCacheAopChains = Symbol('SymbolCacheAopChains');
+const SymbolCacheAopChainsKey = Symbol('SymbolCacheAopChainsKey');
+const SymbolBeanContainerInstances = Symbol('SymbolBeanContainerInstances');
+const SymbolBeanInstancePropsLazy = Symbol('SymbolBeanInstancePropsLazy');
+// const BeanInstanceScope = Symbol('BeanInstance#Scope');
+
+class BeanContainer {
+  static create(app, ctx) {
+    const beanContainer = new BeanContainer(app, ctx);
+    return new Proxy(beanContainer, {
+      get(obj, prop) {
+        if (typeof prop === 'symbol') return obj[prop];
+        if (obj[prop]) return obj[prop];
+        return obj._getBean(prop);
+      }
+    });
+  }
+  constructor(app, ctx) {
+    this.app = void 0;
+    this.ctx = void 0;
+    this[SymbolBeanContainerInstances] = {};
+    this.app = app;
+    this.ctx = ctx;
+  }
+
+  /** @internal */
+  async dispose() {
+    const beanInstances = this[SymbolBeanContainerInstances];
+    for (const prop in beanInstances) {
+      const beanInstance = cast(beanInstances[prop]);
+      if (beanInstance && !(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
+        await beanInstance.__dispose__();
+      }
+    }
+    this[SymbolBeanContainerInstances] = {};
+  }
+  async _removeBean(beanInstanceKeyLike) {
+    const beanInstanceKey = typeof beanInstanceKeyLike === 'string' ? beanInstanceKeyLike : beanInstanceKeyLike[SymbolBeanInstanceKey];
+    if (!beanInstanceKey) return;
+    const beanInstance = this[SymbolBeanContainerInstances][beanInstanceKey];
+    if (beanInstance) {
+      if (!(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
+        await beanInstance.__dispose__();
+      }
+    }
+    // maybe null
+    delete this[SymbolBeanContainerInstances][beanInstanceKey];
+  }
+  get containerType() {
+    if (!this.ctx) return 'app';
+    return 'ctx';
+  }
+
+  /** get specific module's scope */
+
+  // scope<T>(moduleScope: string): T;
+  scope(moduleScope) {
+    return this._getBean(`${moduleScope}.scope.module`);
+  }
+  // _getBean<T>(beanFullName: string, ...args): T;
+  _getBean(beanFullName, ...args) {
+    return this._getBeanSelectorInner(beanFullName, false, ...args);
+  }
+  // _getBeanSelector<T>(beanFullName: string, selector?: string, ...args): T;
+  _getBeanSelector(beanFullName, selector, ...args) {
+    return this._getBeanSelectorInner(beanFullName, true, selector, ...args);
+  }
+  _getBeanSelectorInner(beanFullName, withSelector, ...args) {
+    // bean options
+    const beanOptions = appResource.getBean(beanFullName);
+    if (!beanOptions) {
+      // not found
+      return null;
+    }
+    const fullName = beanOptions.beanFullName;
+    const key = __getSelectorKey(fullName, withSelector, args[0]);
+    if (this[SymbolBeanContainerInstances][key] === undefined) {
+      this._newBeanInner(true, fullName, withSelector, ...args);
+    }
+    return this[SymbolBeanContainerInstances][key];
+  }
+  // _newBean<T>(beanFullName: string, ...args): T;
+  _newBean(beanFullName, ...args) {
+    return this._newBeanInner(false, beanFullName, false, ...args);
+  }
+  // _newBeanSelector<T>(beanFullName: string, selector?: string, ...args): T;
+  _newBeanSelector(beanFullName, selector, ...args) {
+    return this._newBean(beanFullName, selector, ...args);
+  }
+
+  /** @internal */
+  _newBeanInner(record, beanFullName, withSelector, ...args) {
+    // bean options
+    const beanOptions = appResource.getBean(beanFullName);
+    if (!beanOptions) {
+      // class
+      if (typeof beanFullName === 'function' && isClass(beanFullName)) {
+        return this._createBeanInstance(record, undefined, beanFullName, args, false, withSelector);
+      }
+      // throw new Error(`bean not found: ${beanFullName}`);
+      return null;
+    }
+    // instance
+    return this._createBeanInstance(record, beanOptions.beanFullName, beanOptions.beanClass, args, cast(beanOptions.scene) === 'aop', withSelector);
+  }
+  _createBeanInstance(record, beanFullName, beanClass, args, aop, withSelector) {
+    // prepare
+    const beanInstance = this._prepareBeanInstance(beanFullName, beanClass, args, aop);
+    // record
+    if (record) {
+      // fullName
+      const fullName = appResource.getBeanFullName(beanFullName);
+      if (fullName) {
+        const key = __getSelectorKey(fullName, withSelector, args[0]);
+        __setPropertyValue(beanInstance, SymbolBeanInstanceKey, key);
+        this[SymbolBeanContainerInstances][key] = beanInstance;
+        this.containerType === 'app' && this.app.meta.hmr?.addBeanInstance(fullName, key, args, withSelector);
+      }
+    }
+    // init
+    this._initBeanInstance(beanFullName, beanInstance, args);
+    // ok
+    return beanInstance;
+  }
+  _prepareBeanInstance(beanFullName, BeanClass, args, aop) {
+    // create
+    let beanInstance;
+    if (BeanClass.prototype.__init__) {
+      beanInstance = new BeanClass();
+    } else {
+      beanInstance = new BeanClass(...args);
+    }
+    // app/ctx
+    if (beanInstance instanceof BeanSimple) {
+      beanInstance.app = this.app;
+      if (this.ctx) {
+        __setPropertyValue(beanInstance, 'ctx', this.ctx);
+      }
+    }
+    // beanFullName
+    if (typeof beanFullName === 'string') {
+      __setPropertyValue(beanInstance, SymbolBeanFullName, beanFullName);
+    }
+    // aop: proxy
+    return this._patchBeanInstance(beanFullName || BeanClass, beanInstance, aop);
+  }
+  _initBeanInstance(beanFullName, beanInstance, args) {
+    // inject
+    this._injectBeanInstance(beanInstance, beanFullName);
+    // init
+    if (!(beanInstance instanceof BeanAopBase) && beanInstance.__init__) {
+      beanInstance.__init__(...args);
+    }
+    // ok
+    return beanInstance;
+  }
+  _injectBeanInstance(beanInstance, beanFullName) {
+    const beanOptions = appResource.getBean(beanFullName);
+    if (!beanOptions) return;
+    const uses = appResource.getUses(beanOptions.beanClass.prototype);
+    if (!uses) return;
+    for (const key in uses) {
+      const useOptions = uses[key];
+      this._injectBeanInstancePropLazy(beanInstance, useOptions.prop, useOptions.beanFullName, useOptions);
+    }
+  }
+  _injectBeanInstancePropLazy(beanInstance, prop, targetBeanFullName, useOptions) {
+    const self = this;
+    Object.defineProperty(beanInstance, prop, {
+      enumerable: true,
+      configurable: true,
+      get() {
+        if (!beanInstance[SymbolBeanInstancePropsLazy]) beanInstance[SymbolBeanInstancePropsLazy] = {};
+        if (!beanInstance[SymbolBeanInstancePropsLazy][prop]) {
+          beanInstance[SymbolBeanInstancePropsLazy][prop] = self._injectBeanInstanceProp(beanInstance, targetBeanFullName, useOptions);
+          self.containerType === 'app' && self.app.meta.hmr?.addBeanInstanceProp(beanInstance, prop, targetBeanFullName);
+        }
+        return beanInstance[SymbolBeanInstancePropsLazy][prop];
+      }
+    });
+  }
+  _injectBeanInstanceProp(beanInstance, targetBeanFullName, useOptions) {
+    // injectionScope
+    const injectionScope = useOptions.injectionScope ?? 'app';
+    // options: selectorInfo
+    const selectorInfo = __prepareInjectSelectorInfo(beanInstance, useOptions);
+    // targetInstance
+    let targetInstance;
+    // selector maybe empty string
+    if (injectionScope === 'app') {
+      targetInstance = this.app.bean._getBeanSelectorInner(targetBeanFullName, selectorInfo.withSelector, ...selectorInfo.args);
+    } else if (injectionScope === 'ctx') {
+      targetInstance = this._getBeanSelectorInner(targetBeanFullName, selectorInfo.withSelector, ...selectorInfo.args);
+    } else if (injectionScope === 'new') {
+      targetInstance = this._newBeanInner(false, targetBeanFullName, selectorInfo.withSelector, ...selectorInfo.args);
+    }
+    return targetInstance;
+  }
+
+  // private _injectBeanInstanceScope(beanInstance, beanFullName) {
+  //   if (typeof beanFullName !== 'string' || beanFullName.indexOf('.scope.module') > -1) return;
+  //   Object.defineProperty(beanInstance, 'scope', {
+  //     enumerable: false,
+  //     configurable: true,
+  //     get() {
+  //       if (!this[BeanInstanceScope]) {
+  //         this[BeanInstanceScope] = this.bean._getBean(`${this[SymbolModuleBelong]}.scope.module`);
+  //       }
+  //       return this[BeanInstanceScope];
+  //     },
+  //   });
+  // }
+
+  _patchBeanInstance(beanFullNameOrBeanClass, beanInstance, aop) {
+    if (!beanFullNameOrBeanClass) return beanInstance;
+    // not aop on aop
+    if (aop) return beanInstance;
+    // aop chains
+    const _aopChains = this._prepareAopChains(beanFullNameOrBeanClass, beanInstance);
+    // no aop
+    if (_aopChains.length === 0) return beanInstance;
+    // aop
+    return this._newBeanProxy(beanFullNameOrBeanClass, beanInstance);
+  }
+  _newBeanProxy(beanFullName, beanInstance) {
+    const self = this;
+    return new Proxy(beanInstance, {
+      get(target, prop, receiver) {
+        if (typeof prop === 'symbol') {
+          return Reflect.get(target, prop, receiver);
+        }
+        if (__isInnerMethod(prop)) {
+          return Reflect.get(target, prop, receiver);
+        }
+        // descriptorInfo
+        const descriptorInfo = __getPropertyDescriptor(target, prop);
+        if (!__checkAopOfDescriptorInfo(descriptorInfo)) return Reflect.get(target, prop, receiver);
+        const methodType = __methodTypeOfDescriptor(descriptorInfo);
+        // get prop
+        if (!methodType) {
+          if (__isLifeCycleMethod(prop)) return Reflect.get(target, prop, receiver);
+          const methodName = `__get_${prop}__`;
+          const methodNameMagic = '__get__';
+          const _aopChainsProp = self._getAopChainsProp(beanFullName, beanInstance, methodName, methodNameMagic, 'get', prop);
+          if (!_aopChainsProp) return Reflect.get(target, prop, receiver);
+          // aop
+          return _aopChainsProp([receiver, undefined], ([receiver, _]) => {
+            if (!descriptorInfo && target.__get__) {
+              return Reflect.apply(target.__get__, receiver, [prop, target]);
+            } else {
+              return Reflect.get(target, prop, receiver);
+            }
+          });
+        }
+        // method
+        return self._getInstanceMethodProxy(beanFullName, beanInstance, target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        if (typeof prop === 'symbol') {
+          Reflect.set(target, prop, value, receiver);
+          return true;
+        }
+        if (__isInnerMethod(prop)) {
+          Reflect.set(target, prop, value, receiver);
+          return true;
+        }
+        // descriptorInfo
+        const descriptorInfo = __getPropertyDescriptor(target, prop);
+        if (!__checkAopOfDescriptorInfo(descriptorInfo)) {
+          Reflect.set(target, prop, value, receiver);
+          return true;
+        }
+        const methodName = `__set_${prop}__`;
+        const methodNameMagic = '__set__';
+        const _aopChainsProp = self._getAopChainsProp(beanFullName, beanInstance, methodName, methodNameMagic, 'set', prop);
+        if (!_aopChainsProp) {
+          Reflect.set(target, prop, value, receiver);
+          return true;
+        }
+        // aop
+        return _aopChainsProp([receiver, value], ([receiver, value]) => {
+          if (!descriptorInfo && target.__set__) {
+            const res = Reflect.apply(target.__set__, receiver, [prop, value, target]);
+            if (res === undefined) throw new Error('__set__ must return true/false');
+            if (!res) {
+              Reflect.set(target, prop, value, receiver);
+            }
+          } else {
+            Reflect.set(target, prop, value, receiver);
+          }
+          // ok: prop be set
+          return true;
+        });
+      }
+    });
+  }
+  _getInstanceMethodProxy(beanFullName, beanInstance, target, prop, receiver) {
+    // not aop magic methods
+    if (__isInnerMethod(prop)) {
+      return Reflect.get(target, prop, receiver);
+    }
+    // aop chains
+    const methodNameMagic = '__method__';
+    const _aopChainsProp = this._getAopChainsProp(beanFullName, beanInstance, prop, methodNameMagic, 'method', prop);
+    if (!_aopChainsProp) return Reflect.get(target, prop, receiver);
+    // proxy
+    const methodProxyKey = `__aopproxy_method_${prop}__`;
+    if (target[methodProxyKey]) return target[methodProxyKey];
+    const methodProxy = new Proxy(target[prop], {
+      apply(target, thisArg, args) {
+        // aop
+        return _aopChainsProp([thisArg, args], ([thisArg, args]) => {
+          return Reflect.apply(target, thisArg, args);
+        });
+      }
+    });
+    __setPropertyValue(target, methodProxyKey, methodProxy);
+    return methodProxy;
+  }
+  _prepareAopChains(beanFullNameOrBeanClass, beanInstance) {
+    if (!beanFullNameOrBeanClass) return [];
+    // beanFullName maybe class
+    const beanOptions = appResource.getBean(beanFullNameOrBeanClass);
+    const cacheKey = beanOptions?.beanFullName || beanFullNameOrBeanClass;
+    // ProxyDisable
+    const proxyDisable = beanOptions?.beanClass ? appMetadata.getMetadata(SymbolDecoratorProxyDisable, beanOptions?.beanClass) : false;
+    // host
+    const host = this._aopCacheHost();
+    if (!host[SymbolCacheAopChains]) host[SymbolCacheAopChains] = {};
+    if (host[SymbolCacheAopChains][cacheKey]) return host[SymbolCacheAopChains][cacheKey];
+    // chains
+    let chains = [];
+    // aop
+    if (!proxyDisable && beanOptions && cast(beanOptions.scene) !== 'aop') {
+      const beanAop = this.app.bean._getBean('a-aspectutils.service.aop');
+      const aops = beanAop.findAopsMatched(beanOptions.beanFullName);
+      if (aops) {
+        chains = chains.concat(aops);
+      }
+    }
+    // aop method
+    if (!proxyDisable && beanOptions) {
+      const beanAop = this.app.bean._getBean('a-aspectutils.service.aop');
+      if (beanAop.hasAopMethods(beanOptions?.beanFullName)) {
+        chains.push(SymbolProxyAopMethod);
+      }
+    }
+    // magic self
+    if (__hasMagicMethod(beanInstance)) {
+      chains.push(SymbolProxyMagic);
+    }
+    // hold
+    host[SymbolCacheAopChains][cacheKey] = chains;
+    return chains;
+  }
+  _aopCacheHost() {
+    if (!this.app) throw new Error('Perhaps missing await');
+    return this.app;
+  }
+  _getAopChainsProp(beanFullName, beanInstance, methodName, methodNameMagic, methodType, prop) {
+    const self = this;
+    const chainsKey = `__aopChains_${methodName}__`;
+    const beanOptions = appResource.getBean(beanFullName);
+    const cacheKey = beanOptions?.beanFullName || beanFullName;
+    const host = this._aopCacheHost();
+    if (!host[SymbolCacheAopChainsKey]) host[SymbolCacheAopChainsKey] = {};
+    if (!host[SymbolCacheAopChainsKey][cacheKey]) host[SymbolCacheAopChainsKey][cacheKey] = {};
+    if (host[SymbolCacheAopChainsKey][cacheKey][chainsKey] !== undefined) return host[SymbolCacheAopChainsKey][cacheKey][chainsKey];
+    const _aopChains = this._prepareAopChains(beanFullName, beanInstance);
+    const chains = [];
+    for (const aopKey of _aopChains) {
+      if (aopKey === SymbolProxyMagic) {
+        if (!__isLifeCycleMethod(methodName)) {
+          chains.push([aopKey, methodName]);
+        }
+      } else if (aopKey === SymbolProxyAopMethod) {
+        this._getAopChainsProp_aopMethods(chains, aopKey, beanFullName, methodType, prop);
+      } else {
+        // singleton
+        const aopOuter = self.app.bean._getBean(aopKey);
+        if (aopOuter[methodName]) {
+          let fn;
+          if (methodType === 'get') {
+            fn = function ([receiver, _], next) {
+              const aop = self.app.bean._getBean(aopKey);
+              return aop[methodName](_patchAopNext([receiver, _], next), receiver);
+            };
+          } else if (methodType === 'set') {
+            fn = function ([receiver, value], next) {
+              const aop = self.app.bean._getBean(aopKey);
+              return aop[methodName](value, _patchAopNext([receiver, value], next), receiver);
+            };
+          } else if (methodType === 'method') {
+            fn = function ([receiver, args], next) {
+              const aop = self.app.bean._getBean(aopKey);
+              return aop[methodName](args, _patchAopNext([receiver, args], next), receiver);
+            };
+          }
+          chains.push([aopKey, fn]);
+        }
+        if (methodNameMagic && aopOuter[methodNameMagic]) {
+          if (!__isLifeCycleMethod(methodName)) {
+            let fn;
+            if (methodType === 'get') {
+              fn = function ([receiver, _], next) {
+                const aop = self.app.bean._getBean(aopKey);
+                return aop[methodNameMagic](prop, _patchAopNext([receiver, _], next), receiver);
+              };
+            } else if (methodType === 'set') {
+              fn = function ([receiver, value], next) {
+                const aop = self.app.bean._getBean(aopKey);
+                return aop[methodNameMagic](prop, value, _patchAopNext([receiver, value], next), receiver);
+              };
+            } else if (methodType === 'method') {
+              fn = function ([receiver, args], next) {
+                const aop = self.app.bean._getBean(aopKey);
+                return aop[methodNameMagic](prop, args, _patchAopNext([receiver, args], next), receiver);
+              };
+            }
+            chains.push([aopKey, fn]);
+          }
+        }
+      }
+    }
+    let result;
+    if (chains.length === 0) {
+      result = null;
+    } else {
+      result = __composeForProp(chains);
+    }
+    host[SymbolCacheAopChainsKey][cacheKey][chainsKey] = result;
+    return result;
+  }
+  _getAopChainsProp_aopMethods(chains, aopKey, beanFullName, methodType, prop) {
+    const self = this;
+    const beanAop = this.app.bean._getBean('a-aspectutils.service.aop');
+    const aopMethods = beanAop.findAopMethodsMatched(beanFullName, prop);
+    for (const aopMethod of aopMethods) {
+      let fn;
+      if (methodType === 'get') {
+        fn = function ([receiver, _], next) {
+          const beanInstance = self.app.bean._getBean(aopMethod.beanFullName);
+          if (!beanInstance.get) throw new Error(`get property accessor not exists: ${aopMethod.onionName}`);
+          return beanInstance.get(aopMethod.options, _patchAopNext([receiver, _], next), receiver, prop);
+        };
+      } else if (methodType === 'set') {
+        fn = function ([receiver, value], next) {
+          const beanInstance = self.app.bean._getBean(aopMethod.beanFullName);
+          if (!beanInstance.set) throw new Error(`set property accessor not exists: ${aopMethod.onionName}`);
+          return beanInstance.set(aopMethod.options, value, _patchAopNext([receiver, value], next), receiver, prop);
+        };
+      } else if (methodType === 'method') {
+        fn = function ([receiver, args], next) {
+          const beanInstance = self.app.bean._getBean(aopMethod.beanFullName);
+          if (!beanInstance.execute) throw new Error(`execute method not exists: ${aopMethod.onionName}`);
+          return beanInstance.execute(aopMethod.options, args, _patchAopNext([receiver, args], next), receiver, prop);
+        };
+      }
+      chains.push([aopKey, fn]);
+    }
+  }
+}
+function __composeForPropAdapter(_context, chain) {
+  const [aopKey, fn] = chain;
+  // SymbolProxyMagic
+  if (aopKey === SymbolProxyMagic) return;
+  // chain
+  return {
+    receiver: undefined,
+    fn
+  };
+}
+function __composeForProp(chains) {
+  return compose(chains, __composeForPropAdapter);
+}
+function _patchAopNext([receiver, context], next) {
+  return (...args) => {
+    context = args.length === 0 ? context : args[0];
+    return next([receiver, context]);
+  };
+}
+function __checkAopOfDescriptorInfo(descriptorInfo) {
+  if (!descriptorInfo) return true;
+  return !descriptorInfo.dynamic && !descriptorInfo.ofBeanBase;
+}
+function __getPropertyDescriptor(obj, prop) {
+  // dynamic
+  const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+  if (descriptor) return {
+    descriptor,
+    dynamic: true
+  };
+  // static
+  return __getPropertyDescriptorStatic(obj, prop);
+}
+function __getPropertyDescriptorStatic(obj, prop) {
+  let proto = Object.getPrototypeOf(obj);
+  let ofBeanBase = false;
+  while (proto) {
+    if (proto.constructor.name === BeanBase.name) {
+      ofBeanBase = true;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
+    if (descriptor) return {
+      descriptor,
+      dynamic: false,
+      ofBeanBase
+    };
+    proto = Object.getPrototypeOf(proto);
+  }
+  return null;
+}
+function __setPropertyValue(obj, prop, value) {
+  Object.defineProperty(obj, prop, {
+    enumerable: false,
+    configurable: true,
+    get() {
+      return value;
+    }
+  });
+}
+function __hasMagicMethod(instance) {
+  return !!instance.__get__ || !!instance.__set__;
+}
+function __isInnerMethod(prop) {
+  return ['__get__', '__set__',
+  // '__init__',
+  // '__dispose__',
+  'then', '__v_isShallow', '__v_isReadonly', '__v_raw'].includes(prop);
+}
+function __isLifeCycleMethod(prop) {
+  return ['__init__', '__dispose__'].includes(prop);
+}
+function __methodTypeOfDescriptor(descriptorInfo) {
+  if (!descriptorInfo) return null;
+  const {
+    descriptor,
+    dynamic
+  } = descriptorInfo;
+  if (dynamic) return null;
+  if (descriptor.get) return null;
+  const methodType = descriptor.value?.constructor?.name;
+  if (['Function', 'AsyncFunction'].includes(methodType)) {
+    return methodType;
+  }
+  return null;
+}
+
+// same as _getBean if selector is undefined/null/'', as as to get the same bean instance
+//   not use !selector which maybe is 0
+function __getSelectorKey(beanFullName, withSelector, selector) {
+  if (!withSelector) return beanFullName;
+  const isSelectorValid = !isNilOrEmptyString(selector);
+  return !isSelectorValid ? beanFullName : `${beanFullName}#${selector}`;
+}
+
+const BeanModuleScope$4 = Symbol('BeanScopeError#ModuleScope');
+const BeanErrorCode = Symbol('BeanScopeError#BeanErrorCode');
+class BeanScopeErrorImpl extends BeanSimple {
+  constructor(moduleScope, errorCode) {
+    super();
+    this[BeanModuleScope$4] = void 0;
+    this[BeanErrorCode] = void 0;
+    this[BeanModuleScope$4] = moduleScope;
+    this[BeanErrorCode] = errorCode;
+  }
+  throw(...args) {
+    return this.app.meta.error.throw(this[BeanModuleScope$4], this[BeanErrorCode], ...args);
+  }
+  parseFail(...args) {
+    return this.app.meta.error.parseFail(this[BeanModuleScope$4], this[BeanErrorCode], ...args);
+  }
+}
+
+const BeanModuleScope$3 = Symbol('BeanScopeError#ModuleScope');
+class BeanScopeError extends BeanSimple {
+  constructor(moduleScope) {
+    super();
+    this[BeanModuleScope$3] = void 0;
+    this.__instances = {};
+    this[BeanModuleScope$3] = moduleScope;
+  }
+  __get__(prop) {
+    if (!this.__instances[prop]) {
+      this.__instances[prop] = this.bean._newBean(BeanScopeErrorImpl, this[BeanModuleScope$3], prop);
+    }
+    return this.__instances[prop];
+  }
+}
+
+class ErrorClass extends BeanSimple {
+  constructor(ebErrors) {
+    super();
+    this.ebErrors = void 0;
+    this.ebErrors = ebErrors;
+  }
+
+  // data,code/message,args
+  success(module, data, code, ...args) {
+    const body = this.parseSuccess(module, code, ...args);
+    this.ctx.response.status = 200;
+    this.ctx.response.type = 'application/json';
+    this.ctx.response.body = {
+      code: 0,
+      message: body.message,
+      data
+    };
+  }
+
+  // code/message,args
+  fail(module, code, ...args) {
+    const body = this.parseFail(module, code, ...args);
+    this.ctx.response.status = __calcStatus(body.code);
+    this.ctx.response.type = 'application/json';
+    this.ctx.response.body = {
+      code: body.code,
+      message: body.message
+    }; // body maybe Error
+  }
+
+  // code/message,args
+  throw(module, code, ...args) {
+    const body = this.parseFail(module, code, ...args);
+    const err = new Error();
+    err.code = body.code;
+    err.message = body.message;
+    err.status = __calcStatus(body.code);
+    throw err;
+  }
+
+  // code/message,args
+  parseFail(module, code, ...args) {
+    if (typeof code === 'object') return code;
+    return this.parseCode(module, 500, code, ...args);
+  }
+
+  // code/message,args
+  parseSuccess(module, code, ...args) {
+    return this.parseCode(module, 0, code, ...args);
+  }
+
+  // parseCode
+  parseCode(module, codeDefault, code, ...args) {
+    const ebError = this.ebErrors[module];
+
+    // '403'->403
+    if (typeof code === 'string' && /^\d+$/.test(code)) {
+      code = Number(code);
+    }
+
+    // convert from enum
+    let text;
+    if (ebError && code && typeof code === 'string') {
+      text = code;
+      code = ebError[code];
+    }
+    if (code === undefined || code === null || code === '') {
+      code = codeDefault;
+    }
+    let message;
+    if (typeof code === 'number' && code <= 1000) {
+      message = this.app.meta.locale.getText(true, undefined, undefined, String(code), ...args);
+    } else {
+      message = this.app.meta.locale.getText(false, module, undefined, text || code, ...args);
+    }
+    code = __combineErrorCode(module, code);
+    return {
+      code,
+      message
+    };
+  }
+}
+function __combineErrorCode(module, code) {
+  if (typeof code !== 'number' || code <= 1000) return code;
+  return module ? `${module}:${code}` : code;
+}
+function __calcStatus(code) {
+  return typeof code !== 'string' && code < 1000 ? code : 500;
+}
+
+/* eslint-disable */
+const errorsInternal = {
+  '0': 'Success',
+  '1': 'Unknown Error',
+  '100': 'Continue',
+  '101': 'Switching Protocols',
+  '102': 'Processing',
+  '103': 'Early hints',
+  '200': 'OK',
+  '201': 'Created',
+  '202': 'Accepted',
+  '203': 'Non-Authoritative Information',
+  '204': 'No Content',
+  '205': 'Reset Content',
+  '206': 'Partial Content',
+  '207': 'Multi-Status',
+  '208': 'Already Reported',
+  '226': 'IM Used',
+  '300': 'Multiple Choices',
+  '301': 'Moved Permanently',
+  '302': 'Found',
+  '303': 'See Other',
+  '304': 'Not Modified',
+  '305': 'Use Proxy',
+  '307': 'Temporary Redirect',
+  '308': 'Permanent Redirect',
+  '400': 'Bad Request',
+  '401': 'Unauthorized',
+  '402': 'Payment Required',
+  '403': 'Forbidden',
+  '404': 'Not Found',
+  '405': 'Method Not Allowed',
+  '406': 'Not Acceptable',
+  '407': 'Proxy Authentication Required',
+  '408': 'Request Timeout',
+  '409': 'Conflict',
+  '410': 'Gone',
+  '411': 'Length Required',
+  '412': 'Precondition Failed',
+  '413': 'Payload Too Large',
+  '414': 'URI Too Long',
+  '415': 'Unsupported Media Type',
+  '416': 'Range Not Satisfiable',
+  '417': 'Expectation Failed',
+  '418': "I'm a teapot",
+  '421': 'Misdirected Request',
+  '422': 'Unprocessable Entity',
+  '423': 'Locked',
+  '424': 'Failed Dependency',
+  '425': 'Too Early',
+  '426': 'Upgrade Required',
+  '428': 'Precondition Required',
+  '429': 'Too Many Requests',
+  '431': 'Request Header Fields Too Large',
+  '451': 'Unavailable For Legal Reasons',
+  '500': 'Internal Server Error',
+  '501': 'Not Implemented',
+  '502': 'Bad Gateway',
+  '503': 'Service Unavailable',
+  '504': 'Gateway Timeout',
+  '505': 'HTTP Version Not Supported',
+  '506': 'Variant Also Negotiates',
+  '507': 'Insufficient Storage',
+  '508': 'Loop Detected',
+  '509': 'Bandwidth Limit Exceeded',
+  '510': 'Not Extended',
+  '511': 'Network Authentication Required'
+};
+
+const LocaleModuleNameSeparator = '::';
+
+class AppLocale extends BeanSimple {
+  get current() {
+    return this.ctx.locale;
+  }
+  set current(value) {
+    this.ctx.locale = value;
+  }
+  get tz() {
+    return this.ctx.tz;
+  }
+  set tz(value) {
+    this.ctx.tz = value;
+  }
+
+  /** @internal */
+  createLocaleText(moduleScope) {
+    const self = this;
+    const getText = function (text, ...args) {
+      return self.getText(false, moduleScope, undefined, text, ...args);
+    };
+    getText.locale = function (locale, text, ...args) {
+      return self.getText(false, moduleScope, locale, text, ...args);
+    };
+    return getText;
+  }
+
+  /** @internal */
+  createScopeLocaleText(moduleScope, text) {
+    const self = this;
+    const getText = function (...args) {
+      return self.getText(false, moduleScope, undefined, text, ...args);
+    };
+    getText.locale = function (locale, ...args) {
+      return self.getText(false, moduleScope, locale, text, ...args);
+    };
+    return getText;
+  }
+  getText(supportCustomMessage, moduleScope, locale, key, ...args) {
+    if (!key) return key;
+    if (typeof key !== 'string') throw new Error(`${key} should be string`);
+    const pos = key.indexOf(LocaleModuleNameSeparator);
+    if (pos > -1) {
+      moduleScope = key.substring(0, pos);
+      key = key.substring(pos + LocaleModuleNameSeparator.length);
+    }
+    return localeutil.getLocaleText(supportCustomMessage, moduleScope ? this.app.meta.localeModules[moduleScope] : undefined, this.app.meta.locales, locale || this.current, key, ...args);
+  }
+}
+
+const BeanModuleScope$2 = Symbol('BeanScopeLocale#ModuleScope');
+class BeanScopeLocale extends BeanSimple {
+  constructor(moduleScope) {
+    super();
+    this[BeanModuleScope$2] = void 0;
+    this.__instances = {};
+    this[BeanModuleScope$2] = moduleScope;
+  }
+  __get__(prop) {
+    if (!this.__instances[prop]) {
+      this.__instances[prop] = this.app.meta.locale.createScopeLocaleText(this[BeanModuleScope$2], prop);
+    }
+    return this.__instances[prop];
+  }
+}
+
+function $localeScope(moduleName, key) {
+  return `${moduleName}::${String(key)}`;
+}
+
+const BeanModuleScope$1 = Symbol('BeanScopeScene#ModuleScope');
+const BeanModuleScene = Symbol('BeanScopeScene#BeanModuleScene');
+class BeanScopeScene extends BeanSimple {
+  constructor(moduleScope, scene) {
+    super();
+    this[BeanModuleScope$1] = void 0;
+    this[BeanModuleScene] = void 0;
+    this.__instances = {};
+    this[BeanModuleScope$1] = moduleScope;
+    this[BeanModuleScene] = scene;
+  }
+  __get__(prop) {
+    if (!this.__instances[prop]) {
+      const beanFullName = `${this[BeanModuleScope$1]}.${this[BeanModuleScene]}.${prop}`;
+      this.__instances[prop] = this.bean._injectBeanInstanceProp(this, beanFullName, {});
+    }
+    return this.__instances[prop];
+  }
+}
+
+const BeanModuleScope = Symbol('BeanScopeScene#ModuleScope');
+class BeanScopeUtil extends BeanSimple {
+  constructor(moduleScope) {
+    super();
+    this[BeanModuleScope] = void 0;
+    this[BeanModuleScope] = moduleScope;
+  }
+  combineApiPath(path, prefix, simplify) {
+    return this.app.util.combineApiPath(path, this[BeanModuleScope], prefix, simplify);
+  }
+  combineResourceName(resourceName, simplify, simplifyProviderId) {
+    return this.app.util.combineResourceName(resourceName, this[BeanModuleScope], simplify, simplifyProviderId);
+  }
+  combineStaticPath(path) {
+    return this.app.util.combineStaticPath(path, this[BeanModuleScope]);
+  }
+}
+
+const BeanModuleError = Symbol('BeanScopeBase#BeanModuleError');
+const BeanModuleLocale = Symbol('BeanScopeBase#BeanModuleLocale');
+const BeanModuleUtil = Symbol('BeanScopeBase#BeanModuleUtil');
+const BeanModuleModel = Symbol('BeanScopeBase#BeanModuleModel');
+const BeanModuleEntity = Symbol('BeanScopeBase#BeanModuleEntity');
+class BeanScopeBase extends BeanBaseSimple {
+  constructor(...args) {
+    super(...args);
+    this[BeanModuleError] = void 0;
+    this[BeanModuleLocale] = void 0;
+    this[BeanModuleUtil] = void 0;
+    this[BeanModuleModel] = void 0;
+    this[BeanModuleEntity] = void 0;
+    this.__onionMetaNames = void 0;
+    this.__scenes = {};
+    this.__metas = {};
+  }
+  get module() {
+    return this.app.meta.modules[this[SymbolModuleBelong]];
+  }
+  get onionMetaNames() {
+    if (!this.__onionMetaNames) {
+      this.__onionMetaNames = {};
+      const onionMetasMeta = getOnionMetasMeta(this.app.meta.modules);
+      for (const metaName in onionMetasMeta) {
+        const onionMetaMeta = onionMetasMeta[metaName];
+        if (onionMetaMeta.scopeResource) {
+          this.__onionMetaNames[metaName] = true;
+        }
+      }
+    }
+    return this.__onionMetaNames;
+  }
+  __get__(prop) {
+    const moduleBelong = this[SymbolModuleBelong];
+    // error
+    if (prop === 'error') {
+      if (!this[BeanModuleError]) {
+        this[BeanModuleError] = this.bean._newBean(BeanScopeError, moduleBelong);
+      }
+      return this[BeanModuleError];
+    }
+    // locale
+    if (prop === 'locale') {
+      if (!this[BeanModuleLocale]) {
+        this[BeanModuleLocale] = this.bean._newBean(BeanScopeLocale, moduleBelong);
+      }
+      return this[BeanModuleLocale];
+    }
+    // config
+    if (prop === 'config') {
+      // app or ctx
+      const config = this.ctx?.config ?? this.app.config;
+      return config.modules[moduleBelong];
+    }
+    // constant
+    if (prop === 'constant') {
+      return this.app.meta.constants[moduleBelong];
+    }
+    // util
+    if (prop === 'util') {
+      if (!this[BeanModuleUtil]) {
+        this[BeanModuleUtil] = this.bean._newBean(BeanScopeUtil, moduleBelong);
+      }
+      return this[BeanModuleUtil];
+    }
+    // model
+    if (prop === 'model') {
+      if (!this[BeanModuleModel]) {
+        this[BeanModuleModel] = this.bean._newBean('a-orm.service.modelResolver', moduleBelong);
+      }
+      return this[BeanModuleModel];
+    }
+    // entity
+    if (prop === 'entity') {
+      if (!this[BeanModuleEntity]) {
+        this[BeanModuleEntity] = this.bean._newBean('a-orm.service.entityResolver', moduleBelong);
+      }
+      return this[BeanModuleEntity];
+    }
+    // meta
+    if (this.onionMetaNames[prop]) {
+      if (!this.__metas[prop]) {
+        this.__metas[prop] = this.bean._getBean(`${moduleBelong}.meta.${prop}`);
+      }
+      return this.__metas[prop];
+    }
+    // scene
+    if (!this.__scenes[prop]) {
+      this.__scenes[prop] = this.bean._newBean(BeanScopeScene, moduleBelong, prop);
+    }
+    return this.__scenes[prop];
+  }
+}
+
+class BeanScopeContainer extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this.__instances = {};
+  }
+  __get__(prop) {
+    if (!this.__instances[prop]) {
+      let moduleName = splitWords(prop, true, '-');
+      if (!moduleName?.includes('-')) {
+        moduleName = `a-${moduleName}`;
+      }
+      this.__instances[prop] = this.bean.scope(moduleName);
+    }
+    return this.__instances[prop];
+  }
+}
+
+class VonaAsyncLocalStorage extends AsyncLocalStorage {
+  constructor(app) {
+    super();
+    this.app = void 0;
+    this.app = app;
+  }
+  async run(store, callback, ...args) {
+    if (store === this.app.currentContext) {
+      return await callback(...args);
+    }
+    return super.run(store, async (...args) => {
+      try {
+        this.app.meta.ctxCounter.increment();
+        return await callback(...args);
+      } finally {
+        await store.bean.dispose();
+        this.app.meta.ctxCounter.decrement();
+      }
+    }, ...args);
+  }
+}
+
+const BEAN = Symbol.for('Context#__bean');
+const INNERACCESS = Symbol.for('Context#__inneraccess');
+const CTXCALLER = Symbol.for('Context#__ctxcaller');
+const ONIONSDYNAMIC = Symbol.for('Context#__onionsdynamic');
+const contextBase = {
+  get bean() {
+    const self = cast(this);
+    if (!self[BEAN]) {
+      self[BEAN] = BeanContainer.create(self.app, self);
+    }
+    return self[BEAN];
+  },
+  get locale() {
+    const self = cast(this);
+    return self.__getLocale();
+  },
+  set locale(value) {
+    const self = cast(this);
+    self.__setLocale(value);
+  },
+  get tz() {
+    const self = cast(this);
+    return self.__getTz();
+  },
+  set tz(value) {
+    const self = cast(this);
+    self.__setTz(value);
+  },
+  get instanceName() {
+    const self = cast(this);
+    return self.__getInstanceName();
+  },
+  set instanceName(value) {
+    const self = cast(this);
+    self.__setInstanceName(value);
+  },
+  get config() {
+    const self = cast(this);
+    const serviceInstance = cast(self.app.bean._getBean('a-instance.service.instance'));
+    return serviceInstance.getConfig(self.instanceName) || self.app.config;
+  },
+  get innerAccess() {
+    return this[INNERACCESS];
+  },
+  set innerAccess(value) {
+    this[INNERACCESS] = value;
+  },
+  get ctxCaller() {
+    return this[CTXCALLER];
+  },
+  set ctxCaller(value) {
+    this[CTXCALLER] = value;
+  },
+  getController() {
+    const self = cast(this);
+    return self.route?.controller;
+  },
+  getControllerPrototype() {
+    const self = cast(this);
+    const controller = self.getController();
+    if (!controller) return undefined;
+    return controller.prototype;
+  },
+  getControllerBean() {
+    const self = cast(this);
+    const beanFullName = self.getControllerBeanFullName();
+    if (!beanFullName) return;
+    return self.app.bean._getBean(beanFullName);
+  },
+  getControllerBeanFullName() {
+    const self = cast(this);
+    const controller = self.getController();
+    if (!controller) return undefined;
+    const beanOptions = appResource.getBean(controller);
+    return beanOptions?.beanFullName;
+  },
+  getHandler() {
+    const self = cast(this);
+    return self.route?.actionDescriptor?.value;
+  },
+  getHandlerName() {
+    const self = cast(this);
+    return self.route?.action;
+  },
+  get onionsDynamic() {
+    return this[ONIONSDYNAMIC];
+  },
+  set onionsDynamic(value) {
+    this[ONIONSDYNAMIC] = value;
+  },
+  get acceptJSON() {
+    const self = cast(this);
+    if (self.path.endsWith('.json')) return true;
+    if (self.response.type && self.response.type.includes('json')) return true;
+    if (self.request.headers['content-type']?.includes('application/json') && self.accepts('json') === 'json') return true;
+    if (self.accepts('html', 'text', 'json') === 'json') return true;
+    return false;
+  },
+  redirect(url, status) {
+    const self = cast(this);
+    // checkOrigin
+    if (!url.startsWith('/')) {
+      const origin = cast(self.app.bean).security.checkOrigin(url, self.host);
+      if (!origin) self.app.throw(403);
+    }
+    // throw
+    status = status ?? 302;
+    self.app.throw(status, url);
+  }
+};
+
+class CtxCounter {
+  constructor() {
+    this._ctxCounter = 0;
+  }
+  get current() {
+    return this._ctxCounter;
+  }
+  increment() {
+    return ++this._ctxCounter;
+  }
+  decrement() {
+    return --this._ctxCounter;
+  }
+  async awaitUntilZero() {
+    while (true) {
+      if (this.current === 0) break;
+      await sleep(200);
+    }
+  }
+}
+
+const SymbolHmrStateSave = Symbol('SymbolHmrStateSave');
+const SymbolHmrStateLoad = Symbol('SymbolHmrStateLoad');
+class AppHmr extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this.recordBeanInstances = {};
+    this.recordBeanInstanceProps = {};
+  }
+  addBeanInstance(beanFullName, beanInstanceKey, args, withSelector) {
+    if (!this.recordBeanInstances[beanFullName]) {
+      this.recordBeanInstances[beanFullName] = [];
+    }
+    this.recordBeanInstances[beanFullName].push({
+      beanInstanceKey,
+      withSelector,
+      args
+    });
+  }
+  addBeanInstanceProp(beanInstance, prop, targetBeanFullName) {
+    if (!this.recordBeanInstanceProps[targetBeanFullName]) {
+      this.recordBeanInstanceProps[targetBeanFullName] = [];
+    }
+    this.recordBeanInstanceProps[targetBeanFullName].push({
+      beanInstance,
+      prop
+    });
+  }
+  mutateBeanInstance(beanFullName, beanInstanceKey, args) {
+    const beanInstances = this.recordBeanInstances[beanFullName];
+    if (!beanInstances) return;
+    const beanInstance = beanInstances.find(item => item.beanInstanceKey === beanInstanceKey);
+    if (!beanInstance) return;
+    beanInstance.args = args;
+  }
+}
+
+const SymbolLoggerInstances = Symbol('SymbolLoggerInstances');
+class AppLogger extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this[SymbolLoggerInstances] = {};
+  }
+  async dispose() {
+    for (const key in this[SymbolLoggerInstances]) {
+      const logger = this[SymbolLoggerInstances][key];
+      await _closeLogger(logger);
+    }
+  }
+  get(clientName) {
+    clientName = clientName || 'default';
+    if (!this[SymbolLoggerInstances][clientName]) {
+      this[SymbolLoggerInstances][clientName] = this._createClient(clientName);
+    }
+    return this[SymbolLoggerInstances][clientName];
+  }
+  child(childName, clientName) {
+    const logger = this.get(clientName);
+    if (!childName) return logger;
+    return logger.child({
+      name: childName
+    });
+  }
+  getLevel(clientName) {
+    clientName = clientName || 'default';
+    const envName = `LOGGER_CLIENT_${clientName.toUpperCase()}`;
+    const level = this.app.meta.env[envName];
+    if (level === 'false') return false;
+    if (level === 'true' || !level) return 'info';
+    return level;
+  }
+  setLevel(level, clientName) {
+    clientName = clientName || 'default';
+    const envName = `LOGGER_CLIENT_${clientName.toUpperCase()}`;
+    this.app.meta.env[envName] = level.toString();
+  }
+  _createClient(clientName) {
+    const configClient = this.app.config.logger.clients[clientName];
+    if (!configClient) throw new Error(`logger client not found: ${clientName}`);
+    const configNode = deepExtend({}, this._prepareConfigClient(clientName, this.app.config.logger.base), this._prepareConfigClient(clientName, configClient));
+    const logger = Winston.createLogger(configNode);
+    logger.on('error', err => {
+      console.error(err);
+    });
+    return logger;
+  }
+  _prepareConfigClient(clientName, configClient) {
+    if (typeof configClient !== 'function') return configClient;
+    return configClient.call(this.app, {
+      clientName,
+      level: () => this.getLevel(clientName)
+    }, Winston);
+  }
+  createTransportFile(fileName, clientInfo, options) {
+    const dirname = this.app.config.logger.baseDir;
+    if (!fse.existsSync(dirname)) {
+      const [_, err] = catchErrorSync(() => {
+        fse.ensureDirSync(dirname);
+      });
+      if (err) {
+        throw new Error(`Failed to create logger dir: ${dirname}`);
+      }
+    }
+    const configRotate = this.app.config.logger.rotate.call(this, fileName, Winston, clientInfo);
+    let optionsFile;
+    if (configRotate.enable) {
+      optionsFile = configRotate;
+    } else {
+      optionsFile = Object.assign({}, {
+        filename: `${fileName}.log`
+      }, configRotate);
+    }
+    const _options = deepExtend({
+      dirname
+    }, optionsFile, options);
+    if (configRotate.enable) {
+      const transport = new DailyRotateFile(_options);
+      transport.on('error', err => {
+        console.error(err);
+      });
+      return transport;
+    } else {
+      return new Winston.transports.File(_options);
+    }
+  }
+}
+async function _closeLogger(logger) {
+  return new Promise(resolve => {
+    if (logger.__closed__) return resolve(true);
+    logger.end(() => {
+      logger.__closed__ = true;
+      resolve(true);
+    });
+  });
+}
+
+const SymbolClosePromise = Symbol('SymbolClosePromise');
+class AppMeta extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this.env = void 0;
+    this.ctxCounter = void 0;
+    this.isProd = void 0;
+    this.isTest = void 0;
+    this.isDev = void 0;
+    this.isLocal = void 0;
+    this.error = void 0;
+    this.logger = void 0;
+    this.locale = void 0;
+    this.hmr = void 0;
+    this.text = void 0;
+    this.scopeContainer = void 0;
+    this.appMonkey = void 0;
+    //
+    this.resource = void 0;
+    this.metadata = void 0;
+    //
+    this.modules = void 0;
+    this.modulesArray = void 0;
+    this.modulesMonkey = void 0;
+    //
+    this.constants = void 0;
+    this.locales = void 0;
+    this.localeModules = void 0;
+    //
+    this.hmrCacheLocaleModules = void 0;
+    this.hmrCacheConfigModules = void 0;
+    //
+    this.appReady = void 0;
+    this.appReadyInstances = void 0;
+    //
+    this.appStarted = void 0;
+    this.appStartError = void 0;
+    //
+    this.appClose = void 0;
+    this.appClosed = void 0;
+  }
+  __init__(env) {
+    // env
+    this.env = env;
+    this._prepareEnv();
+
+    // ctxCounter
+    this.ctxCounter = new CtxCounter();
+
+    // appMonkey
+    this.appMonkey = this.app.options.AppMonkey ? new this.app.options.AppMonkey() : undefined;
+
+    // logger
+    this.logger = this.bean._newBean(AppLogger);
+
+    // locale
+    this.locale = this.bean._newBean(AppLocale);
+
+    // hmr
+    if (process.env.META_MODE === 'dev') {
+      this.hmr = this.bean._newBean(AppHmr);
+    }
+
+    // text
+    this.text = this.locale.createLocaleText();
+
+    // scopeContainer
+    this.scopeContainer = this.bean._newBean(BeanScopeContainer);
+
+    // resource
+    this.resource = appResource;
+    this.resource.app = this.app;
+
+    // metadata
+    this.metadata = appMetadata;
+  }
+  _prepareEnv() {
+    const mode = this.app.configMeta.mode;
+    this.isProd = mode === 'prod';
+    this.isTest = mode === 'test';
+    this.isDev = mode === 'dev';
+    this.isLocal = this.isTest || this.isDev;
+  }
+  async waitAppStarted() {
+    return new Promise((resolve, reject) => {
+      // check once
+      if (this.appStarted) {
+        resolve(true);
+      }
+      if (this.appStartError) {
+        reject(this.appStartError);
+      }
+      // listen
+      this.app.once(EnumAppEvent.AppStarted, () => {
+        resolve(true);
+      });
+      this.app.once(EnumAppEvent.AppStartError, err => {
+        reject(err);
+      });
+    });
+  }
+  async close() {
+    if (!this[SymbolClosePromise]) {
+      this[SymbolClosePromise] = this._closeInner();
+    }
+    return this[SymbolClosePromise];
+  }
+  async _closeInner() {
+    // should not call disconnect, which will cause channel closed
+    // cluster.worker?.disconnect();
+    // close server
+    if (this.app.server) {
+      this.app.server.close();
+      // maybe hang up using await
+      // await promisify(this.app.server.close).call(this.app.server);
+    }
+    // appClose
+    this.appClose = true;
+    // hook: appClose
+    await this.app.util.monkeyModule(this.app.meta.appMonkey, this.app.meta.modulesMonkey, 'appClose');
+    // ctx counter
+    await this.app.meta.ctxCounter.awaitUntilZero();
+    // appClosed
+    this.appClosed = true;
+    // hook: appClosed
+    await this.app.util.monkeyModule(this.app.meta.appMonkey, this.app.meta.modulesMonkey, 'appClosed');
+    // container dispose
+    await this.app.bean.dispose();
+    // logger dispose
+    await this.app.meta.logger.dispose();
+    // log
+    if (this.app.meta.env.LOGGER_DUMMY !== 'true') {
+      const message = `App shutdown gracefully: ${process.pid}`;
+      // eslint-disable-next-line
+      console.log(chalk.cyan(message));
+    }
+    // need not call process.exit
+  }
+}
+
+class ResponseMock {
+  constructor() {
+    this._headers = {};
+  }
+  getHeader(field) {
+    return this._headers[field];
+  }
+  setHeader(field, val) {
+    this._headers[field] = val;
+  }
+  hasHeader(field) {
+    return this._headers[field] !== undefined;
+  }
+  removeHeader(field) {
+    delete this._headers[field];
+  }
+}
+
+class VonaApplication extends KoaApplication {
+  constructor(options) {
+    const env = options.env;
+    const koaOptions = {
+      env: cast(env).NODE_ENV,
+      asyncLocalStorage: false
+    };
+    super(koaOptions);
+    this.options = void 0;
+    this.config = void 0;
+    this.bean = void 0;
+    this.util = void 0;
+    this.meta = void 0;
+    this.server = void 0;
+    this.ctxStorage = void 0;
+    this.options = options;
+    this.bean = BeanContainer.create(this, undefined);
+    this.util = this.bean._newBean(AppUtil);
+    this.meta = this.bean._newBean(AppMeta, env);
+    // asyncLocalStorage
+    this.ctxStorage = new VonaAsyncLocalStorage(this);
+    // app.context
+    for (const key of Reflect.ownKeys(contextBase)) {
+      const desc = Object.getOwnPropertyDescriptor(contextBase, key);
+      Object.defineProperty(this.context, key, desc);
+    }
+  }
+  get name() {
+    return this.options.name;
+  }
+  get projectPath() {
+    return this.options.projectPath;
+  }
+  get configMeta() {
+    return this.options.configMeta;
+  }
+  get ctx() {
+    return this.currentContext;
+  }
+
+  /** get specific module's scope */
+
+  // scope<T>(moduleScope: string): T;
+  scope(moduleScope) {
+    return this.bean.scope(moduleScope);
+  }
+  createAnonymousContext(req, res) {
+    let request;
+    if (req) {
+      request = req;
+    } else {
+      const host = `localhost:${this.meta.env.SERVER_LISTEN_PORT}`;
+      request = {
+        headers: {
+          'host': host,
+          'x-forwarded-for': host
+        },
+        query: {},
+        querystring: '',
+        host,
+        hostname: 'localhost',
+        protocol: 'http',
+        secure: 'false',
+        method: 'POST',
+        url: '',
+        path: '',
+        socket: {
+          remoteAddress: '127.0.0.1',
+          remotePort: 7001
+        }
+      };
+    }
+    const response = res ?? new ResponseMock();
+    return this.createContext(request, response);
+  }
+  async close(terminate) {
+    await closeApp(terminate);
+  }
+}
+
+async function combineConfigDefault(app, configDefault, configDev, configProd, configTest) {
+  let config = await configDefault(app);
+  const mode = app.config.meta.mode;
+  if (mode === 'dev' && configDev) {
+    config = deepExtend(config, await configDev(app));
+  } else if (mode === 'prod' && configProd) {
+    config = deepExtend(config, await configProd(app));
+  } else if (mode === 'test' && configTest) {
+    config = deepExtend(config, await configTest(app));
+  }
+  return config;
+}
+function getLoggerPathPhysicalRoot(app) {
+  const mode = app.configMeta.mode;
+  let loggerDir;
+  if (mode === 'test' || mode === 'dev') {
+    loggerDir = path.join(app.projectPath, '.app/logs');
+  } else {
+    loggerDir = path.join(os.homedir(), 'vona', app.name, 'logs');
+  }
+  fse.ensureDirSync(loggerDir);
+  return loggerDir;
+}
+function getPublicPathPhysicalRoot(app) {
+  const mode = app.configMeta.mode;
+  let publicDir;
+  if (mode === 'test' || mode === 'dev') {
+    publicDir = path.join(app.projectPath, '.app/public');
+  } else {
+    publicDir = path.join(os.homedir(), 'vona', app.name, 'public');
+  }
+  fse.ensureDirSync(publicDir);
+  return publicDir;
+}
+function getRuntimePathPhysicalRoot(app) {
+  const mode = app.config.meta.mode;
+  let runtimeDir;
+  if (mode === 'test' || mode === 'dev') {
+    runtimeDir = path.join(app.options.projectPath, '.app/runtime');
+  } else {
+    runtimeDir = path.join(os.homedir(), 'vona', app.options.name, 'runtime');
+  }
+  fse.ensureDirSync(runtimeDir);
+  return runtimeDir;
+}
+
+var enUs = {
+  ...errorsInternal,
+  ValidationFailedDev: 'controller: %s, method: %s, argument: %d'
+};
+
+var zhCn = {
+  ValidationFailedDev: '控制器: %s, 方法: %s, 参数: %d',
+  // http status
+  0: '成功',
+  1: '未知错误',
+  100: '继续',
+  101: '切换协议',
+  102: '处理中',
+  103: '早期线索',
+  200: '成功',
+  201: '已创建',
+  202: '已接受',
+  203: '非认证信息',
+  204: '没有内容',
+  205: '重置内容',
+  206: '部分内容',
+  207: '多状态',
+  208: '已报告',
+  226: 'IM_Used',
+  300: '多选择',
+  301: '永久转移',
+  302: '已发现',
+  303: '参考其他',
+  304: '未变更',
+  305: '使用代理',
+  307: '临时转向',
+  308: '永久转向',
+  400: '无效请求',
+  401: '未经认证',
+  402: '需要支付',
+  403: '访问被禁止',
+  404: '未发现',
+  405: '方法不允许',
+  406: '不可接受',
+  407: '需要代理认证',
+  408: '请求超时',
+  409: '冲突',
+  410: '已失效',
+  411: '需要指定长度',
+  412: '条件不匹配',
+  413: '载荷过大',
+  414: 'URL地址太长',
+  415: '不支持的媒体类型',
+  416: '请求的范围不匹配',
+  417: '期望值不匹配',
+  418: '我是一个茶壶',
+  421: '无效转向',
+  422: '无法处理的内容',
+  423: '已锁定',
+  424: '依赖失败',
+  425: '太早',
+  426: '需要升级',
+  428: '需要指定条件',
+  429: '请求太多',
+  431: '请求头部字段太大',
+  451: '由于法律原因无法使用',
+  500: '内部服务错误',
+  501: '没有实现',
+  502: '无效网关',
+  503: '服务无法访问',
+  504: '网关超时',
+  505: 'HTTP版本不支持',
+  506: '变量需要协商',
+  507: '存储空间不足',
+  508: '检测到无限循环',
+  509: '超过带宽限制',
+  510: '未扩展',
+  511: '需要网络认证'
+};
+
+var localesDefault = {
+  'en-us': enUs,
+  'zh-cn': zhCn
+};
+
+const SymbolLoggerMessage = Symbol('SymbolLoggerMessage');
+const formatLoggerAxiosError = Winston.format((einfo, {
+  stack,
+  cause
+}) => {
+  if (einfo instanceof Error && einfo.constructor.name.includes('AxiosError') || einfo.name === 'AxiosError') {
+    const info = Object.assign({}, einfo, {
+      level: einfo.level,
+      [LEVEL]: einfo[LEVEL] || einfo.level,
+      message: einfo.message,
+      [MESSAGE]: einfo[MESSAGE] || einfo.message
+    });
+    if (stack) info.stack = einfo.stack;
+    if (cause) info.cause = einfo.cause;
+    info.message = `${info.message}: ${cast(info.config).url}`;
+    info[MESSAGE] = `${info[MESSAGE]}: ${cast(info.config).url}`;
+    delete info.config;
+    delete info.request;
+    delete info.response;
+    return info;
+  }
+  return einfo;
+});
+const formatLoggerCtx = Winston.format((info, _opts) => {
+  const app = useApp();
+  if (!app.ctx || !app.ctx.method || !app.ctx.path) return info;
+  info.method = app.ctx.method;
+  info.path = app.ctx.path;
+  return info;
+});
+const formatLoggerDummy = Winston.format(info => {
+  const app = useApp();
+  if (app.meta.env.LOGGER_DUMMY === 'true') return false;
+  return info;
+});
+const formatLoggerFilter = Winston.format((info, opts) => {
+  const level = typeof opts.level === 'function' ? opts.level() : opts.level;
+  if (!level) return false;
+  if (opts.strict) {
+    if (Winston.config.npm.levels[info.level] === Winston.config.npm.levels[level]) return __formatLoggerFilterCheckInfo(info);
+    return false;
+  }
+  if (Winston.config.npm.levels[info.level] <= Winston.config.npm.levels[level] || opts.silly && info.level === 'silly') return __formatLoggerFilterCheckInfo(info);
+  return false;
+});
+const formatLoggerConsole = clientInfo => {
+  return Winston.format.printf(({
+    timestamp,
+    level,
+    stack,
+    message,
+    name,
+    beanFullName,
+    durationMs,
+    ...meta
+  }) => {
+    const textClientName = clientInfo.clientName === 'default' ? '' : ` ${chalk.cyan(`[${clientInfo.clientName}]`)}`;
+    const textName = name ? ` ${chalk.cyan(`[${name}]`)}` : '';
+    const textBeanFullName = beanFullName ? ` ${chalk.gray(`[${beanFullName}]`)}` : '';
+    const textMeta = !isEmptyObject(meta) ? ` ${JSON.stringify(meta)}` : '';
+    const textMessage = ` ${message}`;
+    const textDurationMs = durationMs !== undefined ? ` ${chalk.cyan(`+${durationMs}ms`)}` : '';
+    const textStack = stack ? `\n${stack}` : '';
+    return `${timestamp} ${level}${textClientName}${textName}${textBeanFullName}${textMeta}${textMessage}${textDurationMs}${textStack}`;
+  });
+};
+function __formatLoggerFilterCheckInfo(info) {
+  if (typeof info.message === 'function') {
+    if (info.message[SymbolLoggerMessage] === undefined) {
+      info.message[SymbolLoggerMessage] = info.message();
+    }
+    info.message = info.message[SymbolLoggerMessage];
+  }
+  return info;
+}
+
+async function loadConfig (app, modules) {
+  app.meta.hmrCacheConfigModules = deepExtend({}, app.config.modules);
+  // load configs
+  await loadConfigs();
+  async function loadConfigs() {
+    for (const key in modules) {
+      const module = modules[key];
+      // module config
+      if (module.resource.config) {
+        const configModule = await module.resource.config(app, app.options.env);
+        // configNew is not used by now
+        await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'configLoaded', module, configModule);
+        app.config.modules[module.info.relativeName] = deepExtend({}, configModule, app.config.modules[module.info.relativeName]);
+      }
+    }
+  }
+}
+
+function loadConstants (app, modules) {
+  // all constants
+  const ebConstants = app.meta.constants = {};
+
+  // load constants
+  loadConstants();
+  function loadConstants() {
+    for (const key in modules) {
+      const module = modules[key];
+      const ebConstant = ebConstants[module.info.relativeName] = {};
+
+      // module constants
+      if (module.resource.constants) deepExtend(ebConstant, module.resource.constants);
+    }
+  }
+}
+
+function loadErrors (app, modules) {
+  // all errors
+  const ebErrors = {};
+
+  // load errors
+  loadErrors();
+
+  // patch Error
+  patchError();
+  function patchError() {
+    // error
+    app.meta.error = app.bean._newBean(ErrorClass, ebErrors);
+
+    // methods
+    ['success', 'fail', 'throw', 'parseFail', 'parseSuccess', 'parseCode'].forEach(key => {
+      app[key] = function (...args) {
+        return app.meta.error[key](undefined, ...args);
+      };
+    });
+  }
+  function loadErrors() {
+    for (const key in modules) {
+      const module = modules[key];
+      const ebError = ebErrors[module.info.relativeName] = {};
+
+      // module errors
+      if (module.resource.errors) deepExtend(ebError, module.resource.errors);
+    }
+  }
+}
+
+async function loadLocales (app, modules) {
+  // all locales
+  app.meta.locales = localesDefault;
+  app.meta.localeModules = {};
+
+  // load locales
+  await loadLocales();
+  async function loadLocales() {
+    const locales = (await app.options.locales()).locales;
+    // project locales
+    for (const locale in locales) {
+      _initLocales(locale, locales[locale]);
+    }
+    // app cache
+    app.meta.hmrCacheLocaleModules = deepExtend({}, app.meta.localeModules);
+    // module locales
+    for (const moduleName in modules) {
+      const module = modules[moduleName];
+      _registerLocales(moduleName, module.resource.locales);
+    }
+  }
+  function _initLocales(locale, locales) {
+    if (!locales) return;
+    if (!locales.modules) {
+      // override
+      app.meta.locales[locale] = Object.assign({}, app.meta.locales[locale], locales);
+    } else {
+      const moduleMap = locales.modules;
+      for (const moduleName in moduleMap) {
+        _registerLocale(moduleName, locale, moduleMap[moduleName]);
+      }
+    }
+  }
+  function _registerLocales(moduleName, locales) {
+    if (!locales) return;
+    for (const locale in locales) {
+      _registerLocale(moduleName, locale, locales[locale]);
+    }
+  }
+  function _registerLocale(moduleName, locale, moduleLocales) {
+    // locales: not override
+    app.meta.locales[locale] = Object.assign({}, moduleLocales, app.meta.locales[locale]);
+    // localeModules
+    if (!app.meta.localeModules[moduleName]) app.meta.localeModules[moduleName] = {};
+    app.meta.localeModules[moduleName][locale] = Object.assign({}, moduleLocales, app.meta.localeModules[moduleName][locale]);
+  }
+}
+
+class ModuleTools extends BeanSimple {
+  async prepare() {
+    const app = this.app;
+    const modulesMeta = await app.options.modulesMeta();
+    const modules = modulesMeta.modulesMeta.modules;
+    const modulesArray = modulesMeta.modulesMeta.moduleNames.map(relativeName => modules[relativeName]);
+    app.meta.modules = modules;
+    app.meta.modulesArray = modulesArray;
+    app.meta.modulesMonkey = {};
+    return modules;
+  }
+  async load() {
+    const app = this.app;
+    // main / monkey
+    for (const module of app.meta.modulesArray) {
+      if (module.resource.Main) {
+        module.mainInstance = app.bean._newBean(module.resource.Main, module);
+      }
+      if (module.resource.Monkey) {
+        module.monkeyInstance = app.bean._newBean(module.resource.Monkey, module);
+        app.meta.modulesMonkey[module.info.relativeName] = module;
+      }
+    }
+  }
+  async monkey(monkeyName) {
+    const app = this.app;
+    for (const module of app.meta.modulesArray) {
+      await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, monkeyName, module);
+    }
+  }
+}
+
+class ModuleLoader extends BeanSimple {
+  async execute() {
+    const app = this.app;
+    // modules
+    const moduleTools = app.bean._newBean(ModuleTools);
+    // prepare
+    const modules = await moduleTools.prepare();
+    // load modules
+    await moduleTools.load();
+    // monkey modules
+    await moduleTools.monkey('moduleLoading');
+    await loadConfig(app, modules);
+    await loadLocales(app, modules);
+    loadErrors(app, modules);
+    loadConstants(app, modules);
+
+    // monkey modules
+    await moduleTools.monkey('moduleLoaded');
+  }
+}
+
+class Start {
+  constructor(app) {
+    this.app = void 0;
+    this.app = app;
+  }
+  async start() {
+    const app = this.app;
+    try {
+      await this._start_appConfig();
+      await this._start_appLoad();
+      await this._start_appStart();
+      await this._start_appReady();
+      await this._start_appStarted();
+    } catch (err) {
+      // record
+      app.meta.appStartError = err;
+      // event: appReadyError
+      app.emit(EnumAppEvent.AppStartError, err);
+      // throw exception
+      throw err;
+    }
+  }
+  async _start_appLoad() {
+    const app = this.app;
+    // module loader
+    const moduleLoader = app.bean._newBean(ModuleLoader);
+    await moduleLoader.execute();
+  }
+  async _start_appStart() {
+    const app = this.app;
+    // hook: appStart
+    await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'appStart');
+  }
+  async _start_appReady() {
+    const app = this.app;
+    app.meta.appReady = true;
+    app.meta.appReadyInstances = {};
+    // hook: appReady
+    await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'appReady');
+  }
+  async _start_appStarted() {
+    const app = this.app;
+    app.meta.appStarted = true;
+    // event: appStarted
+    app.emit(EnumAppEvent.AppStarted);
+    // hook: appStarted
+    await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'appStarted');
+  }
+  async _start_appConfig() {
+    const app = this.app;
+    // config
+    const appConfig = await __prepareConfig(app);
+    this.app.config = appConfig;
+    this.app.keys = appConfig.server.keys;
+    this.app.proxy = appConfig.proxy.enable;
+    this.app.subdomainOffset = appConfig.server.subdomainOffset;
+    this.app.proxyIpHeader = appConfig.proxy.ipHeaders;
+    this.app.maxIpsCount = appConfig.proxy.maxIpsCount;
+  }
+}
+async function __prepareConfig(app) {
+  const config = {};
+  const configItems = (await app.options.config()).default;
+  const configItemsPromise = [];
+  for (const configItem of configItems) {
+    configItemsPromise.push(configItem(app, app.options.env));
+  }
+  const configItemsRes = await Promise.all(configItemsPromise);
+  for (const configItem of configItemsRes) {
+    if (configItem) {
+      deepExtend(config, configItem);
+    }
+  }
+  return config;
+}
+
+async function createAppMaster(bootstrapOptions) {
+  globalThis.__bootstrapOptions__ = bootstrapOptions;
+  const {
+    modulesMeta,
+    locales,
+    config,
+    env,
+    AppMonkey
+  } = bootstrapOptions;
+  globalThis.__app__ = __createApp({
+    modulesMeta,
+    locales,
+    config,
+    env,
+    AppMonkey
+  });
+}
+async function createApp(bootstrapOptions) {
+  while (globalThis.__creating__) {
+    await sleep(100);
+  }
+  try {
+    globalThis.__creating__ = true;
+    globalThis.__bootstrapOptions__ = bootstrapOptions;
+    const {
+      modulesMeta,
+      locales,
+      config,
+      env,
+      AppMonkey
+    } = bootstrapOptions;
+    if (!globalThis.__app__) {
+      globalThis.__app__ = __createApp({
+        modulesMeta,
+        locales,
+        config,
+        env,
+        AppMonkey
+      });
+      const start = new Start(globalThis.__app__);
+      await start.start();
+    }
+    await globalThis.__app__.meta.waitAppStarted();
+    return globalThis.__app__;
+  } finally {
+    globalThis.__creating__ = false;
+  }
+}
+function __createApp({
+  modulesMeta,
+  locales,
+  config,
+  env,
+  AppMonkey
+}) {
+  // patch zod, should before config
+  zodEnhance();
+  // env
+  const env2 = prepareEnv(env);
+  // appInfo
+  const appInfo = prepareAppInfo(env2);
+  // options
+  const options = {
+    name: appInfo.name,
+    projectPath: appInfo.projectPath,
+    configMeta: appInfo.configMeta,
+    modulesMeta,
+    locales,
+    config,
+    env: env2,
+    AppMonkey
+  };
+  return new VonaApplication(options);
+}
+function prepareAppInfo(env) {
+  return {
+    name: env.APP_NAME,
+    projectPath: process.cwd(),
+    configMeta: {
+      flavor: cast(env).META_FLAVOR,
+      mode: cast(env).META_MODE
+    }
+  };
+}
+
+function handleProcessWork() {
+  process.once('SIGUSR2', async () => {
+    // console.log('------------SIGUSR2');
+    await closeApp(true);
+  });
+  process.once('SIGINT', async () => {
+    // console.log('------------SIGINT');
+    await closeApp(true);
+  });
+  process.on('uncaughtException', async err => {
+    const app = useApp();
+    if (!app) {
+      console.error(err);
+      process.kill(process.pid, 'SIGTERM');
+    } else {
+      const [logger] = catchErrorSync(() => {
+        return app.meta.logger.get();
+      });
+      if (logger) {
+        logger.error(err);
+      } else {
+        console.error(err);
+      }
+      if (!app.meta.appStarted) {
+        await app.meta.logger.dispose();
+        process.kill(process.pid, 'SIGTERM');
+      }
+    }
+  });
+}
+function handleProcessMaster() {
+  process.once('SIGUSR2', () => {
+    // should not kill master self by manual
+    // process.kill(process.pid, 'SIGTERM');
+  });
+  // should not kill master self by manual
+  // process.once('SIGINT', () => {
+  //   process.kill(process.pid, 'SIGTERM');
+  // });
+}
+
+async function startCluster(workers, bootstrapOptions) {
+  if (cluster.isPrimary) {
+    handleProcessMaster();
+    createAppMaster(bootstrapOptions);
+
+    // console.log(`Primary ${process.pid} is running`);
+
+    // Fork workers.
+    for (let i = 0; i < workers; i++) {
+      cluster.fork();
+    }
+    cluster.on('message', (worker, message) => {
+      if (message === 'reload-worker') {
+        worker.process.kill('SIGTERM');
+        cluster.fork();
+      }
+    });
+    cluster.on('exit', (_worker, _code, _signal) => {
+      // console.log(`worker ${worker.process.pid} died`, code, signal);
+      // should not kill master self by manual
+      // master -> worker, rather than worker -> master
+      // if (cluster.workers && Object.keys(cluster.workers).length === 0) {
+      //   process.kill(process.pid, 'SIGTERM');
+      // }
+    });
+  } else {
+    handleProcessWork();
+    await createApp(bootstrapOptions);
+    // console.log(`Worker ${process.pid} started`);
+  }
+}
+
+async function bootstrap(bootstrapOptions) {
+  const env = prepareEnv(bootstrapOptions.env);
+  const workers = Number.parseInt(env.SERVER_WORKERS);
+  if (workers === 1 && process.env.META_MODE !== 'dev') {
+    handleProcessWork();
+    return await createApp(bootstrapOptions);
+  }
+  await startCluster(workers, bootstrapOptions);
+}
+
+function ExtendClass(classRef) {
+  appHmrDeps.addBean(classRef);
+  return classRef;
+}
+
+function MixinClass(...classRefs) {
+  appHmrDeps.addBeans(classRefs);
+  class TargetClass {}
+  copyMetadataOfClasses(TargetClass.prototype, classRefs.map(item => item.prototype));
+  copyPropertiesOfClasses(TargetClass, classRefs);
+  return TargetClass;
+}
+
+function OmitClass(classRef, keys) {
+  appHmrDeps.addBean(classRef);
+  class TargetClass {}
+  copyMetadataOfClasses(TargetClass.prototype, [classRef.prototype], (rules, key) => {
+    if (!keys.includes(key)) {
+      return rules[key];
+    }
+  });
+  copyPropertiesOfClasses(TargetClass, [classRef], key => {
+    return !keys.includes(key);
+  });
+  return TargetClass;
+}
+
+function PartialClass(classRef, keys) {
+  appHmrDeps.addBean(classRef);
+  class TargetClass {}
+  copyMetadataOfClasses(TargetClass.prototype, [classRef.prototype], (rules, key, metadataKeyOptions) => {
+    const schema = rules[key];
+    if (keys && !keys.includes(key)) return schema;
+    if (metadataKeyOptions?.partialClass) {
+      return metadataKeyOptions?.partialClass(schema);
+    }
+    return schema;
+  });
+  copyPropertiesOfClasses(TargetClass, [classRef]);
+  return TargetClass;
+}
+
+function PickClassInner(classTarget, classRef, keys) {
+  copyMetadataOfClasses(classTarget.prototype, [classRef.prototype], (rules, key) => {
+    if (!keys || keys.includes(key)) {
+      return rules[key];
+    }
+  });
+  copyPropertiesOfClasses(classTarget, [classRef], key => {
+    return !keys || keys.includes(key);
+  });
+  return classTarget;
+}
+
+function PickClass(classRef, keys) {
+  appHmrDeps.addBean(classRef);
+  class TargetClass {}
+  return PickClassInner(TargetClass, classRef, keys);
+}
+
+const $Class = {
+  extend: ExtendClass,
+  mixin: MixinClass,
+  omit: OmitClass,
+  partial: PartialClass,
+  pick: PickClass
+};
+
+function zodExtendOpenApi() {
+  extendZodWithOpenApi(z);
+  const openapiOriginal = z.ZodType.prototype.openapi;
+  z.ZodType.prototype.openapi = function (...args) {
+    // refId
+    if (typeof args[0] === 'string') return openapiOriginal.call(this, ...args);
+    const refId = ZodMetadata.getRefId(this);
+    if (!refId) return openapiOriginal.call(this, ...args);
+    // metadata
+    const metadata = args[0];
+    if (isEmptyObject(metadata)) {
+      return this;
+      // return openapiOriginal.call(this, ...args);
+    }
+    const options = args[1];
+    // refId: update
+    const refIdNew = `${refId}_${hashkey(metadata)}`;
+    const metadataOld = ZodMetadata.getOpenapiMetadata(this);
+    const metadataNew = deepExtend({}, metadataOld, metadata);
+    return openapiOriginal.call(this, refIdNew, metadataNew, options);
+  };
+}
+
+function $customKey(key) {
+  return key;
+}
+
+async function retry(options, fn) {
+  return new Promise((resolve, reject) => {
+    const operation = Retry.operation(options);
+    operation.attempt(currentAttempt => {
+      fn(currentAttempt).then(data => resolve(data)).catch(err => {
+        if (operation.retry(err)) return;
+        reject(err);
+      });
+    });
+  });
+}
+
+function getSqlite3DatabaseNameDefault(app) {
+  const mode = app.configMeta.mode;
+  if (mode !== 'prod') return '';
+  const dbPath = path.join(os.homedir(), 'vona', app.name, 'sqlite3');
+  fse.ensureDirSync(dbPath);
+  return path.join(dbPath, `${app.name}.db`);
+}
+
+// string/true/false
+function getSqlite3NativeBinding(_app, nativeBinding) {
+  nativeBinding = prepareNativeBinding(nativeBinding);
+  if (!nativeBinding) return nativeBinding;
+  const nativeBindingPath = path.isAbsolute(nativeBinding) ? nativeBinding : path.join(import.meta.dirname, nativeBinding);
+  const require = createRequire(import.meta.url);
+  const addon = require(nativeBindingPath);
+  return addon;
+}
+async function copySqlite3NativeBinding(projectPath, outDir, env) {
+  // dest
+  const nativeBinding = prepareNativeBinding(env.DATABASE_CLIENT_SQLITE3_NATIVEBINDING);
+  if (!nativeBinding || path.isAbsolute(nativeBinding)) return;
+  const fileDest = path.join(outDir, nativeBinding);
+  // src
+  const require = createRequire(pathToHref(path.join(projectPath, '/')));
+  const modulePath = require.resolve('better-sqlite3/package.json');
+  const fileSrc = path.join(path.dirname(modulePath), 'build/Release/better_sqlite3.node');
+  // copy
+  await fse.copy(fileSrc, fileDest);
+}
+function prepareNativeBinding(nativeBinding) {
+  if (!nativeBinding || nativeBinding === 'false') return null;
+  return nativeBinding === 'true' ? 'node/better_sqlite3.node' : nativeBinding;
+}
+
+zodExtendOpenApi();
+
+export { $Class, $customKey, $localeScope, AppHmr, AppHmrDeps, AppLocale, AppLogger, AppMeta, AppMetadata, AppResource, AppUtil, BeanAopBase, BeanAopMethodBase, BeanBase, BeanBaseSimple, BeanContainer, BeanInfo, BeanScopeBase, BeanScopeContainer, BeanScopeError, BeanScopeErrorImpl, BeanScopeLocale, BeanScopeScene, BeanScopeUtil, BeanSimple, EnumAppEvent, ErrorClass, LocaleModuleNameSeparator, PickClassInner, ProxyDisable, SymbolBeanContainerInstances, SymbolBeanFullName, SymbolBeanInstanceKey, SymbolBeanInstancePropsLazy, SymbolCacheAopChains, SymbolCacheAopChainsKey, SymbolDecoratorBeanFullName, SymbolDecoratorBeanInfo, SymbolDecoratorProxyDisable, SymbolDecoratorUse, SymbolDecoratorVirtual, SymbolHmrStateLoad, SymbolHmrStateSave, SymbolMappedClassMetadataKeys, SymbolModuleBelong, SymbolModuleName, Use, Virtual, VonaApplication, __prepareInjectSelectorInfo, appHmrDeps, appMetadata, appResource, beanFullNameFromOnionName, bootstrap, cast, closeApp, combineConfigDefault, combineFilePathSafe, compose, copyMetadataOfClasses, copyProperties, copyPropertiesOfClasses, copySqlite3NativeBinding, createApp, createAppMaster, createBeanDecorator, createGeneralApp, createHash, deepExtend, disposeInstance, errorsInternal, filterHeaders, formatLoggerAxiosError, formatLoggerConsole, formatLoggerCtx, formatLoggerDummy, formatLoggerFilter, functionNoop, getLoggerPathPhysicalRoot, getMappedClassMetadataKeys, getPublicPathPhysicalRoot, getRuntimePathPhysicalRoot, getSqlite3DatabaseNameDefault, getSqlite3NativeBinding, handleProcessMaster, handleProcessWork, instanceDesp, loadJSONFile, localeDefault, onionNameFromBeanFullName, pathToHref, polyfillDispose, prepareEnv, registerMappedClassMetadataKey, requireDynamic, retry, saveJSONFile, setMappedClassMetadataKeys, useApp, usePrepareArg, usePrepareArgs, uuidv4 };