nebula-engine 1.0.0-beta3

package/dist/index.mjs

@@ -0,0 +1,3457 @@
+import winston, { format } from 'winston';
+import { html } from 'hono/html';
+import { jsx, jsxs } from 'hono/jsx/jsx-runtime';
+import * as ejson from 'ejson';
+import { z } from 'zod';
+export { z } from 'zod';
+import { createHash } from 'crypto';
+import { trace, SpanStatusCode } from '@opentelemetry/api';
+import { promises } from 'fs';
+import { dirname } from 'path';
+import prettier from 'prettier';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+export { Context, MiddlewareHandler } from 'hono';
+import * as net from 'net';
+import { customAlphabet } from 'nanoid';
+
+// src/core/types.ts
+var PluginPriority = /* @__PURE__ */ ((PluginPriority2) => {
+  PluginPriority2[PluginPriority2["SYSTEM"] = 50] = "SYSTEM";
+  PluginPriority2[PluginPriority2["SECURITY"] = 100] = "SECURITY";
+  PluginPriority2[PluginPriority2["LOGGING"] = 200] = "LOGGING";
+  PluginPriority2[PluginPriority2["BUSINESS"] = 300] = "BUSINESS";
+  PluginPriority2[PluginPriority2["PERFORMANCE"] = 400] = "PERFORMANCE";
+  PluginPriority2[PluginPriority2["ROUTE"] = 1e3] = "ROUTE";
+  return PluginPriority2;
+})(PluginPriority || {});
+
+// src/metadata/metadata.ts
+var DECORATED_KEYS_KEY = /* @__PURE__ */ Symbol.for("nebula:decoratedKeys");
+var keyToClassesMap = /* @__PURE__ */ new Map();
+var classMetadataStore = /* @__PURE__ */ new WeakMap();
+var methodMetadataStore = /* @__PURE__ */ new WeakMap();
+var fieldMetadataStore = /* @__PURE__ */ new WeakMap();
+function getOrCreateClassMetadataMap(targetClass) {
+  let metadataMap = classMetadataStore.get(targetClass);
+  if (!metadataMap) {
+    metadataMap = /* @__PURE__ */ new Map();
+    classMetadataStore.set(targetClass, metadataMap);
+  }
+  return metadataMap;
+}
+function getOrCreateDecoratedKeysSet(targetClass) {
+  const metadataMap = getOrCreateClassMetadataMap(targetClass);
+  let decoratedKeys = metadataMap.get(DECORATED_KEYS_KEY);
+  if (!decoratedKeys) {
+    decoratedKeys = /* @__PURE__ */ new Set();
+    metadataMap.set(DECORATED_KEYS_KEY, decoratedKeys);
+  }
+  return decoratedKeys;
+}
+function registerKeyClassRelation(targetClass, metadataKey) {
+  const decoratedKeys = getOrCreateDecoratedKeysSet(targetClass);
+  decoratedKeys.add(metadataKey);
+  if (!keyToClassesMap.has(metadataKey)) {
+    keyToClassesMap.set(metadataKey, /* @__PURE__ */ new Set());
+  }
+  keyToClassesMap.get(metadataKey).add(targetClass);
+}
+function createClassDecorator(metadataKey = /* @__PURE__ */ Symbol.for("nebula:classMetadata")) {
+  return function(metadata) {
+    return function(target, context) {
+      context.addInitializer(function() {
+        registerKeyClassRelation(target, metadataKey);
+        const metadataMap = getOrCreateClassMetadataMap(target);
+        const existingMetadata = metadataMap.get(metadataKey) || {};
+        const mergedMetadata = {
+          ...existingMetadata,
+          ...metadata
+        };
+        metadataMap.set(metadataKey, mergedMetadata);
+      });
+    };
+  };
+}
+function createMethodDecorator(metadataKey = /* @__PURE__ */ Symbol.for("nebula:methodMetadata")) {
+  return function(metadata) {
+    return function(target, context) {
+      const methodName = context.name.toString();
+      const collectMetadata = (targetClass2) => {
+        if (!targetClass2) return;
+        registerKeyClassRelation(targetClass2, metadataKey);
+        let metadataMap = methodMetadataStore.get(targetClass2);
+        if (!metadataMap) {
+          metadataMap = /* @__PURE__ */ new Map();
+          methodMetadataStore.set(targetClass2, metadataMap);
+        }
+        const existingMetadataMap = metadataMap.get(metadataKey) || {};
+        const existingMetadata = existingMetadataMap[methodName] || [];
+        const newMetadata = {
+          ...metadata,
+          type: metadata.type
+        };
+        existingMetadataMap[methodName] = [...existingMetadata, newMetadata];
+        metadataMap.set(metadataKey, existingMetadataMap);
+      };
+      let targetClass = null;
+      try {
+        if (target.constructor && typeof target.constructor === "function") {
+          targetClass = target.constructor;
+        }
+      } catch (e) {
+      }
+      if (targetClass) {
+        collectMetadata(targetClass);
+      }
+      context.addInitializer(function() {
+        const instanceClass = this.constructor;
+        if (instanceClass && instanceClass !== targetClass) {
+          collectMetadata(instanceClass);
+        }
+      });
+    };
+  };
+}
+function createFieldDecorator(metadataKey = /* @__PURE__ */ Symbol.for("nebula:fieldMetadata")) {
+  return function(metadata) {
+    return function(target, context) {
+      const fieldName = context.name.toString();
+      const collectMetadata = (targetClass) => {
+        if (!targetClass) return;
+        registerKeyClassRelation(targetClass, metadataKey);
+        let metadataMap = fieldMetadataStore.get(targetClass);
+        if (!metadataMap) {
+          metadataMap = /* @__PURE__ */ new Map();
+          fieldMetadataStore.set(targetClass, metadataMap);
+        }
+        const existingMetadataMap = metadataMap.get(metadataKey) || {};
+        const existingMetadata = existingMetadataMap[fieldName] || [];
+        const newMetadata = {
+          ...metadata,
+          type: metadata.type
+        };
+        existingMetadataMap[fieldName] = [...existingMetadata, newMetadata];
+        metadataMap.set(metadataKey, existingMetadataMap);
+      };
+      context.addInitializer(function() {
+        const instanceClass = this.constructor;
+        if (instanceClass) {
+          collectMetadata(instanceClass);
+        }
+      });
+    };
+  };
+}
+function getClassesByKey(metadataKey) {
+  return keyToClassesMap.get(metadataKey) || /* @__PURE__ */ new Set();
+}
+function getClassMetadata(target, metadataKey = /* @__PURE__ */ Symbol.for("nebula:classMetadata")) {
+  let targetClass = null;
+  if (target && typeof target === "function" && target.prototype) {
+    targetClass = target;
+  } else if (target && target.constructor && typeof target.constructor === "function") {
+    targetClass = target.constructor;
+  }
+  if (!targetClass) {
+    return {};
+  }
+  const metadataMap = classMetadataStore.get(targetClass);
+  if (!metadataMap) {
+    return {};
+  }
+  return metadataMap.get(metadataKey) || {};
+}
+function getAllMethodMetadata(target, metadataKey = /* @__PURE__ */ Symbol.for("nebula:methodMetadata")) {
+  const result = /* @__PURE__ */ new Map();
+  let targetClass = null;
+  if (target && typeof target === "function" && target.prototype) {
+    targetClass = target;
+  } else if (target && target.constructor && typeof target.constructor === "function") {
+    targetClass = target.constructor;
+  }
+  if (!targetClass) {
+    return result;
+  }
+  const metadataMap = methodMetadataStore.get(targetClass);
+  if (!metadataMap) {
+    return result;
+  }
+  const allMetadata = metadataMap.get(metadataKey) || {};
+  for (const [methodName, metadataList] of Object.entries(allMetadata)) {
+    if (metadataList.length > 0) {
+      result.set(methodName, metadataList);
+    }
+  }
+  return result;
+}
+function getAllFieldMetadata(target, metadataKey = /* @__PURE__ */ Symbol.for("nebula:fieldMetadata")) {
+  const result = /* @__PURE__ */ new Map();
+  let targetClass = null;
+  if (target && typeof target === "function" && target.prototype) {
+    targetClass = target;
+  } else if (target && target.constructor && typeof target.constructor === "function") {
+    targetClass = target.constructor;
+  }
+  if (!targetClass) {
+    return result;
+  }
+  const metadataMap = fieldMetadataStore.get(targetClass);
+  if (!metadataMap) {
+    return result;
+  }
+  const allMetadata = metadataMap.get(metadataKey) || {};
+  for (const [fieldName, metadataList] of Object.entries(allMetadata)) {
+    if (metadataList.length > 0) {
+      result.set(fieldName, metadataList);
+    }
+  }
+  return result;
+}
+
+// src/core/decorators.ts
+var HANDLER_METADATA_KEY = /* @__PURE__ */ Symbol.for("nebula:handlerMetadata");
+var HANDLER_FIELD_METADATA_KEY = /* @__PURE__ */ Symbol.for("nebula:handlerFieldMetadata");
+var createHandlerDecorator = createMethodDecorator(HANDLER_METADATA_KEY);
+var createHandlerFieldDecorator = createFieldDecorator(HANDLER_FIELD_METADATA_KEY);
+function Handler(config) {
+  return createHandlerDecorator({
+    type: config.type,
+    options: config.options || {}
+  });
+}
+function HandlerField(config) {
+  return createHandlerFieldDecorator({
+    type: config.type,
+    options: config.options || {}
+  });
+}
+function getAllHandlerMetadata(target) {
+  const allMetadata = getAllMethodMetadata(target, HANDLER_METADATA_KEY);
+  const result = /* @__PURE__ */ new Map();
+  for (const [methodName, metadataList] of allMetadata.entries()) {
+    result.set(methodName, metadataList);
+  }
+  return result;
+}
+function getAllHandlerFieldMetadata(target) {
+  const allMetadata = getAllFieldMetadata(target, HANDLER_FIELD_METADATA_KEY);
+  const result = /* @__PURE__ */ new Map();
+  for (const [fieldName, metadataList] of allMetadata.entries()) {
+    result.set(fieldName, metadataList);
+  }
+  return result;
+}
+
+// src/core/errors.ts
+var PluginNameRequiredError = class extends Error {
+  constructor(pluginName) {
+    super(
+      `Plugin name is required${pluginName ? ` (plugin: ${pluginName})` : ""}`
+    );
+    this.name = "PluginNameRequiredError";
+  }
+};
+var ModuleConfigValidationError = class extends Error {
+  constructor(moduleName, pluginName, message) {
+    super(
+      `[ModuleConfigError] Module ${moduleName} (plugin ${pluginName}): ${message}`
+    );
+    this.name = "ModuleConfigValidationError";
+  }
+};
+var DuplicateModuleError = class extends Error {
+  constructor(moduleName) {
+    super(`Module ${moduleName} is already registered`);
+    this.name = "DuplicateModuleError";
+  }
+};
+var customFormat = format.printf((info) => {
+  const { level, timestamp, message, ...meta } = info;
+  const splat = info[/* @__PURE__ */ Symbol.for("splat")];
+  let msg = `${timestamp} [${level}] ${message}`;
+  if (splat && Array.isArray(splat) && splat.length > 0) {
+    const metaStr = splat.map((item) => {
+      if (item instanceof Error) {
+        return item.stack || item.message;
+      }
+      if (typeof item === "object") {
+        return JSON.stringify(item, null, 2);
+      }
+      return String(item);
+    }).join("\n");
+    msg += `
+${metaStr}`;
+  }
+  const metaKeys = Object.keys(meta).filter(
+    (key) => key !== (/* @__PURE__ */ Symbol.for("splat")).toString()
+  );
+  if (metaKeys.length > 0) {
+    const metaObj = {};
+    for (const key of metaKeys) {
+      metaObj[key] = meta[key];
+    }
+    msg += `
+${JSON.stringify(metaObj, null, 2)}`;
+  }
+  return msg;
+});
+var logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || "info",
+  transports: [
+    new winston.transports.Console({
+      format: format.combine(
+        format.colorize({ all: true }),
+        format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
+        customFormat
+      )
+    })
+  ]
+});
+var logger_default = logger;
+
+// src/core/checker.ts
+async function startCheck(checkers, pass) {
+  logger_default.info("[ \u9884\u68C0\u5F00\u59CB ]");
+  for (const [index, checker] of checkers.entries()) {
+    const seq = index + 1;
+    logger_default.info(`${seq}. ${checker.name}`);
+    try {
+      if (checker.skip) {
+        logger_default.warn(`${seq}. ${checker.name} [\u8DF3\u8FC7]`);
+        continue;
+      }
+      await checker.check();
+      logger_default.info(`${seq}. ${checker.name} [\u6210\u529F]`);
+    } catch (error) {
+      logger_default.error(`${seq}. ${checker.name} [\u5931\u8D25]`);
+      throw error;
+    }
+  }
+  logger_default.info("[ \u9884\u68C0\u5B8C\u6210 ]");
+  if (pass) await pass();
+}
+var DEFAULT_FAVICON = /* @__PURE__ */ jsx(
+  "link",
+  {
+    rel: "icon",
+    href: "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100' width='100' height='100'><defs><linearGradient id='nodeGradient' x1='0%' y1='0%' x2='100%' y2='100%'><stop offset='0%' stop-color='%233498db'/><stop offset='100%' stop-color='%232980b9'/></linearGradient><linearGradient id='centerNodeGradient' x1='0%' y1='0%' x2='100%' y2='100%'><stop offset='0%' stop-color='%232ecc71'/><stop offset='100%' stop-color='%2327ae60'/></linearGradient></defs><circle cx='50' cy='50' r='45' fill='%23f5f7fa'/><path d='M30,30 L50,50' stroke='%23bdc3c7' stroke-width='2' stroke-linecap='round'/><path d='M70,30 L50,50' stroke='%23bdc3c7' stroke-width='2' stroke-linecap='round'/><path d='M30,70 L50,50' stroke='%23bdc3c7' stroke-width='2' stroke-linecap='round'/><path d='M70,70 L50,50' stroke='%23bdc3c7' stroke-width='2' stroke-linecap='round'/><polygon points='30,15 45,25 45,45 30,55 15,45 15,25' fill='url(%23nodeGradient)' stroke='%232980b9' stroke-width='1.5'/><polygon points='70,15 85,25 85,45 70,55 55,45 55,25' fill='url(%23nodeGradient)' stroke='%232980b9' stroke-width='1.5'/><polygon points='30,45 45,55 45,75 30,85 15,75 15,55' fill='url(%23nodeGradient)' stroke='%232980b9' stroke-width='1.5'/><polygon points='70,45 85,55 85,75 70,85 55,75 55,55' fill='url(%23nodeGradient)' stroke='%232980b9' stroke-width='1.5'/><polygon points='50,30 65,40 65,60 50,70 35,60 35,40' fill='url(%23centerNodeGradient)' stroke='%2327ae60' stroke-width='2'/><circle cx='30' cy='30' r='3' fill='%23ffffff'/><circle cx='70' cy='30' r='3' fill='%23ffffff'/><circle cx='30' cy='70' r='3' fill='%23ffffff'/><circle cx='70' cy='70' r='3' fill='%23ffffff'/><circle cx='50' cy='50' r='4' fill='%23ffffff'/></svg>",
+    type: "image/svg+xml"
+  }
+);
+var BaseLayout = (props = {
+  title: "Microservice Template"
+}) => html`<!DOCTYPE html>
+    <html>
+      <head>
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>${props.title}</title>
+        ${props.heads}
+      </head>
+      <body>
+        ${props.children}
+      </body>
+    </html>`;
+var HtmxLayout = (props = {
+  title: "Microservice Template"
+}) => BaseLayout({
+  title: props.title,
+  heads: html`
+      <script src="https://unpkg.com/htmx.org@latest"></script>
+      <script src="https://unpkg.com/hyperscript.org@latest"></script>
+      <script src="https://cdn.tailwindcss.com"></script>
+      ${props.favicon || DEFAULT_FAVICON}
+    `,
+  children: props.children
+});
+var InfoCard = ({
+  icon,
+  iconColor,
+  bgColor,
+  label,
+  value
+}) => /* @__PURE__ */ jsxs("div", { className: `${bgColor} p-4 rounded-lg`, children: [
+  /* @__PURE__ */ jsxs("div", { className: "flex items-center mb-2", children: [
+    /* @__PURE__ */ jsx(
+      "svg",
+      {
+        className: `w-5 h-5 ${iconColor} mr-2`,
+        fill: "none",
+        stroke: "currentColor",
+        viewBox: "0 0 24 24",
+        children: /* @__PURE__ */ jsx(
+          "path",
+          {
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 2,
+            d: icon
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-gray-600", children: label })
+  ] }),
+  /* @__PURE__ */ jsx("p", { className: `text-xl font-semibold text-gray-900`, children: value })
+] });
+var getEnvironmentBadgeClass = (env) => {
+  const normalizedEnv = env.toLowerCase();
+  switch (normalizedEnv) {
+    case "production":
+    case "prod":
+      return "bg-red-100 text-red-800";
+    case "staging":
+    case "stg":
+      return "bg-yellow-100 text-yellow-800";
+    case "development":
+    case "dev":
+    default:
+      return "bg-blue-100 text-blue-800";
+  }
+};
+var getStatusBadgeClass = (status) => {
+  switch (status.toLowerCase()) {
+    case "running":
+      return "bg-green-100 text-green-800";
+    case "stopped":
+      return "bg-gray-100 text-gray-800";
+    case "error":
+      return "bg-red-100 text-red-800";
+    default:
+      return "bg-blue-100 text-blue-800";
+  }
+};
+var ServiceInfoCards = ({
+  serviceInfo
+}) => {
+  const env = serviceInfo.env || typeof process !== "undefined" && process.env?.NODE_ENV || "dev";
+  const status = serviceInfo.status || "running";
+  const infoCards = [
+    {
+      icon: "M7 4V2a1 1 0 011-1h8a1 1 0 011 1v2m-9 0h10m-10 0a2 2 0 00-2 2v14a2 2 0 002 2h10a2 2 0 002-2V6a2 2 0 00-2-2",
+      iconColor: "text-blue-600",
+      bgColor: "bg-blue-50",
+      label: "\u670D\u52A1\u540D\u79F0",
+      value: serviceInfo.name
+    },
+    {
+      icon: "M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1",
+      iconColor: "text-orange-600",
+      bgColor: "bg-orange-50",
+      label: "\u670D\u52A1\u8DEF\u5F84",
+      value: serviceInfo.prefix || "/"
+    },
+    {
+      icon: "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z",
+      iconColor: "text-green-600",
+      bgColor: "bg-green-50",
+      label: "\u8FD0\u884C\u73AF\u5883",
+      value: /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: `px-2 py-1 rounded-full text-sm ${getEnvironmentBadgeClass(env)}`,
+          children: env
+        }
+      )
+    },
+    {
+      icon: "M7 7h.01M7 3h5c.512 0 1.024.195 1.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A1.994 1.994 0 013 12V7a4 4 0 014-4z",
+      iconColor: "text-purple-600",
+      bgColor: "bg-purple-50",
+      label: "\u7248\u672C\u53F7",
+      value: serviceInfo.version || "unknown"
+    },
+    ...serviceInfo.port ? [
+      {
+        icon: "M5 12h14M5 12a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v4a2 2 0 01-2 2M5 12a2 2 0 00-2 2v4a2 2 0 002 2h14a2 2 0 002-2v-4a2 2 0 00-2-2m-2-4h.01M17 16h.01",
+        iconColor: "text-indigo-600",
+        bgColor: "bg-indigo-50",
+        label: "\u7AEF\u53E3",
+        value: serviceInfo.port
+      }
+    ] : [],
+    {
+      icon: "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z",
+      iconColor: "text-emerald-600",
+      bgColor: "bg-emerald-50",
+      label: "\u8FD0\u884C\u72B6\u6001",
+      value: /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: `px-2 py-1 rounded-full text-sm ${getStatusBadgeClass(status)}`,
+          children: status
+        }
+      )
+    }
+  ];
+  return /* @__PURE__ */ jsxs("div", { className: "bg-white rounded-lg shadow-md p-6 mb-8", children: [
+    /* @__PURE__ */ jsxs("h2", { className: "text-2xl font-semibold text-gray-800 mb-6 flex items-center", children: [
+      /* @__PURE__ */ jsx(
+        "svg",
+        {
+          className: "w-6 h-6 mr-2 text-blue-600",
+          fill: "none",
+          stroke: "currentColor",
+          viewBox: "0 0 24 24",
+          children: /* @__PURE__ */ jsx(
+            "path",
+            {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: 2,
+              d: "M13 10V3L4 14h7v7l9-11h-7z"
+            }
+          )
+        }
+      ),
+      "\u670D\u52A1\u57FA\u672C\u4FE1\u606F"
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6", children: infoCards.map((card, index) => /* @__PURE__ */ jsx(InfoCard, { ...card }, index)) })
+  ] });
+};
+var ServiceStatusPage = ({
+  serviceInfo
+}) => {
+  return /* @__PURE__ */ jsx("div", { className: "min-h-screen bg-gray-50 py-8", children: /* @__PURE__ */ jsxs("div", { className: "max-w-6xl mx-auto px-4", children: [
+    /* @__PURE__ */ jsxs("div", { className: "mb-8", children: [
+      /* @__PURE__ */ jsx("h1", { className: "text-4xl font-bold text-gray-900 mb-2", children: "Service Status" }),
+      /* @__PURE__ */ jsx("p", { className: "text-gray-600", children: "\u67E5\u770B\u670D\u52A1\u8FD0\u884C\u72B6\u6001\u548C\u57FA\u672C\u4FE1\u606F" })
+    ] }),
+    /* @__PURE__ */ jsx(ServiceInfoCards, { serviceInfo })
+  ] }) });
+};
+
+// src/plugins/route/decorator.ts
+function Route(options) {
+  return Handler({
+    type: "route",
+    options
+  });
+}
+function Page(options) {
+  const pageOptions = {
+    method: options.method || "GET",
+    ...options
+  };
+  return Route(pageOptions);
+}
+
+// src/plugins/route/plugin.ts
+var RoutePlugin = class {
+  name = "route-plugin";
+  priority = 1e3 /* ROUTE */;
+  engine;
+  globalPrefix;
+  globalMiddlewares;
+  errorTransformer;
+  /**
+   * 构造函数
+   * @param options 插件配置选项
+   */
+  constructor(options) {
+    this.globalPrefix = options?.prefix || "";
+    this.globalMiddlewares = options?.globalMiddlewares || [];
+    this.errorTransformer = options?.errorTransformer;
+  }
+  /**
+   * 声明Module配置Schema（用于类型推导+运行时校验）
+   */
+  getModuleOptionsSchema() {
+    return {
+      _type: {},
+      validate: (options) => {
+        if (options.routePrefix !== void 0 && typeof options.routePrefix !== "string") {
+          return "routePrefix must be a string";
+        }
+        if (options.routePrefix && !options.routePrefix.startsWith("/")) {
+          return `routePrefix must start with '/'`;
+        }
+        if (options.routeMiddlewares !== void 0 && !Array.isArray(options.routeMiddlewares)) {
+          return "routeMiddlewares must be an array";
+        }
+        return true;
+      }
+    };
+  }
+  /**
+   * 引擎初始化钩子：获取Hono实例
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("RoutePlugin initialized");
+  }
+  /**
+   * Handler加载钩子：解析type="route"的Handler元数据，注册HTTP路由
+   */
+  onHandlerLoad(handlers) {
+    const routeHandlers = handlers.filter(
+      (handler) => handler.type === "route"
+    );
+    logger_default.info(`Found ${routeHandlers.length} route handler(s)`);
+    for (const handler of routeHandlers) {
+      const routeOptions = handler.options;
+      const methodName = handler.methodName;
+      const moduleClass = handler.module;
+      const moduleInstance = this.engine.get(moduleClass);
+      if (!moduleInstance) {
+        logger_default.warn(
+          `Module instance not found for ${moduleClass.name}, skipping route registration`
+        );
+        continue;
+      }
+      const moduleMetadata = this.engine.getModules().find((m) => m.clazz === moduleClass);
+      const moduleOptions = moduleMetadata?.options || {};
+      const routePrefix = moduleOptions.routePrefix || "";
+      const paths = Array.isArray(routeOptions.path) ? routeOptions.path : [routeOptions.path];
+      const fullPaths = paths.map((p) => this.globalPrefix + routePrefix + p);
+      const routeHandler = async (ctx) => {
+        const method = moduleInstance[methodName];
+        if (typeof method !== "function") {
+          return ctx.json({ error: "Handler method not found" }, 500);
+        }
+        try {
+          const result = await method.call(moduleInstance, ctx);
+          if (result === void 0) {
+            return new Response(null, { status: 204 });
+          }
+          if (result instanceof Response) {
+            return result;
+          }
+          if (typeof result === "string") {
+            return ctx.text(result);
+          }
+          if (result === null) {
+            return new Response(null, { status: 204 });
+          }
+          if (typeof result === "object" && result !== null && (result.isEscaped === true || result.constructor?.name === "HtmlEscaped")) {
+            return ctx.html(result);
+          }
+          if (typeof result === "object" && result !== null && "type" in result && (typeof result.type === "function" || typeof result.type === "string")) {
+            return ctx.html(result);
+          }
+          return ctx.json(result);
+        } catch (error) {
+          logger_default.error(
+            `Error in route handler ${moduleClass.name}.${methodName}`,
+            error
+          );
+          if (this.errorTransformer) {
+            try {
+              const transformedResponse = await this.errorTransformer(
+                ctx,
+                error,
+                handler
+              );
+              return transformedResponse;
+            } catch (transformerError) {
+              logger_default.error(
+                `Error transformer failed for ${moduleClass.name}.${methodName}`,
+                transformerError
+              );
+            }
+          }
+          return ctx.json(
+            {
+              error: "Internal server error",
+              message: error instanceof Error ? error.message : String(error)
+            },
+            500
+          );
+        }
+      };
+      const hono = this.engine.getHono();
+      const methods = routeOptions.method ? Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method] : ["GET"];
+      for (const fullPath of fullPaths) {
+        let route = hono;
+        if (this.globalMiddlewares.length > 0) {
+          route = route.use(fullPath, ...this.globalMiddlewares);
+        }
+        if (moduleOptions.routeMiddlewares && moduleOptions.routeMiddlewares.length > 0) {
+          route = route.use(fullPath, ...moduleOptions.routeMiddlewares);
+        }
+        if (routeOptions.middlewares && routeOptions.middlewares.length > 0) {
+          route = route.use(fullPath, ...routeOptions.middlewares);
+        }
+        for (const method of methods) {
+          const methodLower = method.toLowerCase();
+          if (methodLower === "get" || methodLower === "post" || methodLower === "put" || methodLower === "delete" || methodLower === "patch" || methodLower === "head" || methodLower === "options") {
+            route[methodLower](fullPath, routeHandler);
+            const description = routeOptions.description ? ` (${routeOptions.description})` : "";
+            logger_default.info(
+              `Registered route: ${method.toUpperCase()} ${fullPath} -> ${moduleClass.name}.${methodName}${description}`
+            );
+          } else {
+            logger_default.warn(
+              `Unsupported HTTP method: ${method}, skipping route ${fullPath}`
+            );
+          }
+        }
+      }
+    }
+  }
+};
+function buildParamsSchema(schemas) {
+  const shape = {};
+  for (let i = 0; i < schemas.length; i++) {
+    shape[String(i)] = schemas[i];
+  }
+  return z.object(shape);
+}
+function parseAndValidateParams(body, schemas) {
+  if (!body || typeof body !== "object") {
+    body = {};
+  }
+  if (schemas.length === 0) {
+    return { success: true, data: [] };
+  }
+  const paramsSchema = buildParamsSchema(schemas);
+  const validation = paramsSchema.safeParse(body);
+  if (!validation.success) {
+    return {
+      success: false,
+      error: validation.error
+    };
+  }
+  const validatedData = [];
+  for (let i = 0; i < schemas.length; i++) {
+    validatedData[i] = validation.data[String(i)];
+  }
+  return {
+    success: true,
+    data: validatedData
+  };
+}
+function buildActionPath(enginePrefix, moduleName, handlerName) {
+  const normalizedPrefix = enginePrefix.replace(/\/+$/, "");
+  return `/${normalizedPrefix}/${moduleName}/${handlerName}`.replace(/\/+/g, "/").replace(/^\/\//, "/");
+}
+
+// src/plugins/action/plugin.ts
+function isAsyncIterable(obj) {
+  return obj != null && typeof obj[Symbol.asyncIterator] === "function";
+}
+var ActionPlugin = class {
+  name = "action-plugin";
+  priority = 1e3 /* ROUTE */;
+  // 路由插件优先级最低，必须最后执行
+  engine;
+  /**
+   * 声明Module配置Schema（用于类型推导+运行时校验）
+   */
+  getModuleOptionsSchema() {
+    return {
+      _type: {},
+      validate: (options) => {
+        if (options.actionMiddlewares !== void 0 && !Array.isArray(options.actionMiddlewares)) {
+          return "actionMiddlewares must be an array";
+        }
+        return true;
+      }
+    };
+  }
+  /**
+   * 引擎初始化钩子：获取Hono实例
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("ActionPlugin initialized");
+  }
+  /**
+   * Handler加载钩子：解析type="action"的Handler元数据，注册HTTP路由
+   */
+  onHandlerLoad(handlers) {
+    const actionHandlers = handlers.filter(
+      (handler) => handler.type === "action"
+    );
+    logger_default.info(`Found ${actionHandlers.length} action handler(s)`);
+    for (const handler of actionHandlers) {
+      const actionOptions = handler.options;
+      const methodName = handler.methodName;
+      const moduleClass = handler.module;
+      const moduleInstance = this.engine.get(moduleClass);
+      if (!moduleInstance) {
+        logger_default.warn(
+          `Module instance not found for ${moduleClass.name}, skipping action registration`
+        );
+        continue;
+      }
+      const moduleMetadata = this.engine.getModules().find((m) => m.clazz === moduleClass);
+      if (!moduleMetadata) {
+        logger_default.warn(
+          `Module metadata not found for ${moduleClass.name}, skipping action registration`
+        );
+        continue;
+      }
+      const moduleOptions = moduleMetadata.options || {};
+      const enginePrefix = this.engine.options.prefix || "";
+      const actionPath = buildActionPath(
+        enginePrefix,
+        moduleMetadata.name,
+        methodName
+      );
+      const paramSchemas = actionOptions.params || [];
+      const returnSchema = actionOptions.returns;
+      const actionHandler = async (ctx) => {
+        const method = moduleInstance[methodName];
+        if (typeof method !== "function") {
+          const errorResponse = ejson.stringify({
+            success: false,
+            error: "Action method not found"
+          });
+          return ctx.text(errorResponse, 500, {
+            "Content-Type": "application/json"
+          });
+        }
+        try {
+          let body = {};
+          if (ctx.req.method === "GET") {
+            const url = new URL(ctx.req.url);
+            url.searchParams.forEach((value, key) => {
+              body[key] = value;
+            });
+          } else {
+            try {
+              const rawBody = await ctx.req.text();
+              if (rawBody) {
+                body = ejson.parse(rawBody);
+              }
+            } catch (parseError) {
+              try {
+                body = await ctx.req.json().catch(() => ({}));
+              } catch {
+                body = {};
+              }
+            }
+          }
+          const validation = parseAndValidateParams(body, paramSchemas);
+          if (!validation.success) {
+            const errors = validation.error.issues || [];
+            const errorMessage = `Validation failed: ${errors.map((e) => {
+              const path = e.path || [];
+              const pathStr = path.length > 0 ? path.map((p, i) => {
+                if (i === 0 && typeof p === "string" && /^\d+$/.test(p)) {
+                  return `\u53C2\u6570[${p}]`;
+                }
+                return String(p);
+              }).join(".") : "unknown";
+              return `${pathStr}: ${e.message}`;
+            }).join(", ")}`;
+            const errorResponse = ejson.stringify({
+              success: false,
+              error: errorMessage
+            });
+            return ctx.text(errorResponse, 400, {
+              "Content-Type": "application/json"
+            });
+          }
+          const methodLength = method.length;
+          const paramsLength = paramSchemas.length;
+          const args = [...validation.data];
+          if (methodLength > paramsLength) {
+            args.unshift(ctx);
+          }
+          const result = await method.apply(moduleInstance, args);
+          if (actionOptions.stream) {
+            if (!isAsyncIterable(result)) {
+              const errorResponse = ejson.stringify({
+                success: false,
+                error: "Stream action must return AsyncIterable"
+              });
+              return ctx.text(errorResponse, 500, {
+                "Content-Type": "application/json"
+              });
+            }
+            const encoder = new TextEncoder();
+            const iterator = result[Symbol.asyncIterator]();
+            const stream = new ReadableStream({
+              async start(controller) {
+                try {
+                  while (true) {
+                    const { value, done } = await iterator.next();
+                    if (done) {
+                      controller.enqueue(
+                        encoder.encode(ejson.stringify({ done: true }))
+                      );
+                      controller.close();
+                      break;
+                    }
+                    controller.enqueue(
+                      encoder.encode(ejson.stringify({ value, done: false }))
+                    );
+                  }
+                } catch (error) {
+                  controller.enqueue(
+                    encoder.encode(
+                      ejson.stringify({
+                        error: error instanceof Error ? error.message : String(error),
+                        done: true
+                      })
+                    )
+                  );
+                  controller.close();
+                }
+              }
+            });
+            return new Response(stream, {
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive"
+              }
+            });
+          }
+          if (returnSchema) {
+            const returnValidation = returnSchema.safeParse(result);
+            if (!returnValidation.success) {
+              logger_default.error(
+                `Return value validation failed for ${moduleClass.name}.${methodName}`,
+                returnValidation.error
+              );
+              const returnErrors = returnValidation.error.issues || [];
+              const errorMessage = `Return value validation failed: ${returnErrors.map((e) => {
+                const path = e.path || [];
+                const pathStr = path.length > 0 ? path.map((p) => String(p)).join(".") : "root";
+                return `${pathStr}: ${e.message}`;
+              }).join(", ")}`;
+              const errorResponse = ejson.stringify({
+                success: false,
+                error: errorMessage
+              });
+              return ctx.text(errorResponse, 400, {
+                "Content-Type": "application/json"
+              });
+            }
+            const successResponse2 = ejson.stringify({
+              success: true,
+              data: returnValidation.data
+            });
+            return ctx.text(successResponse2, 200, {
+              "Content-Type": "application/json"
+            });
+          }
+          const successResponse = ejson.stringify({
+            success: true,
+            data: result
+          });
+          return ctx.text(successResponse, 200, {
+            "Content-Type": "application/json"
+          });
+        } catch (error) {
+          logger_default.error(
+            `Error in action handler ${moduleClass.name}.${methodName}`,
+            error
+          );
+          const errorResponse = ejson.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return ctx.text(errorResponse, 500, {
+            "Content-Type": "application/json"
+          });
+        }
+      };
+      const hono = this.engine.getHono();
+      let route = hono;
+      if (moduleOptions.actionMiddlewares && moduleOptions.actionMiddlewares.length > 0) {
+        route = route.use(actionPath, ...moduleOptions.actionMiddlewares);
+      }
+      if (actionOptions.middlewares && actionOptions.middlewares.length > 0) {
+        route = route.use(actionPath, ...actionOptions.middlewares);
+      }
+      route.get(actionPath, actionHandler);
+      route.post(actionPath, actionHandler);
+      logger_default.info(
+        `[\u6CE8\u518C\u52A8\u4F5C] ${moduleClass.name}.${methodName} ${actionOptions.description}`
+      );
+    }
+  }
+};
+
+// src/plugins/action/decorator.ts
+function Action(options) {
+  return Handler({
+    type: "action",
+    options
+  });
+}
+
+// src/plugins/cache/adapter.ts
+var MemoryCacheAdapter = class {
+  cache = /* @__PURE__ */ new Map();
+  async get(key) {
+    const item = this.cache.get(key);
+    if (!item) {
+      return null;
+    }
+    if (item.expiresAt <= Date.now()) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item;
+  }
+  async set(key, item) {
+    this.cache.set(key, item);
+  }
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  async keys() {
+    const now = Date.now();
+    return Array.from(this.cache.entries()).filter(([_, item]) => item.expiresAt > now).map(([key]) => key);
+  }
+  /**
+   * 清理所有过期项（高效批量清理）
+   * 这个方法比通过 keys() + get() + delete() 更高效
+   */
+  async cleanupExpired() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, item] of this.cache.entries()) {
+      if (item.expiresAt <= now) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  async getStats() {
+    const now = Date.now();
+    const validEntries = Array.from(this.cache.entries()).filter(([_, item]) => item.expiresAt > now).map(([key, item]) => ({
+      key,
+      expiresAt: item.expiresAt,
+      createdAt: item.createdAt
+    }));
+    return {
+      size: validEntries.length,
+      entries: validEntries
+    };
+  }
+};
+var RedisCacheAdapter = class {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix || "cache:";
+  }
+  getKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  async get(key) {
+    const redisKey = this.getKey(key);
+    const data = await this.client.get(redisKey);
+    if (!data) {
+      return null;
+    }
+    try {
+      const item = JSON.parse(data);
+      if (item.expiresAt <= Date.now()) {
+        await this.delete(key);
+        return null;
+      }
+      return item;
+    } catch (error) {
+      await this.delete(key);
+      return null;
+    }
+  }
+  async set(key, item) {
+    const redisKey = this.getKey(key);
+    const data = JSON.stringify(item);
+    const ttl = Math.max(0, Math.floor((item.expiresAt - Date.now()) / 1e3));
+    await this.client.set(redisKey, data, "EX", ttl);
+  }
+  async delete(key) {
+    const redisKey = this.getKey(key);
+    const result = await this.client.del(redisKey);
+    return result > 0;
+  }
+  async clear() {
+    const pattern = `${this.keyPrefix}*`;
+    const keys = await this.client.keys(pattern);
+    if (keys.length > 0) {
+      await Promise.all(keys.map((key) => this.client.del(key)));
+    }
+  }
+  async keys() {
+    const pattern = `${this.keyPrefix}*`;
+    const redisKeys = await this.client.keys(pattern);
+    return redisKeys.map((key) => key.replace(this.keyPrefix, ""));
+  }
+  /**
+   * 清理所有过期项
+   *
+   * 注意：Redis 本身支持自动过期（通过 SET key value EX seconds），
+   * 过期键会被 Redis 自动删除。但在某些情况下（如测试环境、某些 Redis 客户端），
+   * 可能需要手动清理。此方法会检查并清理：
+   * 1. 已过期但尚未被 Redis 删除的键（双重保险）
+   * 2. JSON 解析失败的数据
+   */
+  async cleanupExpired() {
+    const pattern = `${this.keyPrefix}*`;
+    const redisKeys = await this.client.keys(pattern);
+    let cleaned = 0;
+    for (const redisKey of redisKeys) {
+      const data = await this.client.get(redisKey);
+      if (!data) {
+        continue;
+      }
+      try {
+        const item = JSON.parse(data);
+        if (item.expiresAt <= Date.now()) {
+          await this.client.del(redisKey);
+          cleaned++;
+        }
+      } catch {
+        await this.client.del(redisKey);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  async getStats() {
+    const allKeys = await this.keys();
+    const entries = [];
+    for (const key of allKeys) {
+      const item = await this.get(key);
+      if (item) {
+        entries.push({
+          key,
+          expiresAt: item.expiresAt,
+          createdAt: item.createdAt
+        });
+      }
+    }
+    return {
+      size: entries.length,
+      entries
+    };
+  }
+};
+
+// src/plugins/cache/plugin.ts
+var CachePlugin = class {
+  name = "cache-plugin";
+  priority = 400 /* PERFORMANCE */;
+  // 性能优化插件，优先级较低
+  // 缓存适配器
+  adapter;
+  // 清理定时器
+  cleanupTimer = null;
+  // 引擎引用
+  engine = null;
+  // 模块配置
+  defaultTtl = 6e4;
+  // 默认1分钟
+  cacheEnabled = true;
+  cleanupInterval = 6e4;
+  // 默认1分钟清理一次
+  /**
+   * 构造函数
+   * @param adapter 缓存适配器，如果不提供则使用默认的内存缓存适配器
+   */
+  constructor(adapter) {
+    this.adapter = adapter || new MemoryCacheAdapter();
+  }
+  /**
+   * 声明Module配置Schema
+   */
+  getModuleOptionsSchema() {
+    return {
+      _type: {},
+      validate: (options) => {
+        if (options.cacheDefaultTtl !== void 0 && options.cacheDefaultTtl < 0) {
+          return `cacheDefaultTtl must be >= 0`;
+        }
+        if (options.cacheCleanupInterval !== void 0 && options.cacheCleanupInterval < 0) {
+          return `cacheCleanupInterval must be >= 0`;
+        }
+        return true;
+      }
+    };
+  }
+  /**
+   * 引擎初始化前钩子
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("CachePlugin initialized cache storage");
+  }
+  /**
+   * Handler加载后钩子
+   * 拦截带有 type="cache" 的 Handler，包装原始方法实现缓存逻辑
+   */
+  onHandlerLoad(handlers) {
+    const cacheHandlers = handlers.filter(
+      (handler) => handler.type === "cache"
+    );
+    logger_default.info(`Found ${cacheHandlers.length} cache handler(s)`);
+    for (const handler of cacheHandlers) {
+      const methodName = handler.methodName;
+      const moduleClass = handler.module;
+      const cacheOptions = handler.options || {};
+      const moduleMetadata = this.engine?.getModules().find((m) => m.clazz === moduleClass);
+      if (!moduleMetadata) {
+        logger_default.warn(`Module metadata not found for ${moduleClass.name}`);
+        continue;
+      }
+      const moduleOptions = moduleMetadata.options;
+      const moduleDefaultTtl = moduleOptions?.cacheDefaultTtl ?? this.defaultTtl;
+      const moduleCacheEnabled = moduleOptions?.cacheEnabled ?? this.cacheEnabled;
+      const ttl = cacheOptions.ttl ?? moduleDefaultTtl;
+      const enabled = cacheOptions.enabled ?? moduleCacheEnabled;
+      if (!enabled) {
+        logger_default.info(`Cache disabled for ${moduleClass.name}.${methodName}`);
+        continue;
+      }
+      const moduleName = moduleMetadata.name;
+      handler.wrap(async (next, instance, ...args) => {
+        const cacheKey = this.generateCacheKey(
+          moduleName,
+          methodName,
+          cacheOptions.key,
+          args
+        );
+        const cached = await this.adapter.get(cacheKey);
+        if (cached) {
+          logger_default.debug(`Cache hit for ${cacheKey}`);
+          return cached.value;
+        }
+        logger_default.debug(`Cache miss for ${cacheKey}`);
+        const result = await next();
+        await this.adapter.set(cacheKey, {
+          value: result,
+          expiresAt: Date.now() + ttl,
+          createdAt: Date.now()
+        });
+        return result;
+      });
+      logger_default.info(
+        `Wrapped ${moduleClass.name}.${methodName} with cache (TTL: ${ttl}ms)`
+      );
+    }
+  }
+  /**
+   * 引擎启动前钩子
+   */
+  onBeforeStart(engine) {
+    const moduleOptions = engine.options;
+    const cleanupInterval = moduleOptions?.cacheCleanupInterval ?? this.cleanupInterval;
+    if (cleanupInterval > 0) {
+      this.cleanupTimer = setInterval(() => {
+        this.cleanup().catch((error) => {
+          logger_default.error("Cache cleanup failed", error);
+        });
+      }, cleanupInterval);
+      logger_default.info(
+        `Started cache cleanup timer (interval: ${cleanupInterval}ms)`
+      );
+    }
+  }
+  /**
+   * 引擎停止时钩子
+   */
+  async onDestroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    await this.adapter.clear();
+    logger_default.info("Cache storage cleared");
+  }
+  /**
+   * 生成缓存键
+   * @param moduleName 模块名
+   * @param methodName 方法名
+   * @param keyFunction 可选的 key 函数
+   * @param args 方法参数
+   * @returns 缓存键（格式：模块名:方法名:hash）
+   */
+  generateCacheKey(moduleName, methodName, keyFunction, args) {
+    const keyData = keyFunction ? keyFunction(...args) : args;
+    const serialized = ejson.stringify(keyData);
+    const hash = createHash("sha256").update(serialized).digest("hex");
+    return `${moduleName}:${methodName}:${hash}`;
+  }
+  /**
+   * 清理过期缓存
+   */
+  async cleanup() {
+    if (typeof this.adapter.cleanupExpired === "function") {
+      const cleaned = await this.adapter.cleanupExpired();
+      if (cleaned > 0) {
+        logger_default.debug(`Cleaned up ${cleaned} expired cache entry(ies)`);
+      }
+    } else {
+      const now = Date.now();
+      let cleaned = 0;
+      const keys = await this.adapter.keys();
+      for (const key of keys) {
+        const item = await this.adapter.get(key);
+        if (!item || item.expiresAt <= now) {
+          await this.adapter.delete(key);
+          cleaned++;
+        }
+      }
+      if (cleaned > 0) {
+        logger_default.debug(`Cleaned up ${cleaned} expired cache entry(ies)`);
+      }
+    }
+  }
+  /**
+   * 获取缓存统计信息
+   */
+  async getStats() {
+    return await this.adapter.getStats();
+  }
+  /**
+   * 清空所有缓存
+   */
+  async clear() {
+    await this.adapter.clear();
+    logger_default.info("All cache cleared");
+  }
+  /**
+   * 删除指定的缓存项
+   */
+  async delete(key) {
+    return await this.adapter.delete(key);
+  }
+};
+
+// src/plugins/cache/decorator.ts
+function Cache(options = {}) {
+  return Handler({
+    type: "cache",
+    options: {
+      ttl: options.ttl ?? 6e4,
+      // 默认1分钟
+      key: options.key,
+      // key 函数
+      enabled: options.enabled ?? true
+    }
+  });
+}
+
+// src/plugins/graceful-shutdown/plugin.ts
+var GracefulShutdownPlugin = class {
+  name = "graceful-shutdown-plugin";
+  priority = 50 /* SYSTEM */;
+  // 系统级插件，最高优先级
+  engine = null;
+  options;
+  // 正在执行的处理器计数
+  activeHandlers = 0;
+  // 是否正在停机
+  isShuttingDown = false;
+  // 停机超时定时器
+  shutdownTimer = null;
+  // 信号监听器（用于清理）
+  signalListeners = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = {
+      shutdownTimeout: options?.shutdownTimeout ?? 10 * 60 * 1e3,
+      // 默认10分钟
+      enabled: options?.enabled ?? true
+    };
+  }
+  /**
+   * 引擎初始化钩子
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("GracefulShutdownPlugin initialized");
+  }
+  /**
+   * Handler加载钩子：拦截所有处理器，追踪执行状态
+   */
+  onHandlerLoad(handlers) {
+    if (!this.options.enabled) {
+      return;
+    }
+    for (const handler of handlers) {
+      handler.wrap(async (next, instance, ...args) => {
+        if (this.isShuttingDown) {
+          throw new Error("Service is shutting down, new requests are not accepted");
+        }
+        this.incrementActiveHandlers();
+        try {
+          const result = await next();
+          return result;
+        } catch (error) {
+          throw error;
+        } finally {
+          this.decrementActiveHandlers();
+        }
+      });
+    }
+    logger_default.info(
+      `GracefulShutdownPlugin: Tracking ${handlers.length} handler(s)`
+    );
+  }
+  /**
+   * 引擎启动后钩子：注册系统信号监听器
+   */
+  async onAfterStart(engine) {
+    if (!this.options.enabled) {
+      return;
+    }
+    this.engine = engine;
+    this.registerSignalHandlers();
+    logger_default.info(
+      `GracefulShutdownPlugin: Signal handlers registered, shutdown timeout: ${this.options.shutdownTimeout}ms`
+    );
+  }
+  /**
+   * 注册系统信号监听器
+   */
+  registerSignalHandlers() {
+    const signals = [
+      "SIGINT",
+      // Ctrl+C (Unix/Linux/Mac)
+      "SIGTERM",
+      // 终止信号 (Unix/Linux/Mac)
+      "SIGBREAK"
+      // Ctrl+Break (Windows)
+    ];
+    for (const signal of signals) {
+      if (process.platform === "win32" && signal === "SIGTERM") {
+        continue;
+      }
+      const handler = () => {
+        logger_default.info(`GracefulShutdownPlugin: Received ${signal} signal`);
+        this.initiateShutdown();
+      };
+      process.on(signal, handler);
+      this.signalListeners.set(signal, handler);
+    }
+  }
+  /**
+   * 增加活跃处理器计数
+   */
+  incrementActiveHandlers() {
+    this.activeHandlers++;
+    logger_default.debug(
+      `GracefulShutdownPlugin: Active handlers: ${this.activeHandlers}`
+    );
+  }
+  /**
+   * 减少活跃处理器计数
+   */
+  decrementActiveHandlers() {
+    this.activeHandlers = Math.max(0, this.activeHandlers - 1);
+    logger_default.debug(
+      `GracefulShutdownPlugin: Active handlers: ${this.activeHandlers}`
+    );
+    if (this.isShuttingDown && this.activeHandlers === 0) {
+      logger_default.info(
+        "GracefulShutdownPlugin: All handlers completed, proceeding with shutdown"
+      );
+      this.completeShutdown();
+    }
+  }
+  /**
+   * 启动优雅停机流程
+   */
+  async initiateShutdown() {
+    if (this.isShuttingDown) {
+      return;
+    }
+    this.isShuttingDown = true;
+    logger_default.info(
+      `GracefulShutdownPlugin: Initiating graceful shutdown, waiting for ${this.activeHandlers} active handler(s) to complete`
+    );
+    if (this.activeHandlers === 0) {
+      logger_default.info(
+        "GracefulShutdownPlugin: No active handlers, proceeding with shutdown immediately"
+      );
+      await this.completeShutdown();
+      return;
+    }
+    this.shutdownTimer = setTimeout(() => {
+      logger_default.warn(
+        `GracefulShutdownPlugin: Shutdown timeout (${this.options.shutdownTimeout}ms) reached, forcing shutdown`
+      );
+      this.completeShutdown();
+    }, this.options.shutdownTimeout);
+  }
+  /**
+   * 完成停机流程
+   */
+  async completeShutdown() {
+    if (this.shutdownTimer) {
+      clearTimeout(this.shutdownTimer);
+      this.shutdownTimer = null;
+    }
+    this.cleanupSignalHandlers();
+    if (this.engine) {
+      try {
+        await this.engine.stop();
+        logger_default.info("GracefulShutdownPlugin: Engine stopped successfully");
+      } catch (error) {
+        logger_default.error("GracefulShutdownPlugin: Failed to stop engine", error);
+      }
+    }
+    logger_default.info("GracefulShutdownPlugin: Process exiting");
+    process.exit(0);
+  }
+  /**
+   * 清理信号监听器
+   */
+  cleanupSignalHandlers() {
+    for (const [signal, handler] of this.signalListeners.entries()) {
+      process.removeListener(signal, handler);
+    }
+    this.signalListeners.clear();
+  }
+  /**
+   * 引擎销毁钩子：清理资源
+   */
+  async onDestroy() {
+    this.cleanupSignalHandlers();
+    if (this.shutdownTimer) {
+      clearTimeout(this.shutdownTimer);
+      this.shutdownTimer = null;
+    }
+    logger_default.info("GracefulShutdownPlugin: Cleaned up");
+  }
+  /**
+   * 获取当前活跃处理器数量（用于测试和监控）
+   */
+  getActiveHandlersCount() {
+    return this.activeHandlers;
+  }
+  /**
+   * 检查是否正在停机（用于测试和监控）
+   */
+  isShuttingDownNow() {
+    return this.isShuttingDown;
+  }
+};
+
+// src/plugins/schedule/types.ts
+var ScheduleMode = /* @__PURE__ */ ((ScheduleMode2) => {
+  ScheduleMode2["FIXED_RATE"] = "FIXED_RATE";
+  ScheduleMode2["FIXED_DELAY"] = "FIXED_DELAY";
+  return ScheduleMode2;
+})(ScheduleMode || {});
+
+// src/plugins/schedule/decorator.ts
+function Schedule(options) {
+  return Handler({
+    type: "schedule",
+    options: {
+      interval: options.interval,
+      mode: options.mode || "FIXED_RATE" /* FIXED_RATE */
+    }
+  });
+}
+
+// src/plugins/schedule/mock-etcd.ts
+var MockEtcd3 = class {
+  elections = /* @__PURE__ */ new Map();
+  election(key, ttl) {
+    if (!this.elections.has(key)) {
+      this.elections.set(key, new MockElection(key));
+    }
+    return this.elections.get(key);
+  }
+  close() {
+  }
+  delete() {
+    return {
+      prefix: () => Promise.resolve()
+    };
+  }
+  get(key) {
+    return {
+      string: () => Promise.resolve(null)
+    };
+  }
+  getElection(key) {
+    return this.elections.get(key);
+  }
+  clearElections() {
+    this.elections.clear();
+  }
+};
+var MockElection = class {
+  constructor(key) {
+    this.key = key;
+  }
+  observers = [];
+  campaigns = [];
+  currentLeader = null;
+  async observe() {
+    const observer = new MockObserver(this);
+    this.observers.push(observer);
+    if (this.currentLeader) {
+      setTimeout(() => {
+        observer.notifyChange(this.currentLeader);
+      }, 0);
+    }
+    return observer;
+  }
+  campaign(candidate) {
+    const campaign = new MockCampaign(candidate, this);
+    this.campaigns.push(campaign);
+    if (!this.currentLeader) {
+      setTimeout(() => {
+        this.setLeader(candidate);
+      }, 50);
+    }
+    return campaign;
+  }
+  setLeader(leader) {
+    this.currentLeader = leader;
+    for (const observer of this.observers) {
+      observer.notifyChange(leader);
+    }
+    setTimeout(() => {
+      for (const campaign of this.campaigns) {
+        if (campaign.candidate === leader && !campaign.resigned) {
+          campaign.notifyElected();
+        }
+      }
+    }, 50);
+  }
+  getCurrentLeader() {
+    return this.currentLeader;
+  }
+};
+var MockObserver = class {
+  constructor(election) {
+    this.election = election;
+  }
+  changeCallbacks = [];
+  disconnectedCallbacks = [];
+  errorCallbacks = [];
+  on(event, callback) {
+    if (event === "change") {
+      this.changeCallbacks.push(callback);
+    } else if (event === "disconnected") {
+      this.disconnectedCallbacks.push(callback);
+    } else if (event === "error") {
+      this.errorCallbacks.push(callback);
+    }
+    return this;
+  }
+  notifyChange(leader) {
+    for (const callback of this.changeCallbacks) {
+      callback(leader);
+    }
+  }
+};
+var MockCampaign = class {
+  constructor(candidate, election) {
+    this.candidate = candidate;
+    this.election = election;
+  }
+  errorCallbacks = [];
+  electedCallbacks = [];
+  resigned = false;
+  on(event, callback) {
+    if (event === "error") {
+      this.errorCallbacks.push(callback);
+    } else if (event === "elected") {
+      this.electedCallbacks.push(callback);
+    }
+    return this;
+  }
+  notifyElected() {
+    if (!this.resigned) {
+      for (const callback of this.electedCallbacks) {
+        callback();
+      }
+    }
+  }
+  notifyError(error) {
+    for (const callback of this.errorCallbacks) {
+      callback(error);
+    }
+  }
+  async resign() {
+    this.resigned = true;
+  }
+};
+var tracer = trace.getTracer("scheduler");
+var Scheduler = class {
+  constructor(etcdClient) {
+    this.etcdClient = etcdClient;
+  }
+  campaigns = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  isLeader = /* @__PURE__ */ new Map();
+  /**
+   * 启动调度任务
+   */
+  async startSchedule(serviceId, moduleName, methodName, electionKey, metadata, method) {
+    const election = this.etcdClient.election(electionKey, 10);
+    const observe = await election.observe();
+    observe.on("change", (leader) => {
+      const isLeader = leader === serviceId;
+      this.isLeader.set(serviceId, isLeader);
+      if (!isLeader) {
+        this.stopTimer(serviceId);
+      }
+    });
+    const campaign = election.campaign(serviceId);
+    this.campaigns.set(serviceId, campaign);
+    campaign.on("error", (error) => {
+      logger_default.error(`Error in campaign for ${moduleName}.${methodName}:`, error);
+    });
+    campaign.on("elected", () => {
+      this.isLeader.set(serviceId, true);
+      this.startTimer(serviceId, metadata, moduleName, method);
+      logger_default.info(`become leader for ${moduleName}.${methodName}`);
+    });
+  }
+  /**
+   * 启动定时器
+   */
+  startTimer(serviceId, metadata, moduleName, method) {
+    this.stopTimer(serviceId);
+    const wrappedMethod = async () => {
+      tracer.startActiveSpan(
+        `ScheduleTask ${moduleName}.${metadata.name}`,
+        { root: true },
+        async (span) => {
+          span.setAttribute("serviceId", serviceId);
+          span.setAttribute("methodName", metadata.name);
+          span.setAttribute("moduleName", moduleName);
+          span.setAttribute("interval", metadata.interval);
+          span.setAttribute("mode", metadata.mode);
+          try {
+            await method();
+          } catch (error) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: error.message
+            });
+            logger_default.error(
+              `Error executing schedule task ${moduleName}.${metadata.name}:`,
+              error
+            );
+          } finally {
+            span.setStatus({ code: SpanStatusCode.OK });
+            span.end();
+          }
+        }
+      );
+    };
+    if (metadata.mode === "FIXED_DELAY" /* FIXED_DELAY */) {
+      const runTask = async () => {
+        if (!this.isLeader.get(serviceId)) return;
+        try {
+          await wrappedMethod();
+        } finally {
+          this.timers.set(serviceId, setTimeout(runTask, metadata.interval));
+        }
+      };
+      runTask();
+    } else {
+      this.timers.set(
+        serviceId,
+        setInterval(async () => {
+          if (!this.isLeader.get(serviceId)) return;
+          await wrappedMethod();
+        }, metadata.interval)
+      );
+    }
+  }
+  /**
+   * 停止定时器
+   */
+  stopTimer(serviceId) {
+    const timer = this.timers.get(serviceId);
+    if (timer) {
+      clearTimeout(timer);
+      clearInterval(timer);
+      this.timers.delete(serviceId);
+    }
+  }
+  /**
+   * 停止所有调度任务
+   */
+  async stop() {
+    for (const serviceId of this.timers.keys()) {
+      this.stopTimer(serviceId);
+    }
+    for (const [serviceId, campaign] of this.campaigns.entries()) {
+      try {
+        await campaign.resign().catch(() => {
+        });
+      } catch (error) {
+        logger_default.error(`Error stopping schedule ${serviceId}:`, error);
+      } finally {
+        this.campaigns.delete(serviceId);
+        this.isLeader.delete(serviceId);
+      }
+    }
+  }
+};
+
+// src/plugins/schedule/utils.ts
+function extractScheduleMetadata(handlers) {
+  const result = /* @__PURE__ */ new Map();
+  const scheduleHandlers = handlers.filter(
+    (handler) => handler.type === "schedule"
+  );
+  for (const handler of scheduleHandlers) {
+    const moduleClass = handler.module;
+    const methodName = handler.methodName;
+    const options = handler.options || {};
+    if (!result.has(moduleClass)) {
+      result.set(moduleClass, /* @__PURE__ */ new Map());
+    }
+    const moduleMetadata = result.get(moduleClass);
+    moduleMetadata.set(methodName, {
+      name: methodName,
+      interval: options.interval,
+      mode: options.mode || "FIXED_RATE" /* FIXED_RATE */
+    });
+  }
+  return result;
+}
+
+// src/plugins/schedule/plugin.ts
+var SchedulePlugin = class {
+  name = "schedule-plugin";
+  priority = 300 /* BUSINESS */;
+  // 业务逻辑优先级
+  engine;
+  scheduler = null;
+  etcdClient = null;
+  scheduleHandlers = [];
+  useMockEtcd = false;
+  constructor(options) {
+    if (options?.useMockEtcd) {
+      this.useMockEtcd = true;
+      this.etcdClient = new MockEtcd3();
+      logger_default.info("SchedulePlugin: Using MockEtcd3 for local development/testing");
+    } else if (options?.etcdClient) {
+      this.etcdClient = options.etcdClient;
+    }
+  }
+  /**
+   * 引擎初始化钩子
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("SchedulePlugin initialized");
+  }
+  /**
+   * Handler加载钩子：收集所有调度任务
+   */
+  onHandlerLoad(handlers) {
+    this.scheduleHandlers = handlers.filter(
+      (handler) => handler.type === "schedule"
+    );
+    logger_default.info(
+      `SchedulePlugin: Found ${this.scheduleHandlers.length} schedule handler(s)`
+    );
+  }
+  /**
+   * 引擎启动后钩子：启动所有调度任务
+   */
+  async onAfterStart(engine) {
+    if (!this.etcdClient) {
+      logger_default.warn(
+        "SchedulePlugin: etcdClient not configured and useMockEtcd is false, schedule tasks will not start"
+      );
+      return;
+    }
+    this.scheduler = new Scheduler(this.etcdClient);
+    const modules = engine.getModules();
+    if (!this.scheduleHandlers) {
+      logger_default.warn(
+        "SchedulePlugin: No schedule handlers found, schedule tasks will not start"
+      );
+      return;
+    }
+    const scheduleMetadataMap = extractScheduleMetadata(this.scheduleHandlers);
+    const serviceId = `${engine.options.name}-${Date.now()}-${Math.random()}`;
+    for (const moduleMetadata of modules) {
+      const moduleClass = moduleMetadata.clazz;
+      const moduleName = moduleMetadata.name;
+      const moduleInstance = engine.get(moduleClass);
+      const moduleScheduleMetadata = scheduleMetadataMap.get(moduleClass);
+      if (!moduleScheduleMetadata || moduleScheduleMetadata.size === 0) {
+        continue;
+      }
+      for (const [methodName, metadata] of moduleScheduleMetadata.entries()) {
+        const method = moduleInstance[methodName];
+        if (typeof method !== "function") {
+          logger_default.warn(
+            `SchedulePlugin: Method ${moduleName}.${methodName} is not a function, skipping`
+          );
+          continue;
+        }
+        const electionKey = `/schedule/${engine.options.name}/${moduleName}/${methodName}`;
+        const taskServiceId = `${serviceId}-${moduleName}-${methodName}`;
+        try {
+          await this.scheduler.startSchedule(
+            taskServiceId,
+            moduleName,
+            methodName,
+            electionKey,
+            metadata,
+            method.bind(moduleInstance)
+          );
+          logger_default.info(
+            `SchedulePlugin: Started schedule task ${moduleName}.${methodName} (interval: ${metadata.interval}ms, mode: ${metadata.mode})`
+          );
+        } catch (error) {
+          logger_default.error(
+            `SchedulePlugin: Failed to start schedule task ${moduleName}.${methodName}:`,
+            error
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 引擎销毁钩子：停止所有调度任务
+   */
+  async onDestroy() {
+    if (this.scheduler) {
+      try {
+        await this.scheduler.stop();
+        logger_default.info("SchedulePlugin: All schedule tasks stopped");
+      } catch (error) {
+        logger_default.error("SchedulePlugin: Error stopping schedule tasks:", error);
+      }
+    }
+  }
+};
+async function formatCode(code) {
+  try {
+    return prettier.format(code, { parser: "typescript" });
+  } catch {
+    return code;
+  }
+}
+
+// src/plugins/client-code/generator.ts
+function getZodTypeString(schema, defaultOptional = false) {
+  function processType(type) {
+    if (!type) {
+      return "unknown";
+    }
+    const def = type._def;
+    const typeName = def.type;
+    if (typeName === "nullable") {
+      return `${processType(def.innerType)} | null`;
+    }
+    if (typeName === "optional") {
+      return processType(def.innerType);
+    }
+    if (typeName === "pipe" && def.in) {
+      return processType(def.in);
+    }
+    if (typeName === "effects" && def.schema) {
+      return processType(def.schema);
+    }
+    switch (typeName) {
+      case "string": {
+        return "string";
+      }
+      case "number": {
+        return "number";
+      }
+      case "bigint": {
+        return "bigint";
+      }
+      case "boolean": {
+        return "boolean";
+      }
+      case "array": {
+        const elementType = processType(def.element);
+        return `${elementType}[]`;
+      }
+      case "date": {
+        return "Date";
+      }
+      case "object": {
+        const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+        const props = Object.entries(shape).map(([key, value]) => {
+          if (key.includes("-")) {
+            key = `'${key}'`;
+          }
+          const fieldDef = value._def;
+          const fieldTypeName = fieldDef.type;
+          const isOptional = fieldTypeName === "optional";
+          const isDefault = defaultOptional && fieldTypeName === "default";
+          const fieldType = processType(
+            isOptional ? fieldDef.innerType : value
+          );
+          return `${key}${isOptional || isDefault ? "?" : ""}: ${fieldType}`;
+        }).join("; ");
+        return `{ ${props} }`;
+      }
+      case "union": {
+        return def.options.map((opt) => processType(opt)).join(" | ");
+      }
+      case "null": {
+        return "null";
+      }
+      case "promise": {
+        return `Promise<${processType(def.type)}>`;
+      }
+      case "void": {
+        return "void";
+      }
+      case "record": {
+        if (def.valueType) {
+          const keyType = def.keyType ? processType(def.keyType) : "string";
+          return `Record<${keyType}, ${processType(def.valueType)}>`;
+        } else if (def.keyType) {
+          return `Record<string, ${processType(def.keyType)}>`;
+        }
+        return "Record<string, any>";
+      }
+      case "map": {
+        return `Map<${processType(def.keyType)}, ${processType(
+          def.valueType
+        )}>`;
+      }
+      case "any": {
+        return "any";
+      }
+      case "unknown": {
+        return "unknown";
+      }
+      case "enum": {
+        const values = def.entries ? Object.values(def.entries) : [];
+        return "(" + values.map((opt) => `"${String(opt)}"`).join(" | ") + ")";
+      }
+      case "default": {
+        return processType(def.innerType);
+      }
+      default: {
+        if (type.safeParse(new Uint8Array()).success) {
+          return "Uint8Array";
+        }
+        return "unknown";
+      }
+    }
+  }
+  return processType(schema);
+}
+async function generateClientCode(modules) {
+  const imports = [
+    "// \u8FD9\u4E2A\u6587\u4EF6\u662F\u81EA\u52A8\u751F\u6210\u7684\uFF0C\u8BF7\u4E0D\u8981\u624B\u52A8\u4FEE\u6539",
+    "",
+    'import { MicroserviceClient as BaseMicroserviceClient } from "imean-service-client";',
+    'export * from "imean-service-client";',
+    ""
+  ].join("\n");
+  function toPascalCase(moduleName) {
+    return moduleName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  function toCamelCase(moduleName) {
+    const parts = moduleName.split("-");
+    return parts[0] + parts.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  const interfaces = Object.entries(modules).map(([name, module]) => {
+    const methods = Object.entries(module.actions).map(([actionName, action]) => {
+      if (!action.params) {
+        throw new Error(`Missing params for action ${actionName}`);
+      }
+      const paramNames = action.paramNames || [];
+      const params = action.params.map((param, index) => {
+        const paramName = paramNames[index] || param.description || `arg${index}`;
+        const paramDef = param._def;
+        const isOptional = param.isOptional();
+        const hasDefault = paramDef?.type === "default";
+        return `${paramName}${isOptional || hasDefault ? "?" : ""}: ${getZodTypeString(
+          param,
+          true
+        )}`;
+      }).join(", ");
+      const returnType = action.returns ? getZodTypeString(action.returns) : "void";
+      return `
+        /**
+         * ${action.description || ""}
+         */
+        ${actionName}: (${params}) => Promise<${action.stream ? `AsyncIterable<${returnType}>` : returnType}>;`;
+    }).join("\n    ");
+    const interfaceName = `${toPascalCase(name)}Module`;
+    return `export interface ${interfaceName} {
+    ${methods}
+}`;
+  }).join("\n\n");
+  const clientClass = `export class MicroserviceClient extends BaseMicroserviceClient {
+  constructor(options: any) {
+    super(options);
+  }
+
+  ${Object.entries(modules).map(([name, module]) => {
+    const methods = Object.entries(module.actions).map(([actionName, action]) => {
+      return `${actionName}: { idempotent: ${!!action.idempotence}, stream: ${!!action.stream} }`;
+    }).join(",\n      ");
+    const propertyName = toCamelCase(name);
+    const interfaceName = `${toPascalCase(name)}Module`;
+    return `public readonly ${propertyName} = this.registerModule<${interfaceName}>("${name}", {
+      ${methods}
+    });`;
+  }).join("\n\n  ")}
+}`;
+  return await formatCode([imports, interfaces, clientClass].join("\n\n"));
+}
+
+// src/plugins/client-code/utils.ts
+function extractParamNames(func) {
+  if (!func || typeof func !== "function") {
+    return [];
+  }
+  try {
+    const funcStr = func.toString();
+    const match = funcStr.match(
+      /(?:async\s+)?(?:function\s+\w*\s*)?\(([^)]*)\)|(?:async\s+)?\(([^)]*)\)\s*=>/
+    );
+    if (!match) {
+      return [];
+    }
+    const paramsStr = match[1] || match[2] || "";
+    if (!paramsStr.trim()) {
+      return [];
+    }
+    return paramsStr.split(",").map((param) => {
+      return param.replace(/\/\*.*?\*\//g, "").replace(/\/\/.*$/g, "").replace(/:\s*[^=,]+/g, "").replace(/\s*=\s*[^,]+/g, "").trim();
+    }).filter((name) => name.length > 0);
+  } catch (error) {
+    return [];
+  }
+}
+function convertHandlersToModuleInfo(handlers) {
+  const modules = {};
+  const actionHandlers = handlers.filter(
+    (handler) => handler.type === "action"
+  );
+  for (const handler of actionHandlers) {
+    const actionOptions = handler.options;
+    const moduleClass = handler.module;
+    const methodName = handler.methodName;
+    const moduleName = moduleClass.name.toLowerCase().replace(/service$/, "");
+    if (!modules[moduleName]) {
+      modules[moduleName] = {
+        name: moduleName,
+        actions: {}
+      };
+    }
+    const paramNames = extractParamNames(handler.method);
+    modules[moduleName].actions[methodName] = {
+      description: actionOptions.description,
+      params: actionOptions.params || [],
+      returns: actionOptions.returns,
+      stream: actionOptions.stream || false,
+      idempotence: actionOptions.idempotence || false,
+      paramNames
+    };
+  }
+  return modules;
+}
+function convertHandlersToModuleInfoWithMetadata(handlers, getModuleMetadata) {
+  const modules = {};
+  const actionHandlers = handlers.filter(
+    (handler) => handler.type === "action"
+  );
+  for (const handler of actionHandlers) {
+    const actionOptions = handler.options;
+    const moduleClass = handler.module;
+    const methodName = handler.methodName;
+    const moduleMetadata = getModuleMetadata(moduleClass);
+    if (!moduleMetadata) {
+      continue;
+    }
+    const moduleName = moduleMetadata.name;
+    if (!modules[moduleName]) {
+      modules[moduleName] = {
+        name: moduleName,
+        actions: {}
+      };
+    }
+    const paramNames = extractParamNames(handler.method);
+    modules[moduleName].actions[methodName] = {
+      description: actionOptions.description,
+      params: actionOptions.params || [],
+      returns: actionOptions.returns,
+      stream: actionOptions.stream || false,
+      idempotence: actionOptions.idempotence || false,
+      paramNames
+    };
+  }
+  return modules;
+}
+
+// src/plugins/client-code/plugin.ts
+var ClientCodePlugin = class {
+  name = "client-code-plugin";
+  priority = 1e3 /* ROUTE */;
+  // 路由插件优先级，在 ActionPlugin 之后
+  engine;
+  actionHandlers = [];
+  generatedCode = null;
+  clientSavePath;
+  constructor(options) {
+    this.clientSavePath = options?.clientSavePath;
+  }
+  /**
+   * 引擎初始化钩子
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("ClientCodePlugin initialized");
+  }
+  /**
+   * Handler加载钩子：收集所有 Action handlers
+   */
+  onHandlerLoad(handlers) {
+    const actionHandlers = handlers.filter(
+      (handler) => handler.type === "action"
+    );
+    this.actionHandlers = actionHandlers;
+    logger_default.info(
+      `ClientCodePlugin collected ${actionHandlers.length} action handler(s)`
+    );
+  }
+  /**
+   * 引擎启动后钩子：注册客户端代码下载路由
+   */
+  async onAfterStart(engine) {
+    await this.generateCode();
+    const prefix = engine.options.prefix || "";
+    const clientPath = prefix ? `${prefix}/client.ts` : "/client.ts";
+    const hono = engine.getHono();
+    hono.get(clientPath, async (ctx) => {
+      if (!this.generatedCode) {
+        await this.generateCode();
+      }
+      return ctx.text(this.generatedCode || "", 200, {
+        "Content-Type": "text/typescript; charset=utf-8",
+        "Content-Disposition": `attachment; filename="client.ts"`
+      });
+    });
+    logger_default.info(`Client code available at ${clientPath}`);
+  }
+  /**
+   * 生成客户端代码
+   */
+  async generateCode() {
+    try {
+      const getModuleMetadata = (moduleClass) => {
+        const modules2 = this.engine.getModules();
+        const moduleMetadata = modules2.find((m) => m.clazz === moduleClass);
+        return moduleMetadata ? { name: moduleMetadata.name } : void 0;
+      };
+      const modules = convertHandlersToModuleInfoWithMetadata(
+        this.actionHandlers,
+        getModuleMetadata
+      );
+      this.generatedCode = await generateClientCode(modules);
+      logger_default.debug(
+        `Generated client code for ${Object.keys(modules).length} module(s)`
+      );
+      if (this.clientSavePath && this.generatedCode) {
+        await this.saveCodeToFile(this.clientSavePath, this.generatedCode);
+      }
+    } catch (error) {
+      logger_default.error("Failed to generate client code", error);
+      this.generatedCode = "// Error: Failed to generate client code";
+    }
+  }
+  /**
+   * 保存代码到文件
+   */
+  async saveCodeToFile(path, code) {
+    try {
+      const dir = dirname(path);
+      await promises.mkdir(dir, { recursive: true });
+      await promises.writeFile(path, code, "utf-8");
+      logger_default.info(`Client code saved to ${path}`);
+    } catch (error) {
+      logger_default.error(`Failed to save client code to ${path}`, error);
+    }
+  }
+};
+var EtcdConfigStorage = class {
+  etcdClient;
+  prefix;
+  watchers = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  constructor(etcdClient, prefix = "/config") {
+    this.etcdClient = etcdClient;
+    this.prefix = prefix;
+  }
+  /**
+   * 构建完整的 etcd 键
+   */
+  buildKey(key) {
+    return `${this.prefix}/${key}`;
+  }
+  /**
+   * 获取配置
+   */
+  async get(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const value = await this.etcdClient.get(fullKey).string();
+      if (value === null || value === void 0) {
+        logger_default.warn(`get config from etcd: ${fullKey} - not found`);
+        return null;
+      }
+      if (value.trim() === "") {
+        return null;
+      }
+      const parsed = ejson.parse(value);
+      this.cache.set(key, parsed);
+      return parsed;
+    } catch (error) {
+      logger_default.error(`Failed to get config from etcd: ${key}`, error);
+      return this.cache.get(key) || null;
+    }
+  }
+  /**
+   * 同步获取缓存的配置（不访问 etcd）
+   * 用于 configProxy 的同步访问
+   */
+  getCached(key) {
+    return this.cache.get(key);
+  }
+  /**
+   * 设置配置
+   */
+  async set(key, value, metadata) {
+    try {
+      const fullKey = this.buildKey(key);
+      const serialized = ejson.stringify(value);
+      await this.etcdClient.put(fullKey).value(serialized);
+      this.cache.set(key, value);
+    } catch (error) {
+      logger_default.error(`Failed to set config in etcd: ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * 删除配置
+   */
+  async delete(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      await this.etcdClient.delete().key(fullKey);
+      this.cache.delete(key);
+    } catch (error) {
+      logger_default.error(`Failed to delete config from etcd: ${key}`, error);
+      throw error;
+    }
+  }
+  /**
+   * 获取所有配置
+   */
+  async getAll(prefix) {
+    try {
+      const searchPrefix = prefix ? this.buildKey(prefix) : this.buildKey("");
+      const response = await this.etcdClient.getAll().prefix(searchPrefix).strings();
+      const result = /* @__PURE__ */ new Map();
+      for (const key in response) {
+        const cleanKey = key.replace(this.prefix + "/", "");
+        const value = ejson.parse(response[key]);
+        result.set(cleanKey, value);
+        this.cache.set(cleanKey, value);
+      }
+      return result;
+    } catch (error) {
+      logger_default.error(`Failed to get all configs from etcd`, error);
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * 监听配置变化
+   */
+  watch(key, callback) {
+    const fullKey = this.buildKey(key);
+    if (!this.watchers.has(key)) {
+      this.watchers.set(key, /* @__PURE__ */ new Set());
+      this.etcdClient.watch().key(fullKey).create().then((watcher) => {
+        watcher.on("put", (kv) => {
+          try {
+            const newValue = ejson.parse(kv.value.toString());
+            const oldValue = this.cache.get(key);
+            this.cache.set(key, newValue);
+            const callbacks = this.watchers.get(key);
+            if (callbacks) {
+              callbacks.forEach((cb) => {
+                try {
+                  cb(newValue, oldValue);
+                } catch (error) {
+                  logger_default.error(
+                    `Config watch callback error for key: ${key}`,
+                    error
+                  );
+                }
+              });
+            }
+          } catch (error) {
+            logger_default.error(`Failed to parse config value for key: ${key}`, error);
+          }
+        });
+        watcher.on("delete", () => {
+          const oldValue = this.cache.get(key);
+          this.cache.delete(key);
+          const callbacks = this.watchers.get(key);
+          if (callbacks) {
+            callbacks.forEach((cb) => {
+              try {
+                cb(null, oldValue);
+              } catch (error) {
+                logger_default.error(
+                  `Config watch callback error for key: ${key}`,
+                  error
+                );
+              }
+            });
+          }
+        });
+      }).catch((error) => {
+        logger_default.error(`Failed to create etcd watcher for key: ${key}`, error);
+      });
+    }
+    this.watchers.get(key).add(callback);
+    return () => {
+      const callbacks = this.watchers.get(key);
+      if (callbacks) {
+        callbacks.delete(callback);
+        if (callbacks.size === 0) {
+          this.watchers.delete(key);
+        }
+      }
+    };
+  }
+  /**
+   * 清理资源
+   */
+  async destroy() {
+    this.watchers.clear();
+    this.cache.clear();
+  }
+};
+var MemoryConfigStorage = class {
+  storage = /* @__PURE__ */ new Map();
+  watchers = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.storage.get(key) || null;
+  }
+  getCached(key) {
+    return this.storage.get(key);
+  }
+  async set(key, value, metadata) {
+    const oldValue = this.storage.get(key);
+    this.storage.set(key, value);
+    const callbacks = this.watchers.get(key);
+    if (callbacks) {
+      callbacks.forEach((cb) => {
+        try {
+          cb(value, oldValue);
+        } catch (error) {
+          logger_default.error(`Config watch callback error for key: ${key}`, error);
+        }
+      });
+    }
+  }
+  async delete(key) {
+    const oldValue = this.storage.get(key);
+    this.storage.delete(key);
+    const callbacks = this.watchers.get(key);
+    if (callbacks) {
+      callbacks.forEach((cb) => {
+        try {
+          cb(null, oldValue);
+        } catch (error) {
+          logger_default.error(`Config watch callback error for key: ${key}`, error);
+        }
+      });
+    }
+  }
+  async getAll(prefix) {
+    if (!prefix) {
+      return new Map(this.storage);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.storage.entries()) {
+      if (key.startsWith(prefix)) {
+        result.set(key, value);
+      }
+    }
+    return result;
+  }
+  watch(key, callback) {
+    if (!this.watchers.has(key)) {
+      this.watchers.set(key, /* @__PURE__ */ new Set());
+    }
+    this.watchers.get(key).add(callback);
+    return () => {
+      const callbacks = this.watchers.get(key);
+      if (callbacks) {
+        callbacks.delete(callback);
+        if (callbacks.size === 0) {
+          this.watchers.delete(key);
+        }
+      }
+    };
+  }
+  async destroy() {
+    this.storage.clear();
+    this.watchers.clear();
+  }
+};
+
+// src/plugins/dynamic-config/plugin.ts
+function keyToEnvName(key) {
+  return key.toUpperCase().replace(/-/g, "_");
+}
+function getEnvValue(envKey) {
+  const value = process.env[envKey];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+var DynamicConfigPlugin = class {
+  name = "dynamic-config-plugin";
+  priority = 300 /* BUSINESS */;
+  engine;
+  storage;
+  configHandlers = [];
+  unwatchFunctions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    if (options?.useMockEtcd) {
+      this.storage = new MemoryConfigStorage();
+      logger_default.info(
+        "DynamicConfigPlugin: Using MemoryConfigStorage for local development/testing"
+      );
+    } else if (options?.etcdClient) {
+      this.storage = new EtcdConfigStorage(
+        options.etcdClient,
+        options.etcdPrefix || "/config"
+      );
+      logger_default.info("DynamicConfigPlugin: Using EtcdConfigStorage");
+    } else {
+      this.storage = new MemoryConfigStorage();
+      logger_default.warn(
+        "DynamicConfigPlugin: No etcdClient provided, using MemoryConfigStorage"
+      );
+    }
+  }
+  /**
+   * 声明 Module 配置 Schema
+   */
+  getModuleOptionsSchema() {
+    return {
+      _type: {},
+      validate: (options) => {
+        return true;
+      }
+    };
+  }
+  /**
+   * 引擎初始化钩子
+   */
+  onInit(engine) {
+    this.engine = engine;
+    logger_default.info("DynamicConfigPlugin initialized");
+  }
+  /**
+   * Handler 加载钩子：收集所有动态配置
+   */
+  onHandlerLoad(handlers) {
+    this.configHandlers = handlers.filter(
+      (handler) => handler.type === "dynamic-config"
+    );
+    logger_default.info(
+      `DynamicConfigPlugin: Found ${this.configHandlers.length} dynamic config handler(s)`
+    );
+    for (const handler of this.configHandlers) {
+      this.wrapConfigHandler(handler);
+    }
+  }
+  /**
+   * 包装配置方法，实现动态配置注入
+   */
+  wrapConfigHandler(handler) {
+    const options = handler.options;
+    const moduleName = this.getModuleName(handler.module);
+    const methodName = handler.methodName;
+    const configKey = this.buildConfigKey(moduleName, options.key);
+    logger_default.info(
+      `DynamicConfigPlugin: Wrapping ${moduleName}.${methodName} with config key: ${configKey}`
+    );
+    handler.wrap(async (next, instance, ...args) => {
+      let configValue = await this.storage.get(configKey);
+      const fromStorage = configValue !== null && configValue !== void 0;
+      let fromEnv = false;
+      if (!fromStorage) {
+        const envKey = keyToEnvName(options.key);
+        configValue = getEnvValue(envKey);
+        if (configValue !== void 0) {
+          fromEnv = true;
+          logger_default.debug(
+            `DynamicConfigPlugin: Loaded config from env: ${configKey} (${envKey})`
+          );
+        }
+      }
+      if (configValue === null || configValue === void 0) {
+        configValue = options.defaultValue;
+      }
+      if (options.schema && configValue !== void 0) {
+        try {
+          configValue = options.schema.parse(configValue);
+        } catch (error) {
+          logger_default.error(
+            `DynamicConfigPlugin: Config validation failed for ${configKey}`,
+            error
+          );
+          configValue = options.defaultValue;
+        }
+      }
+      if (!fromStorage && !fromEnv && configValue !== void 0 && configValue !== null) {
+        try {
+          await this.storage.set(configKey, configValue);
+        } catch (error) {
+          logger_default.error(
+            `DynamicConfigPlugin: Failed to cache config value for ${configKey}`,
+            error
+          );
+        }
+      }
+      return configValue;
+    });
+  }
+  /**
+   * 引擎启动后钩子：启动配置监听和预加载配置
+   */
+  async onAfterStart(engine) {
+    await this.preloadConfigs();
+    for (const handler of this.configHandlers) {
+      const options = handler.options;
+      const moduleName = this.getModuleName(handler.module);
+      const configKey = this.buildConfigKey(moduleName, options.key);
+      if (options.onChange) {
+        const unwatch = this.storage.watch(
+          configKey,
+          async (newValue, oldValue) => {
+            try {
+              logger_default.info(
+                `DynamicConfigPlugin: Config changed for ${configKey}`,
+                {
+                  sensitive: options.sensitive,
+                  oldValue: options.sensitive ? "***" : oldValue,
+                  newValue: options.sensitive ? "***" : newValue
+                }
+              );
+              await options.onChange(newValue, oldValue);
+            } catch (error) {
+              logger_default.error(
+                `DynamicConfigPlugin: onChange callback error for ${configKey}`,
+                error
+              );
+            }
+          }
+        );
+        this.unwatchFunctions.set(configKey, unwatch);
+      }
+    }
+    logger_default.info(
+      `DynamicConfigPlugin: Started watching ${this.unwatchFunctions.size} config(s)`
+    );
+  }
+  /**
+   * 预加载所有配置到缓存，并将配置方法/属性转换为同步 getter
+   */
+  async preloadConfigs() {
+    const modules = this.engine.getModules();
+    for (const moduleMetadata of modules) {
+      const moduleClass = moduleMetadata.clazz;
+      const moduleInstance = this.engine.get(moduleClass);
+      const moduleConfigHandlers = this.configHandlers.filter(
+        (h) => h.module === moduleClass
+      );
+      const fieldMetadata = getAllHandlerFieldMetadata(moduleClass);
+      const moduleConfigFields = Array.from(fieldMetadata.entries()).filter(
+        ([_, handlers]) => handlers.some((h) => h.type === "dynamic-config")
+      );
+      if (moduleConfigHandlers.length === 0 && moduleConfigFields.length === 0) {
+        continue;
+      }
+      for (const handler of moduleConfigHandlers) {
+        const methodName = handler.methodName;
+        const method = moduleInstance[methodName];
+        if (typeof method === "function") {
+          try {
+            const configValue = await method.call(moduleInstance);
+            const options = handler.options;
+            const moduleName = this.getModuleName(moduleClass);
+            const configKey = this.buildConfigKey(moduleName, options.key);
+            const cachedValue = this.storage.getCached ? this.storage.getCached(configKey) : void 0;
+            if (cachedValue === null || cachedValue === void 0) {
+              if (configValue !== void 0 && configValue !== null) {
+                await this.storage.set(configKey, configValue);
+              }
+            }
+            Object.defineProperty(moduleInstance, methodName, {
+              get: () => {
+                let value = this.storage.getCached ? this.storage.getCached(configKey) : void 0;
+                if (value === null || value === void 0) {
+                  const envKey = keyToEnvName(options.key);
+                  value = getEnvValue(envKey);
+                }
+                return value !== void 0 && value !== null ? value : options.defaultValue;
+              },
+              enumerable: true,
+              configurable: true
+            });
+          } catch (error) {
+            logger_default.error(
+              `DynamicConfigPlugin: Failed to preload config ${moduleMetadata.name}.${methodName}`,
+              error
+            );
+          }
+        }
+      }
+      for (const [fieldName, handlers] of moduleConfigFields) {
+        const configHandler = handlers.find((h) => h.type === "dynamic-config");
+        if (!configHandler) continue;
+        try {
+          const options = configHandler.options;
+          const moduleName = this.getModuleName(moduleClass);
+          const configKey = this.buildConfigKey(moduleName, options.key);
+          let configValue = await this.storage.get(configKey);
+          if (configValue === null || configValue === void 0) {
+            const envKey = keyToEnvName(options.key);
+            configValue = getEnvValue(envKey);
+          }
+          if (configValue === null || configValue === void 0) {
+            configValue = options.defaultValue;
+          }
+          const cachedValue = this.storage.getCached ? this.storage.getCached(configKey) : void 0;
+          if (cachedValue === null || cachedValue === void 0) {
+            if (configValue !== void 0 && configValue !== null) {
+              await this.storage.set(configKey, configValue);
+            }
+          }
+          Object.defineProperty(moduleInstance, fieldName, {
+            get: () => {
+              let value = this.storage.getCached ? this.storage.getCached(configKey) : void 0;
+              if (value === null || value === void 0) {
+                const envKey = keyToEnvName(options.key);
+                value = getEnvValue(envKey);
+              }
+              return value !== void 0 && value !== null ? value : options.defaultValue;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          const fieldHandler = {
+            ...configHandler,
+            methodName: String(fieldName),
+            module: moduleClass,
+            method: () => {
+            }
+            // 属性没有 method，使用 any 绕过类型检查
+          };
+          this.configHandlers.push(fieldHandler);
+        } catch (error) {
+          logger_default.error(
+            `DynamicConfigPlugin: Failed to preload config ${moduleMetadata.name}.${String(fieldName)}`,
+            error
+          );
+        }
+      }
+    }
+    logger_default.info(
+      `DynamicConfigPlugin: Preloaded ${this.configHandlers.length} config(s) and created sync accessors`
+    );
+  }
+  /**
+   * 引擎销毁钩子：清理资源
+   */
+  async onDestroy() {
+    for (const unwatch of this.unwatchFunctions.values()) {
+      unwatch();
+    }
+    this.unwatchFunctions.clear();
+    if (this.storage && typeof this.storage.destroy === "function") {
+      await this.storage.destroy();
+    }
+    logger_default.info("DynamicConfigPlugin: Cleanup completed");
+  }
+  /**
+   * 获取模块名称
+   */
+  getModuleName(moduleClass) {
+    const moduleMetadata = this.engine.getModules().find((m) => m.clazz === moduleClass);
+    return moduleMetadata?.name || moduleClass.name;
+  }
+  /**
+   * 构建完整的配置键
+   */
+  buildConfigKey(moduleName, configKey) {
+    const serviceName = this.engine.options.name;
+    return `${serviceName}/${moduleName}/${configKey}`;
+  }
+  /**
+   * 公共 API：获取配置
+   */
+  async getConfig(key) {
+    return await this.storage.get(key);
+  }
+  /**
+   * 公共 API：同步获取配置（从缓存）
+   * 用于 configProxy 的同步访问
+   */
+  getConfigCached(key) {
+    return this.storage.getCached ? this.storage.getCached(key) : void 0;
+  }
+  /**
+   * 公共 API：设置配置
+   */
+  async setConfig(key, value, metadata) {
+    await this.storage.set(key, value, metadata);
+  }
+  /**
+   * 公共 API：删除配置
+   */
+  async deleteConfig(key) {
+    await this.storage.delete(key);
+  }
+  /**
+   * 公共 API：获取所有配置
+   */
+  async getAllConfigs(prefix) {
+    return await this.storage.getAll(prefix);
+  }
+  /**
+   * 公共 API：监听配置变化
+   */
+  watchConfig(key, callback) {
+    return this.storage.watch(key, callback);
+  }
+};
+
+// src/plugins/dynamic-config/decorator.ts
+function Config(options) {
+  return HandlerField({
+    type: "dynamic-config",
+    options
+  });
+}
+var Microservice3 = class {
+  // 存储已注册的模块
+  modules = [];
+  // 存储已注册的插件（按注册顺序）
+  plugins = [];
+  // 插件注册表（以name为键，用于覆盖逻辑）
+  pluginRegistry = /* @__PURE__ */ new Map();
+  // 模块实例缓存（单例管理）
+  moduleInstances = /* @__PURE__ */ new Map();
+  // 引擎配置（冻结，只读）
+  options;
+  // 是否已启动
+  started = false;
+  // 模块元数据键（用于通过双向访问查找模块）
+  moduleMetadataKey;
+  // 实际使用的端口（启动后设置）
+  actualPort = null;
+  // Hono 实例（由引擎统一管理）
+  hono = new Hono();
+  // HTTP 服务器实例
+  server = null;
+  constructor(options, moduleMetadataKey) {
+    this.options = Object.freeze({
+      hostname: "0.0.0.0",
+      ...options
+    });
+    this.moduleMetadataKey = moduleMetadataKey;
+  }
+  /**
+   * 获取 Hono 实例（供插件使用）
+   */
+  getHono() {
+    return this.hono;
+  }
+  /**
+   * 内部注册插件方法（供构造函数和子类使用）
+   * @protected
+   */
+  registerPlugin(plugin) {
+    if (!plugin.name || plugin.name.trim() === "") {
+      throw new PluginNameRequiredError();
+    }
+    const existingPlugin = this.pluginRegistry.get(plugin.name);
+    if (existingPlugin) {
+      const oldIndex = this.plugins.indexOf(existingPlugin);
+      if (oldIndex >= 0) {
+        this.plugins.splice(oldIndex, 1);
+      }
+      logger_default.info(`Override plugin: ${plugin.name}`);
+    }
+    this.pluginRegistry.set(plugin.name, plugin);
+    this.plugins.push(plugin);
+  }
+  /**
+   * 加载并注册所有模块（通过唯一的 key 查找）
+   * 在引擎启动时调用，使用双向访问机制查找所有被装饰的类
+   *
+   * 注意：
+   * - 每个引擎实例使用唯一的 moduleMetadataKey，实现隔离
+   * - 模块类是静态的，可以被多个引擎实例共享
+   * - 每个引擎实例会创建独立的模块实例，互不影响
+   */
+  loadModules() {
+    this.modules = [];
+    const moduleClasses = getClassesByKey(this.moduleMetadataKey);
+    for (const moduleClass of moduleClasses) {
+      const metadata = getClassMetadata(moduleClass, this.moduleMetadataKey);
+      const moduleName = metadata.name || moduleClass.name;
+      const moduleMetadata = {
+        name: moduleName,
+        clazz: moduleClass,
+        options: metadata.options || {}
+      };
+      this.modules.push(moduleMetadata);
+    }
+  }
+  /**
+   * 加载Handler元数据（平铺结构）
+   * 每个装饰器都是独立的HandlerMetadata条目
+   * 为每个方法创建包装链管理器，提供简单的 wrap API
+   */
+  loadHandlerMetadata() {
+    const handlers = [];
+    const wrapperChains = /* @__PURE__ */ new Map();
+    const originalMethods = /* @__PURE__ */ new Map();
+    for (const module of this.modules) {
+      if (!this.moduleInstances.has(module.clazz)) {
+        this.get(module.clazz);
+      }
+      const allMetadata = getAllHandlerMetadata(module.clazz);
+      for (const [methodName, metadataList] of allMetadata.entries()) {
+        const method = module.clazz.prototype[methodName];
+        const methodNameStr = String(methodName);
+        const methodKey = `${module.clazz.name}.${methodNameStr}`;
+        if (!originalMethods.has(methodKey)) {
+          originalMethods.set(methodKey, method);
+          wrapperChains.set(methodKey, []);
+        }
+        for (const meta of metadataList) {
+          const chain = wrapperChains.get(methodKey);
+          handlers.push({
+            ...meta,
+            method: originalMethods.get(methodKey),
+            methodName: methodNameStr,
+            module: module.clazz,
+            // 提供简单的 wrap API：插件只需要调用这个方法
+            wrap: (wrapper) => {
+              chain.push(wrapper);
+            }
+          });
+        }
+      }
+    }
+    this.__wrapperChains__ = wrapperChains;
+    this.__originalMethods__ = originalMethods;
+    return handlers;
+  }
+  /**
+   * 应用所有包装链到原型
+   * 在所有插件执行完 onHandlerLoad 后调用
+   */
+  applyWrapperChains() {
+    const wrapperChains = this.__wrapperChains__;
+    const originalMethods = this.__originalMethods__;
+    if (!wrapperChains || !originalMethods) return;
+    for (const [methodKey, chain] of wrapperChains.entries()) {
+      if (chain.length === 0) continue;
+      const [moduleName, methodName] = methodKey.split(".");
+      const module = this.modules.find((m) => m.clazz.name === moduleName);
+      if (!module) continue;
+      const originalMethod = originalMethods.get(methodKey);
+      const prototype = module.clazz.prototype;
+      let wrappedMethod = originalMethod;
+      for (let i = chain.length - 1; i >= 0; i--) {
+        const wrapper = chain[i];
+        const next = wrappedMethod;
+        wrappedMethod = async function(...args) {
+          return wrapper(() => next.apply(this, args), this, ...args);
+        };
+      }
+      prototype[methodName] = wrappedMethod;
+    }
+  }
+  /**
+   * 寻找一个随机的可用端口
+   */
+  getRandomPort(hostname) {
+    return new Promise((resolve, reject) => {
+      const server = net.createServer();
+      server.unref();
+      server.on("error", reject);
+      server.listen(0, hostname, () => {
+        const port = server.address().port;
+        server.close((err) => {
+          if (err) {
+            return reject(err);
+          }
+          resolve(port);
+        });
+      });
+    });
+  }
+  /**
+   * 启动引擎
+   * @param requestedPort 启动端口（可选，默认0，表示随机端口）
+   * @returns 实际使用的端口号
+   */
+  async start(requestedPort = 0) {
+    if (this.started) {
+      throw new Error("Engine is already started");
+    }
+    try {
+      const { port, hostname } = await this.determinePort(requestedPort);
+      this.initializeModulesAndPlugins();
+      this.processHandlers();
+      await this.executePluginStartHooks();
+      this.startHttpServer(port, hostname);
+      this.started = true;
+      logger_default.info(
+        `${this.options.name} v${this.options.version} started successfully on port ${this.actualPort}`
+      );
+      return this.actualPort;
+    } catch (error) {
+      logger_default.error("Failed to start engine", error);
+      throw error;
+    }
+  }
+  /**
+   * 确定实际使用的端口
+   */
+  async determinePort(requestedPort) {
+    const hostname = this.options.hostname || "0.0.0.0";
+    if (requestedPort !== 0) {
+      this.actualPort = requestedPort;
+      return { port: this.actualPort, hostname };
+    }
+    this.actualPort = await this.getRandomPort(hostname);
+    return { port: this.actualPort, hostname };
+  }
+  /**
+   * 初始化模块和插件
+   */
+  initializeModulesAndPlugins() {
+    this.loadModules();
+    this.executePluginHook("onInit", (plugin) => {
+      plugin.onInit?.(this);
+    });
+    this.executePluginHook("onModuleLoad", (plugin) => {
+      plugin.onModuleLoad?.(
+        this.modules
+      );
+    });
+  }
+  /**
+   * 处理 Handler 元数据和插件包装
+   */
+  processHandlers() {
+    const handlers = this.loadHandlerMetadata();
+    const sortedPlugins = this.sortPluginsByPriority();
+    const { wrapperPlugins, routePlugins } = this.separateWrapperAndRoutePlugins(sortedPlugins);
+    this.executePluginHook(
+      "onHandlerLoad",
+      (plugin) => {
+        plugin.onHandlerLoad?.(handlers);
+      },
+      wrapperPlugins
+    );
+    this.applyWrapperChains();
+    this.executePluginHook(
+      "onHandlerLoad",
+      (plugin) => {
+        plugin.onHandlerLoad?.(handlers);
+      },
+      routePlugins
+    );
+  }
+  /**
+   * 执行插件启动钩子
+   */
+  async executePluginStartHooks() {
+    this.executePluginHook("onBeforeStart", (plugin) => {
+      plugin.onBeforeStart?.(this);
+    });
+    for (const plugin of this.plugins) {
+      try {
+        await plugin.onAfterStart?.(this);
+      } catch (error) {
+        throw new Error(
+          `Plugin ${plugin.name} failed in onAfterStart: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    this.registerVersionRoute();
+  }
+  /**
+   * 注册版本路由（/prefix/version）
+   * 用于健康检查和探针
+   */
+  registerVersionRoute() {
+    const prefix = this.options.prefix || "";
+    const versionPath = prefix ? `${prefix}` : "/";
+    const existingRoutes = this.hono.routes;
+    const routeExists = existingRoutes.some(
+      (route) => route.path === versionPath && route.method === "GET"
+    );
+    if (routeExists) {
+      logger_default.info(
+        `Version route ${versionPath} already exists, skipping registration`
+      );
+      return;
+    }
+    try {
+      this.hono.get(versionPath, async (ctx) => {
+        return ctx.json({
+          name: this.options.name,
+          version: this.options.version,
+          status: "running"
+        });
+      });
+      logger_default.info(`Registered version route: GET ${versionPath}`);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("matcher is already built")) {
+        logger_default.warn(
+          `Cannot register version route ${versionPath}: route matcher is already built. If you have already registered a route at ${versionPath}, it will be used instead.`
+        );
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * 启动 HTTP 服务器
+   */
+  startHttpServer(port, hostname) {
+    this.server = serve({
+      fetch: this.hono.fetch,
+      port,
+      hostname
+    });
+    logger_default.info(`HTTP server started on http://${hostname}:${port}`);
+  }
+  /**
+   * 按优先级排序插件
+   */
+  sortPluginsByPriority() {
+    return [...this.plugins].sort((a, b) => {
+      const priorityA = this.getPluginPriority(a);
+      const priorityB = this.getPluginPriority(b);
+      if (priorityA !== priorityB) {
+        return priorityA - priorityB;
+      }
+      const indexA = this.plugins.indexOf(a);
+      const indexB = this.plugins.indexOf(b);
+      return indexA - indexB;
+    });
+  }
+  /**
+   * 获取插件优先级
+   */
+  getPluginPriority(plugin) {
+    return plugin.priority ?? 300 /* BUSINESS */;
+  }
+  /**
+   * 分离包装插件和路由插件
+   */
+  separateWrapperAndRoutePlugins(sortedPlugins) {
+    const wrapperPlugins = [];
+    const routePlugins = [];
+    for (const plugin of sortedPlugins) {
+      const priority = this.getPluginPriority(plugin);
+      if (priority === 1e3 /* ROUTE */) {
+        routePlugins.push(plugin);
+      } else {
+        wrapperPlugins.push(plugin);
+      }
+    }
+    return { wrapperPlugins, routePlugins };
+  }
+  /**
+   * 执行插件钩子（通用方法）
+   */
+  executePluginHook(hookName, callback, plugins = this.plugins) {
+    for (const plugin of plugins) {
+      try {
+        callback(plugin);
+      } catch (error) {
+        throw new Error(
+          `Plugin ${plugin.name} failed in ${hookName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * 停止引擎
+   */
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    try {
+      if (this.server) {
+        if (typeof this.server.close === "function") {
+          if (this.server.close.length > 0) {
+            await new Promise((resolve, reject) => {
+              this.server.close((err) => {
+                if (err) {
+                  reject(err);
+                } else {
+                  resolve();
+                }
+              });
+            });
+          } else {
+            this.server.close();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+          }
+        }
+        this.server = null;
+        logger_default.info("HTTP server stopped");
+      }
+      for (let i = this.plugins.length - 1; i >= 0; i--) {
+        const plugin = this.plugins[i];
+        try {
+          await plugin.onDestroy?.();
+        } catch (error) {
+          logger_default.error(`Plugin ${plugin.name} failed in onDestroy`, error);
+        }
+      }
+      this.modules = [];
+      this.moduleInstances.clear();
+      this.started = false;
+      this.actualPort = null;
+      logger_default.info(`${this.options.name} stopped`);
+    } catch (error) {
+      logger_default.error("Failed to stop engine", error);
+      throw error;
+    }
+  }
+  /**
+   * 获取模块实例（单例）
+   * @param moduleClass 模块类
+   * @returns 模块实例
+   */
+  get(moduleClass) {
+    if (!this.moduleInstances.has(moduleClass)) {
+      this.moduleInstances.set(moduleClass, new moduleClass());
+    }
+    return this.moduleInstances.get(moduleClass);
+  }
+  /**
+   * 获取已注册的模块列表
+   */
+  getModules() {
+    if (this.modules.length === 0 && !this.started) {
+      this.loadModules();
+    }
+    return [...this.modules];
+  }
+  /**
+   * 获取实际使用的端口
+   */
+  getPort() {
+    return this.actualPort;
+  }
+  /**
+   * 确保引擎已初始化（模块和处理器已加载）
+   * 如果引擎未启动，则执行必要的初始化步骤
+   */
+  ensureInitialized() {
+    if (this.started) {
+      return;
+    }
+    if (this.modules.length === 0) {
+      this.initializeModulesAndPlugins();
+    }
+    if (!this.__wrapperChains__) {
+      this.processHandlers();
+    }
+  }
+  /**
+   * 获取模块处理器方法（不启动 HTTP 服务器）
+   * 适用于测试场景，可以完整执行中间件和处理逻辑
+   *
+   * 返回一个已绑定模块和方法名的调用函数，调用时只需要传递方法参数
+   * 类型推导：自动推导方法参数类型和返回值类型（无需显式指定泛型参数）
+   *
+   * @param moduleClass 模块类
+   * @param methodName 方法名（handler 名称）
+   * @returns 调用函数，只需要传递方法参数
+   *
+   * @example
+   * ```typescript
+   * @Module("users")
+   * class UserService {
+   *   @Action({ params: [z.string(), z.number()] })
+   *   add(a: string, b: number): { result: number } {
+   *     return { result: Number(a) + b };
+   *   }
+   *
+   *   @Action({ params: [z.string()] })
+   *   getUser(id: string): Promise<{ id: string; name: string }> {
+   *     return Promise.resolve({ id, name: "Alice" });
+   *   }
+   * }
+   *
+   * // 获取 handler 并调用（类型自动推导，无需显式指定泛型）
+   * const addHandler = engine.handler(UserService, "add");
+   * const result1 = await addHandler("10", 20);
+   * // result1 的类型是 { result: number }
+   *
+   * // 也可以链式调用
+   * const result2 = await engine.handler(UserService, "getUser")("123");
+   * // result2 的类型是 { id: string; name: string }（自动解包 Promise）
+   * ```
+   */
+  handler(moduleClass, methodName) {
+    return async (...args) => {
+      this.ensureInitialized();
+      const instance = this.get(moduleClass);
+      const method = instance[methodName];
+      if (typeof method !== "function") {
+        throw new Error(
+          `Handler ${String(methodName)} not found in module ${moduleClass.name}`
+        );
+      }
+      return await method.call(instance, ...args);
+    };
+  }
+  /**
+   * 使用 Hono 的 request 方法调用路由处理器（不启动 HTTP 服务器）
+   * 适用于测试场景，可以完整执行中间件和处理逻辑
+   *
+   * @param input Request 对象、URL 字符串或相对路径
+   * @param init RequestInit 选项（当 input 是字符串时使用）
+   * @returns Response 对象
+   *
+   * @example
+   * ```typescript
+   * // 使用相对路径
+   * const response = await engine.request("/api/users/123");
+   *
+   * // 使用完整 URL
+   * const response = await engine.request("http://localhost/api/users/123");
+   *
+   * // 使用 Request 对象
+   * const request = new Request("http://localhost/api/users/123", {
+   *   method: "POST",
+   *   headers: { "Content-Type": "application/json" },
+   *   body: JSON.stringify({ name: "Alice" }),
+   * });
+   * const response = await engine.request(request);
+   * ```
+   */
+  async request(input, init) {
+    this.ensureInitialized();
+    let request;
+    if (input instanceof Request) {
+      request = input;
+    } else if (typeof input === "string") {
+      const url = input.startsWith("http://") || input.startsWith("https://") ? input : `http://localhost${input}`;
+      request = new Request(url, init);
+    } else {
+      request = new Request(input.toString(), init);
+    }
+    return await this.hono.request(request);
+  }
+};
+
+// src/core/factory.ts
+var Factory = class {
+  /**
+   * 创建类型化的引擎工厂
+   *
+   * @param plugins 插件列表（必须显式提供所有需要的插件）
+   * @returns 包含类型化的 Module 装饰器和 Microservice 类的对象
+   */
+  static create(...plugins) {
+    const moduleMetadataKey = /* @__PURE__ */ Symbol.for(
+      `nebula:moduleMetadata:${Date.now()}:${Math.random()}`
+    );
+    class TypedMicroservice extends Microservice3 {
+      constructor(options) {
+        super(options, moduleMetadataKey);
+        for (const plugin of plugins) {
+          this.registerPlugin(plugin);
+        }
+      }
+    }
+    const baseDecorator = createClassDecorator(moduleMetadataKey);
+    const Module = (name, options) => {
+      const classMetadata = {
+        name: name || void 0,
+        options: options || {}
+      };
+      return baseDecorator(classMetadata);
+    };
+    return {
+      Module,
+      Microservice: TypedMicroservice
+    };
+  }
+};
+
+// src/core/testing.ts
+var DEFAULT_TEST_OPTIONS = {
+  name: "test-service",
+  version: "1.0.0"
+};
+function createTestEngine(config) {
+  const factory = Factory.create(...config.plugins);
+  const Microservice4 = factory.Microservice;
+  const engine = new Microservice4({
+    ...DEFAULT_TEST_OPTIONS,
+    ...config.options
+  });
+  return {
+    ...factory,
+    engine
+  };
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var Testing = {
+  createTestEngine,
+  DEFAULT_TEST_OPTIONS,
+  wait
+};
+var NEBULA_ID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var DEFAULT_ID_LENGTH = 12;
+var generateNebulaId = customAlphabet(NEBULA_ID_ALPHABET, DEFAULT_ID_LENGTH);
+function nebulaId(length = DEFAULT_ID_LENGTH) {
+  if (length <= 0) {
+    throw new Error("ID length must be greater than 0");
+  }
+  if (length === DEFAULT_ID_LENGTH) {
+    return generateNebulaId();
+  }
+  const customLengthGenerator = customAlphabet(NEBULA_ID_ALPHABET, length);
+  return customLengthGenerator();
+}
+
+export { Action, ActionPlugin, BaseLayout, Cache, CachePlugin, ClientCodePlugin, Config, DEFAULT_TEST_OPTIONS, DuplicateModuleError, DynamicConfigPlugin, EtcdConfigStorage, Factory, GracefulShutdownPlugin, Handler, HtmxLayout, MemoryCacheAdapter, MemoryConfigStorage, MockEtcd3, ModuleConfigValidationError, NEBULA_ID_ALPHABET, Page, PluginNameRequiredError, PluginPriority, RedisCacheAdapter, Route, RoutePlugin, Schedule, ScheduleMode, SchedulePlugin, Scheduler, ServiceInfoCards, ServiceStatusPage, Testing, convertHandlersToModuleInfo, convertHandlersToModuleInfoWithMetadata, generateClientCode, getZodTypeString, logger_default as logger, nebulaId, startCheck };