koatty_schedule 4.0.7 → 4.1.0

package/dist/index.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var koatty_container = require('koatty_container');
-var redlock = require('@sesamecare-oss/redlock');
-var koatty_logger = require('koatty_logger');
 var Redis = require('ioredis');
+var koatty_logger = require('koatty_logger');
+var redlock = require('@sesamecare-oss/redlock');
+var koatty_container = require('koatty_container');
 var koatty_lib = require('koatty_lib');
 var cron = require('cron');
 
@@ -13,28 +13,43 @@ var Redis__default = /*#__PURE__*/_interopDefault(Redis);
 
 /*!
 * @Author: richen
-* @Date: 2026-03-07 15:34:44
+* @Date: 2026-04-24 08:20:32
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/config/config.ts
-var COMPONENT_SCHEDULED = "COMPONENT_SCHEDULED";
-var DecoratorType = /* @__PURE__ */ (function(DecoratorType2) {
-  DecoratorType2["SCHEDULED"] = "SCHEDULED";
-  DecoratorType2["REDLOCK"] = "REDLOCK";
-  return DecoratorType2;
-})({});
+var config_exports = {};
+__export(config_exports, {
+  COMPONENT_REDLOCK: () => COMPONENT_REDLOCK,
+  COMPONENT_SCHEDULED: () => COMPONENT_SCHEDULED,
+  DecoratorType: () => DecoratorType,
+  getEffectiveRedLockOptions: () => getEffectiveRedLockOptions,
+  getEffectiveTimezone: () => getEffectiveTimezone,
+  getGlobalScheduledOptions: () => getGlobalScheduledOptions,
+  setGlobalScheduledOptions: () => setGlobalScheduledOptions,
+  validateCronExpression: () => validateCronExpression,
+  validateRedLockMethodOptions: () => validateRedLockMethodOptions,
+  validateRedLockOptions: () => validateRedLockOptions
+});
 function validateCronExpression(cron) {
   if (!cron || typeof cron !== "string") {
-    throw new Error("Cron \u8868\u8FBE\u5F0F\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32 (Cron expression must be a non-empty string)");
+    throw new Error("Cron expression must be a non-empty string");
   }
   const cronParts = cron.trim().split(/\s+/);
   if (cronParts.length < 5 || cronParts.length > 6) {
-    throw new Error(`Cron \u8868\u8FBE\u5F0F\u683C\u5F0F\u65E0\u6548\u3002\u671F\u671B 5 \u6216 6 \u90E8\u5206\uFF0C\u5B9E\u9645\u5F97\u5230 ${cronParts.length} \u90E8\u5206 (Invalid cron format. Expected 5 or 6 parts, got ${cronParts.length})`);
+    throw new Error(`Invalid cron format. Expected 5 or 6 parts, got ${cronParts.length}`);
   }
   const hasSecs = cronParts.length === 6;
   const offset = hasSecs ? 0 : -1;
@@ -74,7 +89,6 @@ function validateCronExpression(cron) {
     "SAT"
   ]);
 }
-__name(validateCronExpression, "validateCronExpression");
 function validateCronField(field, min, max, fieldName, fieldNameCN, allowedStrings) {
   if (field === "*") {
     return;
@@ -89,7 +103,7 @@ function validateCronField(field, min, max, fieldName, fieldNameCN, allowedStrin
     const [range, step] = field.split("/");
     const stepValue = parseInt(step);
     if (isNaN(stepValue) || stepValue <= 0) {
-      throw new Error(`${fieldNameCN}\u5B57\u6BB5\u7684\u6B65\u957F\u503C\u65E0\u6548: ${step} (Invalid step value for ${fieldName}: ${step})`);
+      throw new Error(`Invalid step value for ${fieldName}: ${step}`);
     }
     if (range !== "*") {
       validateCronField(range, min, max, fieldName, fieldNameCN, allowedStrings);
@@ -101,13 +115,13 @@ function validateCronField(field, min, max, fieldName, fieldNameCN, allowedStrin
     const startValue = parseInt(start);
     const endValue = parseInt(end);
     if (isNaN(startValue) || startValue < min || startValue > max) {
-      throw new Error(`${fieldNameCN}\u5B57\u6BB5\u7684\u8303\u56F4\u8D77\u59CB\u503C\u65E0\u6548: ${start}\uFF0C\u5FC5\u987B\u5728 ${min}-${max} \u4E4B\u95F4 (Invalid range start for ${fieldName}: ${start}, must be between ${min}-${max})`);
+      throw new Error(`Invalid range start for ${fieldName}: ${start}, must be between ${min}-${max}`);
     }
     if (isNaN(endValue) || endValue < min || endValue > max) {
-      throw new Error(`${fieldNameCN}\u5B57\u6BB5\u7684\u8303\u56F4\u7ED3\u675F\u503C\u65E0\u6548: ${end}\uFF0C\u5FC5\u987B\u5728 ${min}-${max} \u4E4B\u95F4 (Invalid range end for ${fieldName}: ${end}, must be between ${min}-${max})`);
+      throw new Error(`Invalid range end for ${fieldName}: ${end}, must be between ${min}-${max}`);
     }
     if (startValue > endValue) {
-      throw new Error(`${fieldNameCN}\u5B57\u6BB5\u7684\u8303\u56F4\u65E0\u6548: ${start}-${end}\uFF0C\u8D77\u59CB\u503C\u4E0D\u80FD\u5927\u4E8E\u7ED3\u675F\u503C (Invalid range for ${fieldName}: ${start}-${end}, start cannot be greater than end)`);
+      throw new Error(`Invalid range for ${fieldName}: ${start}-${end}, start cannot be greater than end`);
     }
     return;
   }
@@ -120,10 +134,9 @@ function validateCronField(field, min, max, fieldName, fieldNameCN, allowedStrin
   }
   const numValue = parseInt(field);
   if (isNaN(numValue) || numValue < min || numValue > max) {
-    throw new Error(`${fieldNameCN}\u5B57\u6BB5\u7684\u503C\u65E0\u6548: ${field}\uFF0C\u5FC5\u987B\u5728 ${min}-${max} \u4E4B\u95F4 (Invalid ${fieldName} value: ${field}, must be between ${min}-${max})`);
+    throw new Error(`Invalid ${fieldName} value: ${field}, must be between ${min}-${max}`);
   }
 }
-__name(validateCronField, "validateCronField");
 function validateRedLockMethodOptions(options) {
   if (!options || typeof options !== "object") {
     throw new Error("RedLock method options must be an object");
@@ -149,16 +162,42 @@ function validateRedLockMethodOptions(options) {
     }
   }
 }
-__name(validateRedLockMethodOptions, "validateRedLockMethodOptions");
-var globalScheduledOptions = {};
+function validateRedLockOptions(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("RedLock options must be an object");
+  }
+  if (options.lockTimeOut !== void 0) {
+    if (typeof options.lockTimeOut !== "number" || options.lockTimeOut <= 0) {
+      throw new Error("lockTimeOut must be a positive number");
+    }
+  }
+  if (options.retryCount !== void 0) {
+    if (typeof options.retryCount !== "number" || options.retryCount < 0) {
+      throw new Error("retryCount must be a non-negative number");
+    }
+  }
+  if (options.retryDelay !== void 0) {
+    if (typeof options.retryDelay !== "number" || options.retryDelay < 0) {
+      throw new Error("retryDelay must be a non-negative number");
+    }
+  }
+  if (options.retryJitter !== void 0) {
+    if (typeof options.retryJitter !== "number" || options.retryJitter < 0) {
+      throw new Error("retryJitter must be a non-negative number");
+    }
+  }
+}
+function setGlobalScheduledOptions(options) {
+  globalScheduledOptions = {
+    ...options
+  };
+}
 function getGlobalScheduledOptions() {
   return globalScheduledOptions;
 }
-__name(getGlobalScheduledOptions, "getGlobalScheduledOptions");
 function getEffectiveTimezone(options, userTimezone) {
   return userTimezone || options.timezone || "Asia/Beijing";
 }
-__name(getEffectiveTimezone, "getEffectiveTimezone");
 function getEffectiveRedLockOptions(methodOptions) {
   const globalOptions = getGlobalScheduledOptions();
   return {
@@ -168,580 +207,626 @@ function getEffectiveRedLockOptions(methodOptions) {
     retryDelayMs: methodOptions?.retryDelayMs || globalOptions.retryDelayMs || 200
   };
 }
-__name(getEffectiveRedLockOptions, "getEffectiveRedLockOptions");
+var COMPONENT_SCHEDULED, COMPONENT_REDLOCK, DecoratorType, globalScheduledOptions;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    COMPONENT_SCHEDULED = "COMPONENT_SCHEDULED";
+    COMPONENT_REDLOCK = "COMPONENT_REDLOCK";
+    DecoratorType = /* @__PURE__ */ (function(DecoratorType2) {
+      DecoratorType2["SCHEDULED"] = "SCHEDULED";
+      DecoratorType2["REDLOCK"] = "REDLOCK";
+      return DecoratorType2;
+    })({});
+    __name(validateCronExpression, "validateCronExpression");
+    __name(validateCronField, "validateCronField");
+    __name(validateRedLockMethodOptions, "validateRedLockMethodOptions");
+    __name(validateRedLockOptions, "validateRedLockOptions");
+    globalScheduledOptions = {};
+    __name(setGlobalScheduledOptions, "setGlobalScheduledOptions");
+    __name(getGlobalScheduledOptions, "getGlobalScheduledOptions");
+    __name(getEffectiveTimezone, "getEffectiveTimezone");
+    __name(getEffectiveRedLockOptions, "getEffectiveRedLockOptions");
+  }
+});
 
 // src/locker/interface.ts
-var RedisMode = /* @__PURE__ */ (function(RedisMode2) {
-  RedisMode2["STANDALONE"] = "standalone";
-  RedisMode2["SENTINEL"] = "sentinel";
-  RedisMode2["CLUSTER"] = "cluster";
-  return RedisMode2;
-})({});
-var RedisClientAdapter = class RedisClientAdapter2 {
-  static {
-    __name(this, "RedisClientAdapter");
-  }
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  get status() {
-    return this.client.status;
-  }
-  async call(command, ...args) {
-    return this.client.call(command, ...args);
-  }
-  async set(key, value, mode, duration) {
-    if (mode && duration) {
-      return this.client.set(key, value, mode, duration);
-    }
-    return this.client.set(key, value);
-  }
-  async get(key) {
-    return this.client.get(key);
-  }
-  async del(...keys) {
-    return this.client.del(...keys);
-  }
-  async exists(key) {
-    return this.client.exists(key);
-  }
-  async eval(script, numKeys, ...args) {
-    return this.client.eval(script, numKeys, ...args);
-  }
-  async quit() {
-    return this.client.quit();
-  }
-  disconnect() {
-    this.client.disconnect();
-  }
-  /**
-  * Get underlying Redis/Cluster instance
-  * Used for RedLock initialization
-  */
-  getClient() {
-    return this.client;
-  }
-};
-var RedisFactory = class {
-  static {
-    __name(this, "RedisFactory");
-  }
-  /**
-  * Create Redis client based on configuration mode
-  * @param config - Redis configuration
-  * @returns Redis client adapter
-  */
-  static createClient(config) {
-    const mode = config.mode || RedisMode.STANDALONE;
-    koatty_logger.DefaultLogger.Debug(`Creating Redis client in ${mode} mode`);
-    switch (mode) {
-      case RedisMode.STANDALONE:
-        return this.createStandaloneClient(config);
-      case RedisMode.SENTINEL:
-        return this.createSentinelClient(config);
-      case RedisMode.CLUSTER:
-        return this.createClusterClient(config);
-      default:
-        throw new Error(`\u4E0D\u652F\u6301\u7684 Redis \u6A21\u5F0F: ${mode} (Unsupported Redis mode: ${mode})`);
-    }
-  }
-  /**
-  * Create standalone Redis client
-  * @param config - Standalone configuration
-  */
-  static createStandaloneClient(config) {
-    koatty_logger.DefaultLogger.Debug(`Creating standalone Redis client: ${config.host}:${config.port}`);
-    const options = {
-      host: config.host,
-      port: config.port,
-      password: config.password || void 0,
-      db: config.db || 0,
-      keyPrefix: config.keyPrefix || "",
-      connectTimeout: config.connectTimeout || 1e4,
-      commandTimeout: config.commandTimeout || 5e3,
-      maxRetriesPerRequest: config.maxRetriesPerRequest || 3,
-      retryStrategy: /* @__PURE__ */ __name((times) => {
-        const delay = Math.min(times * 50, 2e3);
-        koatty_logger.DefaultLogger.Debug(`Redis reconnecting, attempt ${times}, delay ${delay}ms`);
-        return delay;
-      }, "retryStrategy"),
-      reconnectOnError: /* @__PURE__ */ __name((err) => {
-        koatty_logger.DefaultLogger.Warn("Redis connection error, attempting reconnect:", err.message);
-        return true;
-      }, "reconnectOnError")
-    };
-    const client = new Redis__default.default(options);
-    client.on("connect", () => {
-      koatty_logger.DefaultLogger.Info("Redis standalone client connected successfully");
-    });
-    client.on("error", (err) => {
-      koatty_logger.DefaultLogger.Error("Redis standalone client error:", err);
-    });
-    return new RedisClientAdapter(client);
-  }
-  /**
-  * Create sentinel Redis client
-  * @param config - Sentinel configuration
-  */
-  static createSentinelClient(config) {
-    koatty_logger.DefaultLogger.Debug(`Creating sentinel Redis client for master: ${config.name}`);
-    const options = {
-      sentinels: config.sentinels,
-      name: config.name,
-      password: config.password || void 0,
-      sentinelPassword: config.sentinelPassword || void 0,
-      db: config.db || 0,
-      keyPrefix: config.keyPrefix || "",
-      connectTimeout: config.connectTimeout || 1e4,
-      commandTimeout: config.commandTimeout || 5e3,
-      maxRetriesPerRequest: config.maxRetriesPerRequest || 3,
-      retryStrategy: /* @__PURE__ */ __name((times) => {
-        const delay = Math.min(times * 50, 2e3);
-        koatty_logger.DefaultLogger.Debug(`Sentinel Redis reconnecting, attempt ${times}, delay ${delay}ms`);
-        return delay;
-      }, "retryStrategy")
+exports.RedisMode = void 0;
+var init_interface = __esm({
+  "src/locker/interface.ts"() {
+    exports.RedisMode = /* @__PURE__ */ (function(RedisMode2) {
+      RedisMode2["STANDALONE"] = "standalone";
+      RedisMode2["SENTINEL"] = "sentinel";
+      RedisMode2["CLUSTER"] = "cluster";
+      return RedisMode2;
+    })({});
+  }
+});
+exports.RedisClientAdapter = void 0; exports.RedisFactory = void 0;
+var init_redis_factory = __esm({
+  "src/locker/redis-factory.ts"() {
+    init_interface();
+    exports.RedisClientAdapter = class RedisClientAdapter2 {
+      static {
+        __name(this, "RedisClientAdapter");
+      }
+      client;
+      constructor(client) {
+        this.client = client;
+      }
+      get status() {
+        return this.client.status;
+      }
+      async call(command, ...args) {
+        return this.client.call(command, ...args);
+      }
+      async set(key, value, mode, duration) {
+        if (mode && duration) {
+          return this.client.set(key, value, mode, duration);
+        }
+        return this.client.set(key, value);
+      }
+      async get(key) {
+        return this.client.get(key);
+      }
+      async del(...keys) {
+        return this.client.del(...keys);
+      }
+      async exists(key) {
+        return this.client.exists(key);
+      }
+      async eval(script, numKeys, ...args) {
+        return this.client.eval(script, numKeys, ...args);
+      }
+      async quit() {
+        return this.client.quit();
+      }
+      disconnect() {
+        this.client.disconnect();
+      }
+      /**
+      * Get underlying Redis/Cluster instance
+      * Used for RedLock initialization
+      */
+      getClient() {
+        return this.client;
+      }
     };
-    const client = new Redis__default.default(options);
-    client.on("connect", () => {
-      koatty_logger.DefaultLogger.Info(`Redis sentinel client connected to master: ${config.name}`);
-    });
-    client.on("error", (err) => {
-      koatty_logger.DefaultLogger.Error("Redis sentinel client error:", err);
-    });
-    return new RedisClientAdapter(client);
-  }
-  /**
-  * Create cluster Redis client
-  * @param config - Cluster configuration
-  */
-  static createClusterClient(config) {
-    koatty_logger.DefaultLogger.Debug(`Creating cluster Redis client with ${config.nodes.length} nodes`);
-    const clusterOptions = {
-      redisOptions: {
-        password: config.redisOptions?.password || config.password || void 0,
-        db: config.redisOptions?.db || config.db || 0,
-        keyPrefix: config.keyPrefix || "",
-        connectTimeout: config.connectTimeout || 1e4,
-        commandTimeout: config.commandTimeout || 5e3,
-        maxRetriesPerRequest: config.maxRetriesPerRequest || 3
-      },
-      clusterRetryStrategy: /* @__PURE__ */ __name((times) => {
-        const delay = Math.min(times * 50, 2e3);
-        koatty_logger.DefaultLogger.Debug(`Cluster Redis reconnecting, attempt ${times}, delay ${delay}ms`);
-        return delay;
-      }, "clusterRetryStrategy")
+    exports.RedisFactory = class {
+      static {
+        __name(this, "RedisFactory");
+      }
+      /**
+      * Create Redis client based on configuration mode
+      * @param config - Redis configuration
+      * @returns Redis client adapter
+      */
+      static createClient(config) {
+        const mode = config.mode || exports.RedisMode.STANDALONE;
+        koatty_logger.DefaultLogger.Debug(`Creating Redis client in ${mode} mode`);
+        switch (mode) {
+          case exports.RedisMode.STANDALONE:
+            return this.createStandaloneClient(config);
+          case exports.RedisMode.SENTINEL:
+            return this.createSentinelClient(config);
+          case exports.RedisMode.CLUSTER:
+            return this.createClusterClient(config);
+          default:
+            throw new Error(`Unsupported Redis mode: ${mode}`);
+        }
+      }
+      /**
+      * Create standalone Redis client
+      * @param config - Standalone configuration
+      */
+      static createStandaloneClient(config) {
+        koatty_logger.DefaultLogger.Debug(`Creating standalone Redis client: ${config.host}:${config.port}`);
+        const options = {
+          host: config.host,
+          port: config.port,
+          password: config.password || void 0,
+          db: config.db || 0,
+          keyPrefix: config.keyPrefix || "",
+          connectTimeout: config.connectTimeout || 1e4,
+          commandTimeout: config.commandTimeout || 5e3,
+          maxRetriesPerRequest: config.maxRetriesPerRequest || 3,
+          retryStrategy: /* @__PURE__ */ __name((times) => {
+            const delay = Math.min(times * 50, 2e3);
+            koatty_logger.DefaultLogger.Debug(`Redis reconnecting, attempt ${times}, delay ${delay}ms`);
+            return delay;
+          }, "retryStrategy"),
+          reconnectOnError: /* @__PURE__ */ __name((err) => {
+            koatty_logger.DefaultLogger.Warn("Redis connection error, attempting reconnect:", err.message);
+            return true;
+          }, "reconnectOnError")
+        };
+        const client = new Redis__default.default(options);
+        client.on("connect", () => {
+          koatty_logger.DefaultLogger.Info("Redis standalone client connected successfully");
+        });
+        client.on("error", (err) => {
+          koatty_logger.DefaultLogger.Error("Redis standalone client error:", err);
+        });
+        return new exports.RedisClientAdapter(client);
+      }
+      /**
+      * Create sentinel Redis client
+      * @param config - Sentinel configuration
+      */
+      static createSentinelClient(config) {
+        koatty_logger.DefaultLogger.Debug(`Creating sentinel Redis client for master: ${config.name}`);
+        const options = {
+          sentinels: config.sentinels,
+          name: config.name,
+          password: config.password || void 0,
+          sentinelPassword: config.sentinelPassword || void 0,
+          db: config.db || 0,
+          keyPrefix: config.keyPrefix || "",
+          connectTimeout: config.connectTimeout || 1e4,
+          commandTimeout: config.commandTimeout || 5e3,
+          maxRetriesPerRequest: config.maxRetriesPerRequest || 3,
+          retryStrategy: /* @__PURE__ */ __name((times) => {
+            const delay = Math.min(times * 50, 2e3);
+            koatty_logger.DefaultLogger.Debug(`Sentinel Redis reconnecting, attempt ${times}, delay ${delay}ms`);
+            return delay;
+          }, "retryStrategy")
+        };
+        const client = new Redis__default.default(options);
+        client.on("connect", () => {
+          koatty_logger.DefaultLogger.Info(`Redis sentinel client connected to master: ${config.name}`);
+        });
+        client.on("error", (err) => {
+          koatty_logger.DefaultLogger.Error("Redis sentinel client error:", err);
+        });
+        return new exports.RedisClientAdapter(client);
+      }
+      /**
+      * Create cluster Redis client
+      * @param config - Cluster configuration
+      */
+      static createClusterClient(config) {
+        koatty_logger.DefaultLogger.Debug(`Creating cluster Redis client with ${config.nodes.length} nodes`);
+        const clusterOptions = {
+          redisOptions: {
+            password: config.redisOptions?.password || config.password || void 0,
+            db: config.redisOptions?.db || config.db || 0,
+            keyPrefix: config.keyPrefix || "",
+            connectTimeout: config.connectTimeout || 1e4,
+            commandTimeout: config.commandTimeout || 5e3,
+            maxRetriesPerRequest: config.maxRetriesPerRequest || 3
+          },
+          clusterRetryStrategy: /* @__PURE__ */ __name((times) => {
+            const delay = Math.min(times * 50, 2e3);
+            koatty_logger.DefaultLogger.Debug(`Cluster Redis reconnecting, attempt ${times}, delay ${delay}ms`);
+            return delay;
+          }, "clusterRetryStrategy")
+        };
+        const cluster = new Redis.Cluster(config.nodes, clusterOptions);
+        cluster.on("connect", () => {
+          koatty_logger.DefaultLogger.Info("Redis cluster client connected successfully");
+        });
+        cluster.on("error", (err) => {
+          koatty_logger.DefaultLogger.Error("Redis cluster client error:", err);
+        });
+        cluster.on("node error", (err, address) => {
+          koatty_logger.DefaultLogger.Error(`Redis cluster node error at ${address}:`, err);
+        });
+        return new exports.RedisClientAdapter(cluster);
+      }
+      /**
+      * Validate Redis configuration
+      * @param config - Redis configuration to validate
+      */
+      static validateConfig(config) {
+        if (!config) {
+          throw new Error("Redis configuration cannot be empty");
+        }
+        const mode = config.mode || exports.RedisMode.STANDALONE;
+        switch (mode) {
+          case exports.RedisMode.STANDALONE:
+            this.validateStandaloneConfig(config);
+            break;
+          case exports.RedisMode.SENTINEL:
+            this.validateSentinelConfig(config);
+            break;
+          case exports.RedisMode.CLUSTER:
+            this.validateClusterConfig(config);
+            break;
+          default:
+            throw new Error(`Unsupported Redis mode: ${mode}`);
+        }
+      }
+      static validateStandaloneConfig(config) {
+        if (!config.host) {
+          throw new Error("Standalone mode requires host configuration");
+        }
+        if (!config.port) {
+          throw new Error("Standalone mode requires port configuration");
+        }
+      }
+      static validateSentinelConfig(config) {
+        if (!config.sentinels || config.sentinels.length === 0) {
+          throw new Error("Sentinel mode requires at least one sentinel node");
+        }
+        if (!config.name) {
+          throw new Error("Sentinel mode requires master name");
+        }
+      }
+      static validateClusterConfig(config) {
+        if (!config.nodes || config.nodes.length === 0) {
+          throw new Error("Cluster mode requires at least one node");
+        }
+      }
     };
-    const cluster = new Redis.Cluster(config.nodes, clusterOptions);
-    cluster.on("connect", () => {
-      koatty_logger.DefaultLogger.Info("Redis cluster client connected successfully");
-    });
-    cluster.on("error", (err) => {
-      koatty_logger.DefaultLogger.Error("Redis cluster client error:", err);
-    });
-    cluster.on("node error", (err, address) => {
-      koatty_logger.DefaultLogger.Error(`Redis cluster node error at ${address}:`, err);
-    });
-    return new RedisClientAdapter(cluster);
-  }
-  /**
-  * Validate Redis configuration
-  * @param config - Redis configuration to validate
-  */
-  static validateConfig(config) {
-    if (!config) {
-      throw new Error("Redis \u914D\u7F6E\u4E0D\u80FD\u4E3A\u7A7A (Redis configuration cannot be empty)");
-    }
-    const mode = config.mode || RedisMode.STANDALONE;
-    switch (mode) {
-      case RedisMode.STANDALONE:
-        this.validateStandaloneConfig(config);
-        break;
-      case RedisMode.SENTINEL:
-        this.validateSentinelConfig(config);
-        break;
-      case RedisMode.CLUSTER:
-        this.validateClusterConfig(config);
-        break;
-      default:
-        throw new Error(`\u4E0D\u652F\u6301\u7684 Redis \u6A21\u5F0F: ${mode} (Unsupported Redis mode: ${mode})`);
-    }
   }
-  static validateStandaloneConfig(config) {
-    if (!config.host) {
-      throw new Error("\u5355\u673A\u6A21\u5F0F\u9700\u8981 host \u914D\u7F6E (Standalone mode requires host configuration)");
-    }
-    if (!config.port) {
-      throw new Error("\u5355\u673A\u6A21\u5F0F\u9700\u8981 port \u914D\u7F6E (Standalone mode requires port configuration)");
-    }
-  }
-  static validateSentinelConfig(config) {
-    if (!config.sentinels || config.sentinels.length === 0) {
-      throw new Error("\u54E8\u5175\u6A21\u5F0F\u9700\u8981\u81F3\u5C11\u4E00\u4E2A\u54E8\u5175\u8282\u70B9\u914D\u7F6E (Sentinel mode requires at least one sentinel node)");
-    }
-    if (!config.name) {
-      throw new Error("\u54E8\u5175\u6A21\u5F0F\u9700\u8981 master name \u914D\u7F6E (Sentinel mode requires master name)");
-    }
-  }
-  static validateClusterConfig(config) {
-    if (!config.nodes || config.nodes.length === 0) {
-      throw new Error("\u96C6\u7FA4\u6A21\u5F0F\u9700\u8981\u81F3\u5C11\u4E00\u4E2A\u8282\u70B9\u914D\u7F6E (Cluster mode requires at least one node)");
-    }
-  }
-};
+});
 
 // src/locker/redlock.ts
-var defaultRedLockConfig = {
-  lockTimeOut: 1e4,
-  clockDriftFactor: 0.01,
-  maxRetries: 3,
-  retryDelayMs: 200,
-  redisConfig: {
-    mode: RedisMode.STANDALONE,
-    host: "127.0.0.1",
-    port: 6379,
-    password: "",
-    db: 0,
-    keyPrefix: "redlock:"
-  }
-};
-var defaultRedlockSettings = {
-  driftFactor: 0.01,
-  retryCount: 3,
-  retryDelay: 200,
-  retryJitter: 200,
-  automaticExtensionThreshold: 500
-};
-var RedLocker = class _RedLocker {
-  static {
-    __name(this, "RedLocker");
-  }
-  static instance = null;
-  static instanceLock = /* @__PURE__ */ Symbol("RedLocker.instanceLock");
-  redlock = null;
-  redisClient = null;
-  config;
-  isInitialized = false;
-  initializationPromise = null;
-  // 私有构造函数防止外部直接实例化
-  constructor(options) {
-    this.config = {
-      ...defaultRedLockConfig,
-      ...options
+var redlock_exports = {};
+__export(redlock_exports, {
+  RedLocker: () => exports.RedLocker
+});
+var defaultRedLockConfig, defaultRedlockSettings; exports.RedLocker = void 0;
+var init_redlock = __esm({
+  "src/locker/redlock.ts"() {
+    init_interface();
+    init_redis_factory();
+    defaultRedLockConfig = {
+      lockTimeOut: 1e4,
+      clockDriftFactor: 0.01,
+      maxRetries: 3,
+      retryDelayMs: 200,
+      redisConfig: {
+        mode: exports.RedisMode.STANDALONE,
+        host: "127.0.0.1",
+        port: 6379,
+        password: "",
+        db: 0,
+        keyPrefix: "redlock:"
+      }
     };
-    this.registerInContainer();
-  }
-  /**
-  * Register RedLocker in IOC container
-  * @private
-  */
-  registerInContainer() {
-    try {
-      koatty_container.IOCContainer.reg("RedLocker", this, {
-        type: "COMPONENT",
-        args: []
-      });
-      koatty_logger.DefaultLogger.Debug("RedLocker registered in IOC container");
-    } catch (_error) {
-      koatty_logger.DefaultLogger.Warn("Failed to register RedLocker in IOC container:", _error);
-    }
-  }
-  /**
-  * Get RedLocker singleton instance with thread-safe initialization
-  * @static
-  * @param options - RedLock configuration options (only used for first initialization)
-  * @returns RedLocker singleton instance
-  */
-  static getInstance(options) {
-    if (!_RedLocker.instance) {
-      if (_RedLocker.instance === null) {
+    defaultRedlockSettings = {
+      driftFactor: 0.01,
+      retryCount: 3,
+      retryDelay: 200,
+      retryJitter: 200,
+      automaticExtensionThreshold: 500
+    };
+    exports.RedLocker = class _RedLocker {
+      static {
+        __name(this, "RedLocker");
+      }
+      static instance = null;
+      static instanceLock = /* @__PURE__ */ Symbol("RedLocker.instanceLock");
+      redlock = null;
+      redisClient = null;
+      config;
+      isInitialized = false;
+      initializationPromise = null;
+      // 私有构造函数防止外部直接实例化
+      constructor(options) {
+        this.config = {
+          ...defaultRedLockConfig,
+          ...options
+        };
+        this.registerInContainer();
+      }
+      /**
+      * Register RedLocker in IOC container
+      * @private
+      */
+      registerInContainer() {
         try {
-          const containerInstance = koatty_container.IOCContainer.get("RedLocker", "COMPONENT");
-          if (containerInstance) {
-            _RedLocker.instance = containerInstance;
-            koatty_logger.DefaultLogger.Debug("Retrieved existing RedLocker instance from IOC container");
-          } else {
-            _RedLocker.instance = new _RedLocker(options);
-            koatty_logger.DefaultLogger.Debug("Created new RedLocker singleton instance");
+          const RedLockerClass = this.constructor;
+          koatty_container.IOCContainer.saveClass("COMPONENT", RedLockerClass, "RedLocker");
+          koatty_container.IOCContainer.setExistingInstance(RedLockerClass, this);
+          koatty_logger.DefaultLogger.Debug("RedLocker registered in IOC container");
+        } catch (_error) {
+          koatty_logger.DefaultLogger.Warn("Failed to register RedLocker in IOC container:", _error);
+        }
+      }
+      /**
+      * Get RedLocker singleton instance with thread-safe initialization
+      * @static
+      * @param options - RedLock configuration options (only used for first initialization)
+      * @returns RedLocker singleton instance
+      */
+      static getInstance(options) {
+        if (!_RedLocker.instance) {
+          if (_RedLocker.instance === null) {
+            try {
+              const containerInstance = koatty_container.IOCContainer.get("RedLocker", "COMPONENT");
+              if (containerInstance) {
+                _RedLocker.instance = containerInstance;
+                koatty_logger.DefaultLogger.Debug("Retrieved existing RedLocker instance from IOC container");
+              } else {
+                _RedLocker.instance = new _RedLocker(options);
+                koatty_logger.DefaultLogger.Debug("Created new RedLocker singleton instance");
+              }
+            } catch {
+              _RedLocker.instance = new _RedLocker(options);
+              koatty_logger.DefaultLogger.Debug("Created new RedLocker instance outside IOC container");
+            }
           }
-        } catch {
-          _RedLocker.instance = new _RedLocker(options);
-          koatty_logger.DefaultLogger.Debug("Created new RedLocker instance outside IOC container");
+        } else if (options) {
+          koatty_logger.DefaultLogger.Warn("RedLocker instance already exists, ignoring new options. Use updateConfig() to change configuration.");
         }
+        return _RedLocker.instance;
       }
-    } else if (options) {
-      koatty_logger.DefaultLogger.Warn("RedLocker instance already exists, ignoring new options. Use updateConfig() to change configuration.");
-    }
-    return _RedLocker.instance;
-  }
-  /**
-  * Reset singleton instance (主要用于测试)
-  * @static
-  */
-  static resetInstance() {
-    if (_RedLocker.instance) {
-      _RedLocker.instance.close().catch((err) => koatty_logger.DefaultLogger.Warn("Error while closing RedLocker instance during reset:", err));
-      _RedLocker.instance = null;
-    }
-  }
-  /**
-  * Initialize RedLock with Redis connection
-  * Uses cached promise to avoid duplicate initialization
-  * @private
-  */
-  async initialize() {
-    if (this.isInitialized) {
-      return;
-    }
-    if (this.initializationPromise) {
-      return this.initializationPromise;
-    }
-    this.initializationPromise = this.performInitialization();
-    try {
-      await this.initializationPromise;
-    } catch (error) {
-      this.initializationPromise = null;
-      this.isInitialized = false;
-      this.redlock = null;
-      koatty_logger.DefaultLogger.Warn("RedLocker initialization failed, state has been reset for retry");
-      throw error;
-    }
-  }
-  /**
-  * 执行实际的初始化操作
-  * @private
-  */
-  async performInitialization() {
-    try {
-      if (this.config.redisConfig) {
-        RedisFactory.validateConfig(this.config.redisConfig);
+      /**
+      * Reset singleton instance (主要用于测试)
+      * @static
+      */
+      static resetInstance() {
+        if (_RedLocker.instance) {
+          _RedLocker.instance.close().catch((err) => koatty_logger.DefaultLogger.Warn("Error while closing RedLocker instance during reset:", err));
+          _RedLocker.instance = null;
+        }
       }
-      try {
-        const existingRedis = koatty_container.IOCContainer.get("Redis", "COMPONENT");
-        if (existingRedis) {
-          if (existingRedis instanceof RedisClientAdapter) {
-            this.redisClient = existingRedis;
-          } else {
-            this.redisClient = new RedisClientAdapter(existingRedis);
+      /**
+      * Initialize RedLock with Redis connection
+      * Uses cached promise to avoid duplicate initialization
+      * @private
+      */
+      async initialize() {
+        if (this.isInitialized) {
+          return;
+        }
+        if (this.initializationPromise) {
+          return this.initializationPromise;
+        }
+        this.initializationPromise = this.performInitialization();
+        try {
+          await this.initializationPromise;
+        } catch (error) {
+          this.initializationPromise = null;
+          this.isInitialized = false;
+          this.redlock = null;
+          koatty_logger.DefaultLogger.Warn("RedLocker initialization failed, state has been reset for retry");
+          throw error;
+        }
+      }
+      /**
+      * 执行实际的初始化操作
+      * @private
+      */
+      async performInitialization() {
+        try {
+          if (this.config.redisConfig) {
+            exports.RedisFactory.validateConfig(this.config.redisConfig);
           }
-          koatty_logger.DefaultLogger.Debug("Using Redis instance from IOC container");
+          try {
+            const existingRedis = koatty_container.IOCContainer.get("Redis", "COMPONENT");
+            if (existingRedis) {
+              if (existingRedis instanceof exports.RedisClientAdapter) {
+                this.redisClient = existingRedis;
+              } else {
+                this.redisClient = new exports.RedisClientAdapter(existingRedis);
+              }
+              koatty_logger.DefaultLogger.Debug("Using Redis instance from IOC container");
+            }
+          } catch {
+          }
+          if (!this.redisClient && this.config.redisConfig) {
+            this.redisClient = exports.RedisFactory.createClient(this.config.redisConfig);
+            koatty_logger.DefaultLogger.Debug("Created new Redis connection for RedLocker");
+          }
+          if (!this.redisClient) {
+            throw new Error("Failed to initialize Redis connection: no configuration provided");
+          }
+          const underlyingClient = this.redisClient.getClient();
+          const userSettings = this.config;
+          const redlockSettings = {
+            ...defaultRedlockSettings,
+            ...userSettings.driftFactor !== void 0 && {
+              driftFactor: userSettings.driftFactor
+            },
+            ...userSettings.retryCount !== void 0 && {
+              retryCount: userSettings.retryCount
+            },
+            ...userSettings.retryDelay !== void 0 && {
+              retryDelay: userSettings.retryDelay
+            },
+            ...userSettings.retryJitter !== void 0 && {
+              retryJitter: userSettings.retryJitter
+            },
+            ...userSettings.automaticExtensionThreshold !== void 0 && {
+              automaticExtensionThreshold: userSettings.automaticExtensionThreshold
+            }
+          };
+          this.redlock = new redlock.Redlock([
+            underlyingClient
+          ], redlockSettings);
+          this.redlock.on("clientError", (err) => {
+            koatty_logger.DefaultLogger.Error("Redis client error in RedLock:", err);
+          });
+          this.isInitialized = true;
+          koatty_logger.DefaultLogger.Info("RedLocker initialized successfully");
+        } catch (error) {
+          this.isInitialized = false;
+          koatty_logger.DefaultLogger.Error("Failed to initialize RedLocker:", error);
+          throw new Error(`RedLocker initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
-      } catch {
       }
-      if (!this.redisClient && this.config.redisConfig) {
-        this.redisClient = RedisFactory.createClient(this.config.redisConfig);
-        koatty_logger.DefaultLogger.Debug("Created new Redis connection for RedLocker");
+      /**
+      * Acquire a distributed lock
+      * @param resources - Resource identifiers to lock
+      * @param ttl - Time to live in milliseconds
+      * @returns Promise<Lock>
+      */
+      async acquire(resources, ttl) {
+        if (!Array.isArray(resources) || resources.length === 0) {
+          throw new Error("Resources array cannot be empty");
+        }
+        const lockTtl = ttl || this.config.lockTimeOut;
+        if (lockTtl <= 0) {
+          throw new Error("Lock TTL must be positive");
+        }
+        await this.initialize();
+        if (!this.redlock) {
+          throw new Error("RedLock is not initialized");
+        }
+        try {
+          const prefixedResources = resources.map((resource) => `${this.config.redisConfig.keyPrefix}${resource}`);
+          koatty_logger.DefaultLogger.Debug(`Acquiring lock for resources: ${prefixedResources.join(", ")} with TTL: ${lockTtl}ms`);
+          const lock = await this.redlock.acquire(prefixedResources, lockTtl);
+          koatty_logger.DefaultLogger.Debug(`Lock acquired successfully for resources: ${prefixedResources.join(", ")}`);
+          return lock;
+        } catch (error) {
+          koatty_logger.DefaultLogger.Error(`Failed to acquire lock for resources: ${resources.join(", ")}`, error);
+          if (error instanceof Error) {
+            error.message = `Lock acquisition failed: ${error.message}`;
+            throw error;
+          }
+          throw new Error(`Lock acquisition failed: Unknown error`);
+        }
       }
-      if (!this.redisClient) {
-        throw new Error("Failed to initialize Redis connection: no configuration provided");
+      /**
+      * Release a lock
+      * @param lock - Lock instance to release
+      */
+      async release(lock) {
+        if (!lock) {
+          throw new Error("Lock instance is required");
+        }
+        try {
+          await lock.release();
+          koatty_logger.DefaultLogger.Debug("Lock released successfully");
+        } catch (error) {
+          koatty_logger.DefaultLogger.Error("Failed to release lock:", error);
+          if (error instanceof Error) {
+            error.message = `Lock release failed: ${error.message}`;
+            throw error;
+          }
+          throw new Error(`Lock release failed: Unknown error`);
+        }
       }
-      const underlyingClient = this.redisClient.getClient();
-      const userSettings = this.config;
-      const redlockSettings = {
-        ...defaultRedlockSettings,
-        ...userSettings.driftFactor !== void 0 && {
-          driftFactor: userSettings.driftFactor
-        },
-        ...userSettings.retryCount !== void 0 && {
-          retryCount: userSettings.retryCount
-        },
-        ...userSettings.retryDelay !== void 0 && {
-          retryDelay: userSettings.retryDelay
-        },
-        ...userSettings.retryJitter !== void 0 && {
-          retryJitter: userSettings.retryJitter
-        },
-        ...userSettings.automaticExtensionThreshold !== void 0 && {
-          automaticExtensionThreshold: userSettings.automaticExtensionThreshold
+      /**
+      * Extend a lock's TTL
+      * @param lock - Lock instance to extend
+      * @param ttl - New TTL in milliseconds
+      * @returns Extended lock
+      */
+      async extend(lock, ttl) {
+        if (!lock) {
+          throw new Error("Lock instance is required");
+        }
+        if (ttl <= 0) {
+          throw new Error("TTL must be positive");
+        }
+        try {
+          const extendedLock = await lock.extend(ttl);
+          koatty_logger.DefaultLogger.Debug(`Lock extended successfully with TTL: ${ttl}ms`);
+          return extendedLock;
+        } catch (error) {
+          koatty_logger.DefaultLogger.Error("Failed to extend lock:", error);
+          throw new Error(`Lock extension failed: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
-      };
-      this.redlock = new redlock.Redlock([
-        underlyingClient
-      ], redlockSettings);
-      this.redlock.on("clientError", (err) => {
-        koatty_logger.DefaultLogger.Error("Redis client error in RedLock:", err);
-      });
-      this.isInitialized = true;
-      koatty_logger.DefaultLogger.Info("RedLocker initialized successfully");
-    } catch (error) {
-      this.isInitialized = false;
-      koatty_logger.DefaultLogger.Error("Failed to initialize RedLocker:", error);
-      throw new Error(`RedLocker initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-  * Acquire a distributed lock
-  * @param resources - Resource identifiers to lock
-  * @param ttl - Time to live in milliseconds
-  * @returns Promise<Lock>
-  */
-  async acquire(resources, ttl) {
-    if (!Array.isArray(resources) || resources.length === 0) {
-      throw new Error("Resources array cannot be empty");
-    }
-    const lockTtl = ttl || this.config.lockTimeOut;
-    if (lockTtl <= 0) {
-      throw new Error("Lock TTL must be positive");
-    }
-    await this.initialize();
-    if (!this.redlock) {
-      throw new Error("RedLock is not initialized");
-    }
-    try {
-      const prefixedResources = resources.map((resource) => `${this.config.redisConfig.keyPrefix}${resource}`);
-      koatty_logger.DefaultLogger.Debug(`Acquiring lock for resources: ${prefixedResources.join(", ")} with TTL: ${lockTtl}ms`);
-      const lock = await this.redlock.acquire(prefixedResources, lockTtl);
-      koatty_logger.DefaultLogger.Debug(`Lock acquired successfully for resources: ${prefixedResources.join(", ")}`);
-      return lock;
-    } catch (error) {
-      koatty_logger.DefaultLogger.Error(`Failed to acquire lock for resources: ${resources.join(", ")}`, error);
-      if (error instanceof Error) {
-        error.message = `Lock acquisition failed: ${error.message}`;
-        throw error;
       }
-      throw new Error(`Lock acquisition failed: Unknown error`);
-    }
-  }
-  /**
-  * Release a lock
-  * @param lock - Lock instance to release
-  */
-  async release(lock) {
-    if (!lock) {
-      throw new Error("Lock instance is required");
-    }
-    try {
-      await lock.release();
-      koatty_logger.DefaultLogger.Debug("Lock released successfully");
-    } catch (error) {
-      koatty_logger.DefaultLogger.Error("Failed to release lock:", error);
-      if (error instanceof Error) {
-        error.message = `Lock release failed: ${error.message}`;
-        throw error;
+      /**
+      * Check if RedLocker is initialized
+      * @returns true if initialized, false otherwise
+      */
+      isReady() {
+        return this.isInitialized && !!this.redlock && !!this.redisClient;
       }
-      throw new Error(`Lock release failed: Unknown error`);
-    }
-  }
-  /**
-  * Extend a lock's TTL
-  * @param lock - Lock instance to extend
-  * @param ttl - New TTL in milliseconds
-  * @returns Extended lock
-  */
-  async extend(lock, ttl) {
-    if (!lock) {
-      throw new Error("Lock instance is required");
-    }
-    if (ttl <= 0) {
-      throw new Error("TTL must be positive");
-    }
-    try {
-      const extendedLock = await lock.extend(ttl);
-      koatty_logger.DefaultLogger.Debug(`Lock extended successfully with TTL: ${ttl}ms`);
-      return extendedLock;
-    } catch (error) {
-      koatty_logger.DefaultLogger.Error("Failed to extend lock:", error);
-      throw new Error(`Lock extension failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-  * Check if RedLocker is initialized
-  * @returns true if initialized, false otherwise
-  */
-  isReady() {
-    return this.isInitialized && !!this.redlock && !!this.redisClient;
-  }
-  /**
-  * Get current configuration
-  * @returns Current RedLock configuration
-  */
-  getConfig() {
-    return {
-      ...this.config
-    };
-  }
-  /**
-  * Update configuration (requires reinitialization)
-  * @param options - New RedLock options
-  */
-  updateConfig(options) {
-    if (options) {
-      this.config = {
-        ...this.config,
-        ...options
-      };
-    }
-    this.isInitialized = false;
-    this.initializationPromise = null;
-    this.redlock = null;
-    koatty_logger.DefaultLogger.Debug("RedLocker configuration updated, will reinitialize on next use");
-  }
-  /**
-  * Close Redis connection and cleanup
-  */
-  async close() {
-    try {
-      if (this.redisClient && this.redisClient.status === "ready") {
-        await this.redisClient.quit();
-        koatty_logger.DefaultLogger.Debug("Redis connection closed");
+      /**
+      * Get current configuration
+      * @returns Current RedLock configuration
+      */
+      getConfig() {
+        return {
+          ...this.config
+        };
       }
-      this.redisClient = null;
-      this.redlock = null;
-      this.isInitialized = false;
-    } catch (error) {
-      koatty_logger.DefaultLogger.Error("Error closing RedLocker:", error);
-    }
-  }
-  /**
-  * Get container registration status
-  * @returns Registration information
-  */
-  getContainerInfo() {
-    try {
-      const instance = koatty_container.IOCContainer.get("RedLocker", "COMPONENT");
-      return {
-        registered: !!instance,
-        identifier: "RedLocker"
-      };
-    } catch {
-      return {
-        registered: false,
-        identifier: "RedLocker"
-      };
-    }
-  }
-  /**
-  * Health check for RedLocker
-  * @returns Health status
-  */
-  async healthCheck() {
-    try {
-      await this.initialize();
-      const redisStatus = this.redisClient?.status || "unknown";
-      const isReady = this.isReady();
-      return {
-        status: isReady ? "healthy" : "unhealthy",
-        details: {
-          initialized: this.isInitialized,
-          redisStatus,
-          redisMode: this.config.redisConfig?.mode || "unknown",
-          redlockReady: !!this.redlock,
-          containerRegistered: this.getContainerInfo().registered
+      /**
+      * Update configuration (requires reinitialization)
+      * @param options - New RedLock options
+      */
+      updateConfig(options) {
+        if (options) {
+          this.config = {
+            ...this.config,
+            ...options
+          };
         }
-      };
-    } catch (error) {
-      return {
-        status: "unhealthy",
-        details: {
-          error: error instanceof Error ? error.message : "Unknown error",
-          initialized: this.isInitialized
+        this.isInitialized = false;
+        this.initializationPromise = null;
+        this.redlock = null;
+        koatty_logger.DefaultLogger.Debug("RedLocker configuration updated, will reinitialize on next use");
+      }
+      /**
+      * Close Redis connection and cleanup
+      */
+      async close() {
+        try {
+          if (this.redisClient && this.redisClient.status === "ready") {
+            await this.redisClient.quit();
+            koatty_logger.DefaultLogger.Debug("Redis connection closed");
+          }
+          this.redisClient = null;
+          this.redlock = null;
+          this.isInitialized = false;
+        } catch (error) {
+          koatty_logger.DefaultLogger.Error("Error closing RedLocker:", error);
         }
-      };
-    }
+      }
+      /**
+      * Get container registration status
+      * @returns Registration information
+      */
+      getContainerInfo() {
+        try {
+          const instance = koatty_container.IOCContainer.get("RedLocker", "COMPONENT");
+          return {
+            registered: !!instance,
+            identifier: "RedLocker"
+          };
+        } catch {
+          return {
+            registered: false,
+            identifier: "RedLocker"
+          };
+        }
+      }
+      /**
+      * Health check for RedLocker
+      * @returns Health status
+      */
+      async healthCheck() {
+        try {
+          await this.initialize();
+          const redisStatus = this.redisClient?.status || "unknown";
+          const isReady = this.isReady();
+          return {
+            status: isReady ? "healthy" : "unhealthy",
+            details: {
+              initialized: this.isInitialized,
+              redisStatus,
+              redisMode: this.config.redisConfig?.mode || "unknown",
+              redlockReady: !!this.redlock,
+              containerRegistered: this.getContainerInfo().registered
+            }
+          };
+        } catch (error) {
+          return {
+            status: "unhealthy",
+            details: {
+              error: error instanceof Error ? error.message : "Unknown error",
+              initialized: this.isInitialized
+            }
+          };
+        }
+      }
+    };
   }
-};
+});
 
 // src/utils/lib.ts
+var lib_exports = {};
+__export(lib_exports, {
+  timeoutPromise: () => timeoutPromise,
+  wrappedPromise: () => wrappedPromise
+});
 function timeoutPromise(ms) {
   let timeoutId = null;
   const promise = new Promise((resolve, reject) => {
@@ -758,9 +843,30 @@ function timeoutPromise(ms) {
   };
   return promise;
 }
-__name(timeoutPromise, "timeoutPromise");
+function wrappedPromise(fn, args) {
+  return new Promise((resolve, reject) => {
+    try {
+      const result = fn(...args);
+      resolve(result);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+var init_lib = __esm({
+  "src/utils/lib.ts"() {
+    __name(timeoutPromise, "timeoutPromise");
+    __name(wrappedPromise, "wrappedPromise");
+  }
+});
+
+// src/decorator/redlock.ts
+init_config();
 
 // src/process/locker.ts
+init_redlock();
+init_lib();
+init_config();
 async function initRedLock(options, app) {
   if (!app || !koatty_lib.Helper.isFunction(app.once)) {
     koatty_logger.DefaultLogger.Warn(`RedLock initialization skipped: Koatty app not available or not initialized`);
@@ -770,7 +876,7 @@ async function initRedLock(options, app) {
     if (koatty_lib.Helper.isEmpty(options)) {
       throw Error(`Missing RedLock configuration. Please write a configuration item with the key name 'RedLock' in the db.ts file.`);
     }
-    const redLocker = RedLocker.getInstance(options);
+    const redLocker = exports.RedLocker.getInstance(options);
     await redLocker.initialize();
     koatty_logger.DefaultLogger.Info("RedLock initialized successfully");
   } catch (error) {
@@ -843,7 +949,7 @@ function redLockerDescriptor(descriptor, name, method, methodOptions) {
     writable: true,
     async value(...props) {
       try {
-        const redlock = RedLocker.getInstance();
+        const redlock = exports.RedLocker.getInstance();
         const lockOptions = getEffectiveRedLockOptions(methodOptions);
         const lockTime = lockOptions.lockTimeOut || 1e4;
         if (lockTime <= 200) {
@@ -884,33 +990,89 @@ __name(generateLockName, "generateLockName");
 
 // src/decorator/redlock.ts
 function RedLock(lockName, options) {
-  return (target, propertyKey, descriptor) => {
-    const methodName = propertyKey.toString();
-    const targetClass = target.constructor;
-    const componentType = koatty_container.IOCContainer.getType(targetClass);
-    if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
-      throw Error("@RedLock decorator can only be used on SERVICE or COMPONENT classes.");
-    }
-    if (!methodName || typeof methodName !== "string") {
-      throw Error("Method name is required for @RedLock decorator");
-    }
-    if (!descriptor || typeof descriptor.value !== "function") {
-      throw Error("@RedLock decorator can only be applied to methods");
-    }
-    const finalLockName = lockName || generateLockName(lockName, methodName, target);
-    if (options) {
-      validateRedLockMethodOptions(options);
-    }
-    koatty_container.IOCContainer.saveClass("COMPONENT", targetClass, targetClass.name);
-    try {
-      const enhancedDescriptor = redLockerDescriptor(descriptor, finalLockName, methodName, options);
-      return enhancedDescriptor;
-    } catch (error) {
-      throw new Error(`Failed to apply RedLock to ${methodName}: ${error.message}`);
+  return koatty_container.IOCContainer.createDecorator(({ target, methodName, descriptor, method, context }) => {
+    if (context) {
+      if (!methodName || typeof methodName !== "string") {
+        throw Error("Method name is required for @RedLock decorator");
+      }
+      if (options) {
+        validateRedLockMethodOptions(options);
+      }
+      context.addInitializer?.(function() {
+        const targetClass = this.constructor;
+        const componentType = koatty_container.IOCContainer.getType(targetClass);
+        if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
+          throw Error("@RedLock decorator can only be used on SERVICE or COMPONENT classes.");
+        }
+        koatty_container.IOCContainer.saveClass("COMPONENT", targetClass, targetClass.name);
+      });
+      const originalMethod = method;
+      return async function(...props) {
+        try {
+          const { RedLocker: RedLocker2 } = await Promise.resolve().then(() => (init_redlock(), redlock_exports));
+          const { getEffectiveRedLockOptions: getEffectiveRedLockOptions2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const { timeoutPromise: timeoutPromise2 } = await Promise.resolve().then(() => (init_lib(), lib_exports));
+          const { Lock } = await import('@sesamecare-oss/redlock');
+          const resolvedLockName = lockName || generateLockName(lockName, methodName, Object.getPrototypeOf(this));
+          const redlock = RedLocker2.getInstance();
+          const lockOptions = getEffectiveRedLockOptions2(options);
+          const lockTime = lockOptions.lockTimeOut || 1e4;
+          if (lockTime <= 200) {
+            throw new Error("Lock timeout must be greater than 200ms to allow for proper execution");
+          }
+          const lock = await redlock.acquire([
+            methodName,
+            resolvedLockName
+          ], lockTime);
+          const timeout = lockTime - 200;
+          try {
+            const result = await Promise.race([
+              originalMethod.apply(this, props),
+              timeoutPromise2(timeout)
+            ]);
+            return result;
+          } catch (error) {
+            throw error;
+          } finally {
+            try {
+              await lock.release();
+            } catch (releaseError) {
+            }
+          }
+        } catch (error) {
+          throw error;
+        }
+      };
+    } else {
+      const targetClass = target.constructor;
+      const componentType = koatty_container.IOCContainer.getType(targetClass);
+      if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
+        throw Error("@RedLock decorator can only be used on SERVICE or COMPONENT classes.");
+      }
+      if (!methodName || typeof methodName !== "string") {
+        throw Error("Method name is required for @RedLock decorator");
+      }
+      if (!descriptor || typeof descriptor.value !== "function") {
+        throw Error("@RedLock decorator can only be applied to methods");
+      }
+      const finalLockName = lockName || generateLockName(lockName, methodName, target);
+      if (options) {
+        validateRedLockMethodOptions(options);
+      }
+      koatty_container.IOCContainer.saveClass("COMPONENT", targetClass, targetClass.name);
+      try {
+        const enhancedDescriptor = redLockerDescriptor(descriptor, finalLockName, methodName, options);
+        return enhancedDescriptor;
+      } catch (error) {
+        throw new Error(`Failed to apply RedLock to ${methodName}: ${error.message}`);
+      }
     }
-  };
+  }, "method");
 }
 __name(RedLock, "RedLock");
+
+// src/decorator/scheduled.ts
+init_config();
 function Scheduled(cron, timezone = "Asia/Beijing") {
   if (koatty_lib.Helper.isEmpty(cron)) {
     throw Error("Cron expression is required and cannot be empty");
@@ -923,28 +1085,50 @@ function Scheduled(cron, timezone = "Asia/Beijing") {
   if (timezone && typeof timezone !== "string") {
     throw Error("Timezone must be a string");
   }
-  return (target, propertyKey, descriptor) => {
-    const targetClass = target.constructor;
-    const componentType = koatty_container.IOCContainer.getType(targetClass);
-    if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
-      throw Error("@Scheduled decorator can only be used on SERVICE or COMPONENT classes.");
-    }
-    const methodName = propertyKey.toString();
-    if (!methodName || typeof methodName !== "string") {
-      throw Error("Method name is required for @Scheduled decorator");
-    }
-    if (!descriptor || typeof descriptor.value !== "function") {
-      throw Error("@Scheduled decorator can only be applied to methods");
+  return koatty_container.IOCContainer.createDecorator(({ target, methodName, descriptor, method, context }) => {
+    if (context) {
+      context.addInitializer?.(function() {
+        const targetClass = this.constructor;
+        const componentType = koatty_container.IOCContainer.getType(targetClass);
+        if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
+          throw Error("@Scheduled decorator can only be used on SERVICE or COMPONENT classes.");
+        }
+        if (!methodName || typeof methodName !== "string") {
+          throw Error("Method name is required for @Scheduled decorator");
+        }
+        koatty_container.IOCContainer.saveClass("COMPONENT", targetClass, targetClass.name);
+        koatty_container.IOCContainer.attachClassMetadata(COMPONENT_SCHEDULED, DecoratorType.SCHEDULED, {
+          method: methodName,
+          cron,
+          timezone
+        }, this, methodName);
+      });
+      return method;
+    } else {
+      const targetClass = target.constructor;
+      const componentType = koatty_container.IOCContainer.getType(targetClass);
+      if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
+        throw Error("@Scheduled decorator can only be used on SERVICE or COMPONENT classes.");
+      }
+      if (!methodName || typeof methodName !== "string") {
+        throw Error("Method name is required for @Scheduled decorator");
+      }
+      if (!descriptor || typeof descriptor.value !== "function") {
+        throw Error("@Scheduled decorator can only be applied to methods");
+      }
+      koatty_container.IOCContainer.saveClass("COMPONENT", targetClass, targetClass.name);
+      koatty_container.IOCContainer.attachClassMetadata(COMPONENT_SCHEDULED, DecoratorType.SCHEDULED, {
+        method: methodName,
+        cron,
+        timezone
+      }, target, methodName);
     }
-    koatty_container.IOCContainer.saveClass("COMPONENT", targetClass, targetClass.name);
-    koatty_container.IOCContainer.attachClassMetadata(COMPONENT_SCHEDULED, DecoratorType.SCHEDULED, {
-      method: methodName,
-      cron,
-      timezone
-    }, target, methodName);
-  };
+  }, "method");
 }
 __name(Scheduled, "Scheduled");
+
+// src/process/schedule.ts
+init_config();
 async function initSchedule(options, app) {
   if (!app || !koatty_lib.Helper.isFunction(app.once)) {
     koatty_logger.DefaultLogger.Warn(`Schedule initialization skipped: Koatty app not available or not initialized`);
@@ -962,54 +1146,45 @@ __name(initSchedule, "initSchedule");
 async function injectSchedule(options) {
   try {
     koatty_logger.DefaultLogger.Debug("Starting batch schedule injection...");
+    let totalScheduled = 0;
     const componentList = koatty_container.IOCContainer.listClass("COMPONENT");
     for (const component of componentList) {
       const classMetadata = koatty_container.IOCContainer.getClassMetadata(COMPONENT_SCHEDULED, DecoratorType.SCHEDULED, component.target);
-      if (!classMetadata) {
+      if (!classMetadata || !Array.isArray(classMetadata)) {
+        continue;
+      }
+      const instance = koatty_container.IOCContainer.get(component.id);
+      if (!instance) {
         continue;
       }
-      let scheduledCount = 0;
-      for (const [className, metadata] of classMetadata) {
+      for (const scheduleData of classMetadata) {
         try {
-          const instance = koatty_container.IOCContainer.get(className);
-          if (!instance) {
+          if (!scheduleData || !scheduleData.method) {
             continue;
           }
-          for (const [key, value] of Object.entries(metadata)) {
-            if (key.startsWith("SCHEDULED")) {
-              const scheduleData = value;
-              const targetMethod = instance[scheduleData.method];
-              if (!koatty_lib.Helper.isFunction(targetMethod)) {
-                koatty_logger.DefaultLogger.Warn(`Schedule injection skipped: method ${scheduleData.method} is not a function in ${className}`);
-                continue;
-              }
-              const taskName = `${className}_${scheduleData.method}`;
-              const tz = getEffectiveTimezone(options, scheduleData.timezone);
-              new cron.CronJob(
-                scheduleData.cron,
-                () => {
-                  koatty_logger.DefaultLogger.Debug(`The schedule job ${taskName} started.`);
-                  Promise.resolve(targetMethod.call(instance)).then(() => {
-                    koatty_logger.DefaultLogger.Debug(`The schedule job ${taskName} completed.`);
-                  }).catch((error) => {
-                    koatty_logger.DefaultLogger.Error(`The schedule job ${taskName} failed:`, error);
-                  });
-                },
-                null,
-                true,
-                tz
-                // timeZone
-              );
-              scheduledCount++;
-              koatty_logger.DefaultLogger.Debug(`Schedule job ${taskName} registered with cron: ${scheduleData.cron}`);
-            }
+          const targetMethod = instance[scheduleData.method];
+          if (!koatty_lib.Helper.isFunction(targetMethod)) {
+            koatty_logger.DefaultLogger.Warn(`Schedule injection skipped: method ${scheduleData.method} is not a function in ${component.id}`);
+            continue;
           }
+          const taskName = `${component.id}_${scheduleData.method}`;
+          const tz = getEffectiveTimezone(options, scheduleData.timezone);
+          new cron.CronJob(scheduleData.cron, () => {
+            koatty_logger.DefaultLogger.Debug(`The schedule job ${taskName} started.`);
+            Promise.resolve(targetMethod.call(instance)).then(() => {
+              koatty_logger.DefaultLogger.Debug(`The schedule job ${taskName} completed.`);
+            }).catch((error) => {
+              koatty_logger.DefaultLogger.Error(`The schedule job ${taskName} failed:`, error);
+            });
+          }, null, true, tz);
+          totalScheduled++;
+          koatty_logger.DefaultLogger.Debug(`Schedule job ${taskName} registered with cron: ${scheduleData.cron}`);
         } catch (error) {
-          koatty_logger.DefaultLogger.Error(`Failed to process class ${className}:`, error);
+          koatty_logger.DefaultLogger.Error(`Failed to process schedule for ${component.id}:`, error);
         }
       }
-      koatty_logger.DefaultLogger.Info(`Batch schedule injection completed. ${scheduledCount} jobs registered.`);
     }
+    koatty_logger.DefaultLogger.Info(`Batch schedule injection completed. ${totalScheduled} jobs registered.`);
   } catch (error) {
     koatty_logger.DefaultLogger.Error("Failed to inject schedules:", error);
   }
@@ -1017,6 +1192,10 @@ async function injectSchedule(options) {
 __name(injectSchedule, "injectSchedule");
 
 // src/index.ts
+init_interface();
+init_redlock();
+init_interface();
+init_redis_factory();
 var SchedulerLock = RedLock;
 var defaultOptions = {
   timezone: "Asia/Beijing",
@@ -1025,7 +1204,7 @@ var defaultOptions = {
   maxRetries: 3,
   retryDelayMs: 200,
   redisConfig: {
-    mode: RedisMode.STANDALONE,
+    mode: exports.RedisMode.STANDALONE,
     host: "localhost",
     port: 6379,
     password: "",
@@ -1047,10 +1226,6 @@ __name(KoattyScheduled, "KoattyScheduled");
 
 exports.KoattyScheduled = KoattyScheduled;
 exports.RedLock = RedLock;
-exports.RedLocker = RedLocker;
-exports.RedisClientAdapter = RedisClientAdapter;
-exports.RedisFactory = RedisFactory;
-exports.RedisMode = RedisMode;
 exports.Scheduled = Scheduled;
 exports.SchedulerLock = SchedulerLock;
 //# sourceMappingURL=index.js.map