@h-ai/cache 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,1571 @@
+import { z } from 'zod';
+import { core, err, ok } from '@h-ai/core';
+import Redis from 'ioredis';
+
+// src/cache-config.ts
+var RedisClusterNodeSchema = z.object({
+  /** 节点主机地址 */
+  host: z.string(),
+  /** 节点端口号（1~65535） */
+  port: z.number().int().min(1).max(65535)
+});
+var RedisSentinelConfigSchema = z.object({
+  /** 哨兵节点列表（至少 1 个） */
+  sentinels: z.array(RedisClusterNodeSchema).min(1),
+  /** 哨兵监控的主节点名称 */
+  name: z.string()
+});
+var MemoryConfigSchema = z.object({
+  type: z.literal("memory")
+});
+var RedisConfigSchema = z.object({
+  type: z.literal("redis"),
+  // 连接（优先级：url > cluster > sentinel > host）
+  /** Redis 连接 URL（如 redis://user:pass@host:6379/0），优先级最高 */
+  url: z.string().optional(),
+  /** 主机地址；默认 'localhost' */
+  host: z.string().default("localhost"),
+  /** 端口号；默认 6379 */
+  port: z.number().int().min(1).max(65535).default(6379),
+  /** 认证密码 */
+  password: z.string().optional(),
+  /** 数据库编号（0~15）；默认 0 */
+  db: z.number().int().min(0).max(15).default(0),
+  /** 集群节点列表；配置后以集群模式连接 */
+  cluster: z.array(RedisClusterNodeSchema).optional(),
+  /** 哨兵配置；配置后以哨兵模式连接 */
+  sentinel: RedisSentinelConfigSchema.optional(),
+  // 通用选项
+  /** 连接超时时间（毫秒）；默认 10000 */
+  connectTimeout: z.number().int().min(0).default(1e4),
+  /** 命令执行超时（毫秒）；默认 5000 */
+  commandTimeout: z.number().int().min(0).default(5e3),
+  /** 键前缀（自动加在所有键前） */
+  keyPrefix: z.string().optional(),
+  /** 是否开启 TLS；默认 false */
+  tls: z.boolean().default(false),
+  /** 最大重试次数；默认 3 */
+  maxRetries: z.number().int().min(0).default(3),
+  /** 重试间隔基数（毫秒）；实际间隔 = retryDelay × 重试次数；默认 50 */
+  retryDelay: z.number().int().min(0).default(50),
+  /** 是否只读模式；默认 false */
+  readOnly: z.boolean().default(false)
+});
+var CacheConfigSchema = z.discriminatedUnion("type", [
+  MemoryConfigSchema,
+  RedisConfigSchema
+]);
+
+// messages/en-US.json
+var en_US_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  cache_notInitialized: "Cache not initialized, please call cache.init() first",
+  cache_operationFailed: "Cache operation failed: {error}",
+  cache_redisConnectionFailed: "Redis connection failed: {error}",
+  cache_initFailed: "Cache initialization failed: {error}",
+  cache_unsupportedType: "Unsupported cache type: {type}",
+  cache_valueNotNumber: "Value is not a number",
+  cache_keyNotFound: "Key not found",
+  cache_indexOutOfRange: "Index out of range",
+  cache_configError: "Cache config validation failed: {error}"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  cache_notInitialized: "\u7F13\u5B58\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 cache.init()",
+  cache_operationFailed: "\u7F13\u5B58\u64CD\u4F5C\u5931\u8D25\uFF1A{error}",
+  cache_redisConnectionFailed: "Redis \u8FDE\u63A5\u5931\u8D25\uFF1A{error}",
+  cache_initFailed: "\u7F13\u5B58\u521D\u59CB\u5316\u5931\u8D25\uFF1A{error}",
+  cache_unsupportedType: "\u4E0D\u652F\u6301\u7684\u7F13\u5B58\u7C7B\u578B\uFF1A{type}",
+  cache_valueNotNumber: "\u503C\u4E0D\u662F\u6570\u5B57",
+  cache_keyNotFound: "\u952E\u4E0D\u5B58\u5728",
+  cache_indexOutOfRange: "\u7D22\u5F15\u8D8A\u754C",
+  cache_configError: "\u7F13\u5B58\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A{error}"
+};
+
+// src/cache-i18n.ts
+var cacheM = core.i18n.createMessageGetter({
+  "zh-CN": zh_CN_default,
+  "en-US": en_US_default
+});
+var CacheErrorInfo = {
+  CONNECTION_FAILED: "001:500",
+  OPERATION_FAILED: "002:500",
+  SERIALIZATION_FAILED: "003:500",
+  DESERIALIZATION_FAILED: "004:500",
+  KEY_NOT_FOUND: "005:404",
+  TIMEOUT: "006:504",
+  NOT_INITIALIZED: "010:500",
+  UNSUPPORTED_TYPE: "011:400",
+  CONFIG_ERROR: "012:500"
+};
+var HaiCacheError = core.error.buildHaiErrorsDef("cache", CacheErrorInfo);
+function serializeValue(value) {
+  return JSON.stringify(value);
+}
+function deserializeValue(str) {
+  return JSON.parse(str);
+}
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regexStr = escaped.replace(/\\\*/g, ".*").replace(/\\\?/g, ".");
+  return new RegExp(`^${regexStr}$`);
+}
+function createMemoryProvider() {
+  const store = /* @__PURE__ */ new Map();
+  const hashStore = /* @__PURE__ */ new Map();
+  const listStore = /* @__PURE__ */ new Map();
+  const setStore = /* @__PURE__ */ new Map();
+  const zsetStore = /* @__PURE__ */ new Map();
+  let connected = false;
+  let cleanupTimer = null;
+  function isExpired(entry) {
+    return entry.expiresAt != null && Date.now() > entry.expiresAt;
+  }
+  function cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of store.entries()) {
+      if (entry.expiresAt && entry.expiresAt < now) {
+        store.delete(key);
+      }
+    }
+  }
+  function getValidEntry(key) {
+    const entry = store.get(key);
+    if (!entry)
+      return null;
+    if (isExpired(entry)) {
+      store.delete(key);
+      return null;
+    }
+    return entry;
+  }
+  function calculateExpiry(options) {
+    if (!options)
+      return void 0;
+    const now = Date.now();
+    if (options.ex)
+      return now + options.ex * 1e3;
+    if (options.px)
+      return now + options.px;
+    if (options.exat)
+      return options.exat * 1e3;
+    if (options.pxat)
+      return options.pxat;
+    return void 0;
+  }
+  const kv = {
+    async get(key) {
+      const entry = getValidEntry(key);
+      return ok(entry ? entry.value : null);
+    },
+    async set(key, value, options) {
+      const existing = getValidEntry(key) !== null;
+      if (options?.nx && existing)
+        return ok(void 0);
+      if (options?.xx && !existing)
+        return ok(void 0);
+      const currentEntry = getValidEntry(key);
+      const expiresAt = options?.keepTtl && currentEntry ? currentEntry.expiresAt : calculateExpiry(options);
+      store.set(key, { value, expiresAt });
+      return ok(void 0);
+    },
+    async del(...keys) {
+      let count = 0;
+      for (const key of keys) {
+        if (store.delete(key))
+          count++;
+        hashStore.delete(key);
+        listStore.delete(key);
+        setStore.delete(key);
+        zsetStore.delete(key);
+      }
+      return ok(count);
+    },
+    async exists(...keys) {
+      let count = 0;
+      for (const key of keys) {
+        if (getValidEntry(key))
+          count++;
+      }
+      return ok(count);
+    },
+    async expire(key, seconds) {
+      const entry = getValidEntry(key);
+      if (!entry)
+        return ok(false);
+      entry.expiresAt = Date.now() + seconds * 1e3;
+      return ok(true);
+    },
+    async expireAt(key, timestamp) {
+      const entry = getValidEntry(key);
+      if (!entry)
+        return ok(false);
+      entry.expiresAt = timestamp * 1e3;
+      return ok(true);
+    },
+    async ttl(key) {
+      const entry = store.get(key);
+      if (!entry)
+        return ok(-2);
+      if (!entry.expiresAt)
+        return ok(-1);
+      if (isExpired(entry)) {
+        store.delete(key);
+        return ok(-2);
+      }
+      return ok(Math.ceil((entry.expiresAt - Date.now()) / 1e3));
+    },
+    async persist(key) {
+      const entry = getValidEntry(key);
+      if (!entry)
+        return ok(false);
+      delete entry.expiresAt;
+      return ok(true);
+    },
+    async incr(key) {
+      const entry = getValidEntry(key);
+      const current = entry ? Number(entry.value) : 0;
+      if (Number.isNaN(current)) {
+        return err(HaiCacheError.OPERATION_FAILED, cacheM("cache_valueNotNumber"));
+      }
+      const newValue = current + 1;
+      store.set(key, { value: newValue, expiresAt: entry?.expiresAt });
+      return ok(newValue);
+    },
+    async incrBy(key, increment) {
+      const entry = getValidEntry(key);
+      const current = entry ? Number(entry.value) : 0;
+      if (Number.isNaN(current)) {
+        return err(HaiCacheError.OPERATION_FAILED, cacheM("cache_valueNotNumber"));
+      }
+      const newValue = current + increment;
+      store.set(key, { value: newValue, expiresAt: entry?.expiresAt });
+      return ok(newValue);
+    },
+    async decr(key) {
+      return kv.incrBy(key, -1);
+    },
+    async decrBy(key, decrement) {
+      return kv.incrBy(key, -decrement);
+    },
+    async mget(...keys) {
+      const results = [];
+      for (const key of keys) {
+        const entry = getValidEntry(key);
+        results.push(entry ? entry.value : null);
+      }
+      return ok(results);
+    },
+    async mset(entries) {
+      for (const [key, value] of entries) {
+        store.set(key, { value });
+      }
+      return ok(void 0);
+    },
+    async scan(cursor, options) {
+      const allKeys = Array.from(store.keys()).filter((key) => {
+        const entry = store.get(key);
+        return entry && !isExpired(entry);
+      });
+      const regex = options?.match ? globToRegex(options.match) : null;
+      const filtered = regex ? allKeys.filter((k) => regex.test(k)) : allKeys;
+      const count = options?.count || 10;
+      const start = cursor;
+      const end = Math.min(start + count, filtered.length);
+      const keys = filtered.slice(start, end);
+      const nextCursor = end >= filtered.length ? 0 : end;
+      return ok([nextCursor, keys]);
+    },
+    async keys(pattern) {
+      const regex = globToRegex(pattern);
+      const result = [];
+      for (const [key] of store.entries()) {
+        if (regex.test(key) && getValidEntry(key)) {
+          result.push(key);
+        }
+      }
+      return ok(result);
+    },
+    async type(key) {
+      if (getValidEntry(key))
+        return ok("string");
+      if (hashStore.has(key))
+        return ok("hash");
+      if (listStore.has(key))
+        return ok("list");
+      if (setStore.has(key))
+        return ok("set");
+      if (zsetStore.has(key))
+        return ok("zset");
+      return ok("none");
+    }
+  };
+  const hash = {
+    async hget(key, field) {
+      const map = hashStore.get(key);
+      if (!map)
+        return ok(null);
+      const val = map.get(field);
+      return ok(val !== void 0 ? deserializeValue(val) : null);
+    },
+    hset: (async (key, fieldOrData, value) => {
+      let map = hashStore.get(key);
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        hashStore.set(key, map);
+      }
+      if (typeof fieldOrData === "string") {
+        const existed = map.has(fieldOrData);
+        map.set(fieldOrData, serializeValue(value));
+        return ok(existed ? 0 : 1);
+      }
+      let count = 0;
+      for (const [f, v] of Object.entries(fieldOrData)) {
+        if (!map.has(f))
+          count++;
+        map.set(f, serializeValue(v));
+      }
+      return ok(count);
+    }),
+    async hdel(key, ...fields) {
+      const map = hashStore.get(key);
+      if (!map)
+        return ok(0);
+      let count = 0;
+      for (const field of fields) {
+        if (map.delete(field))
+          count++;
+      }
+      return ok(count);
+    },
+    async hexists(key, field) {
+      const map = hashStore.get(key);
+      return ok(map?.has(field) ?? false);
+    },
+    async hgetall(key) {
+      const map = hashStore.get(key);
+      if (!map)
+        return ok({});
+      const result = {};
+      for (const [f, v] of map.entries()) {
+        result[f] = deserializeValue(v);
+      }
+      return ok(result);
+    },
+    async hkeys(key) {
+      const map = hashStore.get(key);
+      return ok(map ? Array.from(map.keys()) : []);
+    },
+    async hvals(key) {
+      const map = hashStore.get(key);
+      if (!map)
+        return ok([]);
+      return ok(Array.from(map.values()).map((v) => deserializeValue(v)));
+    },
+    async hlen(key) {
+      const map = hashStore.get(key);
+      return ok(map?.size ?? 0);
+    },
+    async hmget(key, ...fields) {
+      const map = hashStore.get(key);
+      const results = fields.map((field) => {
+        const val = map?.get(field);
+        return val !== void 0 ? deserializeValue(val) : null;
+      });
+      return ok(results);
+    },
+    async hincrBy(key, field, increment) {
+      let map = hashStore.get(key);
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        hashStore.set(key, map);
+      }
+      const current = map.has(field) ? Number(deserializeValue(map.get(field))) : 0;
+      const newValue = current + increment;
+      map.set(field, serializeValue(newValue));
+      return ok(newValue);
+    }
+  };
+  const list = {
+    async lpush(key, ...values) {
+      let arr = listStore.get(key);
+      if (!arr) {
+        arr = [];
+        listStore.set(key, arr);
+      }
+      for (const value of values) {
+        arr.unshift(serializeValue(value));
+      }
+      return ok(arr.length);
+    },
+    async rpush(key, ...values) {
+      let arr = listStore.get(key);
+      if (!arr) {
+        arr = [];
+        listStore.set(key, arr);
+      }
+      arr.push(...values.map(serializeValue));
+      return ok(arr.length);
+    },
+    async lpop(key) {
+      const arr = listStore.get(key);
+      if (!arr || arr.length === 0)
+        return ok(null);
+      const val = arr.shift();
+      return ok(deserializeValue(val));
+    },
+    async rpop(key) {
+      const arr = listStore.get(key);
+      if (!arr || arr.length === 0)
+        return ok(null);
+      const val = arr.pop();
+      return ok(deserializeValue(val));
+    },
+    async llen(key) {
+      const arr = listStore.get(key);
+      return ok(arr?.length ?? 0);
+    },
+    async lrange(key, start, stop) {
+      const arr = listStore.get(key);
+      if (!arr)
+        return ok([]);
+      const len = arr.length;
+      const s = start < 0 ? Math.max(len + start, 0) : start;
+      const e = stop < 0 ? len + stop + 1 : stop + 1;
+      return ok(arr.slice(s, e).map((v) => deserializeValue(v)));
+    },
+    async lindex(key, index) {
+      const arr = listStore.get(key);
+      if (!arr)
+        return ok(null);
+      const i = index < 0 ? arr.length + index : index;
+      const val = arr[i];
+      return ok(val !== void 0 ? deserializeValue(val) : null);
+    },
+    async lset(key, index, value) {
+      const arr = listStore.get(key);
+      if (!arr) {
+        return err(HaiCacheError.KEY_NOT_FOUND, cacheM("cache_keyNotFound"));
+      }
+      const i = index < 0 ? arr.length + index : index;
+      if (i < 0 || i >= arr.length) {
+        return err(HaiCacheError.OPERATION_FAILED, cacheM("cache_indexOutOfRange"));
+      }
+      arr[i] = serializeValue(value);
+      return ok(void 0);
+    },
+    async ltrim(key, start, stop) {
+      const arr = listStore.get(key);
+      if (!arr)
+        return ok(void 0);
+      const len = arr.length;
+      const s = start < 0 ? Math.max(len + start, 0) : start;
+      const e = stop < 0 ? len + stop + 1 : stop + 1;
+      listStore.set(key, arr.slice(s, e));
+      return ok(void 0);
+    },
+    /**
+     * Memory 版本的 blpop 为“非阻塞模拟”：忽略 timeout，立即按 keys 顺序尝试弹出。
+     */
+    async blpop(_timeout, ...keys) {
+      for (const key of keys) {
+        const arr = listStore.get(key);
+        if (arr && arr.length > 0) {
+          const val = arr.shift();
+          return ok([key, deserializeValue(val)]);
+        }
+      }
+      return ok(null);
+    },
+    /**
+     * Memory 版本的 brpop 为“非阻塞模拟”：忽略 timeout，立即按 keys 顺序尝试弹出。
+     */
+    async brpop(_timeout, ...keys) {
+      for (const key of keys) {
+        const arr = listStore.get(key);
+        if (arr && arr.length > 0) {
+          const val = arr.pop();
+          return ok([key, deserializeValue(val)]);
+        }
+      }
+      return ok(null);
+    }
+  };
+  const set_ = {
+    async sadd(key, ...members) {
+      let s = setStore.get(key);
+      if (!s) {
+        s = /* @__PURE__ */ new Set();
+        setStore.set(key, s);
+      }
+      let count = 0;
+      for (const member of members) {
+        const str = serializeValue(member);
+        if (!s.has(str)) {
+          s.add(str);
+          count++;
+        }
+      }
+      return ok(count);
+    },
+    async srem(key, ...members) {
+      const s = setStore.get(key);
+      if (!s)
+        return ok(0);
+      let count = 0;
+      for (const member of members) {
+        if (s.delete(serializeValue(member)))
+          count++;
+      }
+      return ok(count);
+    },
+    async smembers(key) {
+      const s = setStore.get(key);
+      if (!s)
+        return ok([]);
+      return ok(Array.from(s).map((v) => deserializeValue(v)));
+    },
+    async sismember(key, member) {
+      const s = setStore.get(key);
+      return ok(s?.has(serializeValue(member)) ?? false);
+    },
+    async scard(key) {
+      const s = setStore.get(key);
+      return ok(s?.size ?? 0);
+    },
+    async srandmember(key, count) {
+      const s = setStore.get(key);
+      if (!s || s.size === 0)
+        return ok(null);
+      const arr = Array.from(s);
+      if (count === void 0) {
+        const idx = Math.floor(Math.random() * arr.length);
+        return ok(deserializeValue(arr[idx]));
+      }
+      const result = [];
+      for (let i = 0; i < Math.min(Math.abs(count), arr.length); i++) {
+        const idx = Math.floor(Math.random() * arr.length);
+        result.push(deserializeValue(arr[idx]));
+      }
+      return ok(result);
+    },
+    async spop(key, count) {
+      const s = setStore.get(key);
+      if (!s || s.size === 0)
+        return ok(null);
+      const arr = Array.from(s);
+      if (count === void 0) {
+        const idx = Math.floor(Math.random() * arr.length);
+        const val = arr[idx];
+        s.delete(val);
+        return ok(deserializeValue(val));
+      }
+      const result = [];
+      for (let i = 0; i < Math.min(count, arr.length); i++) {
+        const idx = Math.floor(Math.random() * arr.length);
+        const val = arr.splice(idx, 1)[0];
+        s.delete(val);
+        result.push(deserializeValue(val));
+      }
+      return ok(result);
+    },
+    async sinter(...keys) {
+      if (keys.length === 0)
+        return ok([]);
+      const sets = keys.map((k) => setStore.get(k));
+      if (sets.some((s) => !s))
+        return ok([]);
+      const [first, ...rest] = sets;
+      const result = Array.from(first).filter((v) => rest.every((s) => s.has(v)));
+      return ok(result.map((v) => deserializeValue(v)));
+    },
+    async sunion(...keys) {
+      const union = /* @__PURE__ */ new Set();
+      for (const key of keys) {
+        const s = setStore.get(key);
+        if (s) {
+          for (const v of s) union.add(v);
+        }
+      }
+      return ok(Array.from(union).map((v) => deserializeValue(v)));
+    },
+    async sdiff(...keys) {
+      if (keys.length === 0)
+        return ok([]);
+      const first = setStore.get(keys[0]);
+      if (!first)
+        return ok([]);
+      const rest = keys.slice(1).map((k) => setStore.get(k)).filter(Boolean);
+      const result = Array.from(first).filter((v) => !rest.some((s) => s.has(v)));
+      return ok(result.map((v) => deserializeValue(v)));
+    }
+  };
+  const zset = {
+    async zadd(key, ...members) {
+      let map = zsetStore.get(key);
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        zsetStore.set(key, map);
+      }
+      let count = 0;
+      for (const { score, member } of members) {
+        if (!map.has(member))
+          count++;
+        map.set(member, score);
+      }
+      return ok(count);
+    },
+    async zrem(key, ...members) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok(0);
+      let count = 0;
+      for (const member of members) {
+        if (map.delete(member))
+          count++;
+      }
+      return ok(count);
+    },
+    async zscore(key, member) {
+      const map = zsetStore.get(key);
+      const score = map?.get(member);
+      return ok(score !== void 0 ? score : null);
+    },
+    async zrank(key, member) {
+      const map = zsetStore.get(key);
+      if (!map || !map.has(member))
+        return ok(null);
+      const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
+      const idx = sorted.findIndex(([m]) => m === member);
+      return ok(idx >= 0 ? idx : null);
+    },
+    async zrevrank(key, member) {
+      const map = zsetStore.get(key);
+      if (!map || !map.has(member))
+        return ok(null);
+      const sorted = Array.from(map.entries()).sort((a, b) => b[1] - a[1]);
+      const idx = sorted.findIndex(([m]) => m === member);
+      return ok(idx >= 0 ? idx : null);
+    },
+    async zrange(key, start, stop, withScores) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok([]);
+      const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
+      const len = sorted.length;
+      const s = start < 0 ? Math.max(len + start, 0) : start;
+      const e = stop < 0 ? len + stop + 1 : stop + 1;
+      const slice = sorted.slice(s, e);
+      if (withScores) {
+        return ok(slice.map(([member, score]) => ({ member, score })));
+      }
+      return ok(slice.map(([member]) => member));
+    },
+    async zrevrange(key, start, stop, withScores) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok([]);
+      const sorted = Array.from(map.entries()).sort((a, b) => b[1] - a[1]);
+      const len = sorted.length;
+      const s = start < 0 ? Math.max(len + start, 0) : start;
+      const e = stop < 0 ? len + stop + 1 : stop + 1;
+      const slice = sorted.slice(s, e);
+      if (withScores) {
+        return ok(slice.map(([member, score]) => ({ member, score })));
+      }
+      return ok(slice.map(([member]) => member));
+    },
+    async zrangeByScore(key, min, max, options) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok([]);
+      const minVal = min === "-inf" ? Number.NEGATIVE_INFINITY : Number(min);
+      const maxVal = max === "+inf" ? Number.POSITIVE_INFINITY : Number(max);
+      let sorted = Array.from(map.entries()).filter(([, score]) => score >= minVal && score <= maxVal).sort((a, b) => a[1] - b[1]);
+      if (options?.offset !== void 0 || options?.count !== void 0) {
+        const offset = options.offset ?? 0;
+        const count = options.count ?? sorted.length;
+        sorted = sorted.slice(offset, offset + count);
+      }
+      if (options?.withScores) {
+        return ok(sorted.map(([member, score]) => ({ member, score })));
+      }
+      return ok(sorted.map(([member]) => member));
+    },
+    async zcard(key) {
+      const map = zsetStore.get(key);
+      return ok(map?.size ?? 0);
+    },
+    async zcount(key, min, max) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok(0);
+      const minVal = min === "-inf" ? Number.NEGATIVE_INFINITY : Number(min);
+      const maxVal = max === "+inf" ? Number.POSITIVE_INFINITY : Number(max);
+      let count = 0;
+      for (const score of map.values()) {
+        if (score >= minVal && score <= maxVal)
+          count++;
+      }
+      return ok(count);
+    },
+    async zincrBy(key, increment, member) {
+      let map = zsetStore.get(key);
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        zsetStore.set(key, map);
+      }
+      const current = map.get(member) ?? 0;
+      const newScore = current + increment;
+      map.set(member, newScore);
+      return ok(newScore);
+    },
+    async zremRangeByRank(key, start, stop) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok(0);
+      const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
+      const len = sorted.length;
+      const s = start < 0 ? Math.max(len + start, 0) : start;
+      const e = stop < 0 ? len + stop + 1 : stop + 1;
+      const toRemove = sorted.slice(s, e);
+      for (const [member] of toRemove) {
+        map.delete(member);
+      }
+      return ok(toRemove.length);
+    },
+    async zremRangeByScore(key, min, max) {
+      const map = zsetStore.get(key);
+      if (!map)
+        return ok(0);
+      const minVal = min === "-inf" ? Number.NEGATIVE_INFINITY : Number(min);
+      const maxVal = max === "+inf" ? Number.POSITIVE_INFINITY : Number(max);
+      let count = 0;
+      for (const [member, score] of map.entries()) {
+        if (score >= minVal && score <= maxVal) {
+          map.delete(member);
+          count++;
+        }
+      }
+      return ok(count);
+    }
+  };
+  const LOCK_PREFIX = "__lock:";
+  const lock = {
+    async acquire(key, options) {
+      const lockKey = `${LOCK_PREFIX}${key}`;
+      const ttl = options?.ttl ?? 30;
+      const owner = options?.owner ?? "default";
+      const existing = getValidEntry(lockKey);
+      if (existing) {
+        return ok(false);
+      }
+      store.set(lockKey, {
+        value: owner,
+        expiresAt: Date.now() + ttl * 1e3
+      });
+      return ok(true);
+    },
+    async release(key, owner) {
+      const lockKey = `${LOCK_PREFIX}${key}`;
+      const entry = getValidEntry(lockKey);
+      if (!entry) {
+        return ok(false);
+      }
+      if (owner !== void 0 && entry.value !== owner) {
+        return ok(false);
+      }
+      store.delete(lockKey);
+      return ok(true);
+    },
+    async isLocked(key) {
+      const lockKey = `${LOCK_PREFIX}${key}`;
+      const entry = getValidEntry(lockKey);
+      return ok(entry !== null);
+    },
+    async extend(key, ttl, owner) {
+      const lockKey = `${LOCK_PREFIX}${key}`;
+      const entry = getValidEntry(lockKey);
+      if (!entry) {
+        return ok(false);
+      }
+      if (owner !== void 0 && entry.value !== owner) {
+        return ok(false);
+      }
+      entry.expiresAt = Date.now() + ttl * 1e3;
+      return ok(true);
+    }
+  };
+  return {
+    name: "memory",
+    async connect(_config) {
+      if (connected)
+        return ok(void 0);
+      cleanupTimer = setInterval(cleanup, 6e4);
+      connected = true;
+      return ok(void 0);
+    },
+    async close() {
+      if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+      }
+      store.clear();
+      hashStore.clear();
+      listStore.clear();
+      setStore.clear();
+      zsetStore.clear();
+      connected = false;
+    },
+    isConnected: () => connected,
+    kv,
+    hash,
+    list,
+    set_,
+    zset,
+    lock,
+    async ping() {
+      return ok("PONG");
+    }
+  };
+}
+var logger = core.logger.child({ module: "cache", scope: "redis" });
+function sanitizeRedisUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.password)
+      u.password = "***";
+    if (u.username)
+      u.username = "***";
+    return u.toString();
+  } catch {
+    return "(invalid url)";
+  }
+}
+var RELEASE_LOCK_SCRIPT = `
+  if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("del", KEYS[1])
+  else
+    return 0
+  end
+`;
+var EXTEND_LOCK_SCRIPT = `
+  if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("expire", KEYS[1], ARGV[2])
+  else
+    return 0
+  end
+`;
+function createRedisProvider() {
+  let client = null;
+  function serialize(value) {
+    return JSON.stringify(value);
+  }
+  function deserialize(value) {
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async function wrapOperation(operation) {
+    if (!client) {
+      return err(
+        HaiCacheError.NOT_INITIALIZED,
+        cacheM("cache_notInitialized")
+      );
+    }
+    try {
+      const result = await operation();
+      return ok(result);
+    } catch (error) {
+      return err(
+        HaiCacheError.OPERATION_FAILED,
+        cacheM("cache_operationFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+        error
+      );
+    }
+  }
+  const kv = {
+    async get(key) {
+      return wrapOperation(async () => {
+        const value = await client.get(key);
+        return deserialize(value);
+      });
+    },
+    async set(key, value, options) {
+      return wrapOperation(async () => {
+        const args = [key, serialize(value)];
+        if (options?.ex)
+          args.push("EX", options.ex);
+        else if (options?.px)
+          args.push("PX", options.px);
+        else if (options?.exat)
+          args.push("EXAT", options.exat);
+        else if (options?.pxat)
+          args.push("PXAT", options.pxat);
+        if (options?.nx)
+          args.push("NX");
+        else if (options?.xx)
+          args.push("XX");
+        if (options?.keepTtl)
+          args.push("KEEPTTL");
+        await client.set(...args);
+      });
+    },
+    async del(...keys) {
+      return wrapOperation(() => client.del(...keys));
+    },
+    async exists(...keys) {
+      return wrapOperation(() => client.exists(...keys));
+    },
+    async expire(key, seconds) {
+      return wrapOperation(async () => {
+        const result = await client.expire(key, seconds);
+        return result === 1;
+      });
+    },
+    async expireAt(key, timestamp) {
+      return wrapOperation(async () => {
+        const result = await client.expireat(key, timestamp);
+        return result === 1;
+      });
+    },
+    async ttl(key) {
+      return wrapOperation(() => client.ttl(key));
+    },
+    async persist(key) {
+      return wrapOperation(async () => {
+        const result = await client.persist(key);
+        return result === 1;
+      });
+    },
+    async incr(key) {
+      return wrapOperation(() => client.incr(key));
+    },
+    async incrBy(key, increment) {
+      return wrapOperation(() => client.incrby(key, increment));
+    },
+    async decr(key) {
+      return wrapOperation(() => client.decr(key));
+    },
+    async decrBy(key, decrement) {
+      return wrapOperation(() => client.decrby(key, decrement));
+    },
+    async mget(...keys) {
+      return wrapOperation(async () => {
+        const values = await client.mget(...keys);
+        return values.map((v) => deserialize(v));
+      });
+    },
+    async mset(entries) {
+      return wrapOperation(async () => {
+        const args = [];
+        for (const [key, value] of entries) {
+          args.push(key, serialize(value));
+        }
+        await client.mset(...args);
+      });
+    },
+    async scan(cursor, options) {
+      return wrapOperation(async () => {
+        let result;
+        if (options?.match && options?.count) {
+          result = await client.scan(cursor, "MATCH", options.match, "COUNT", options.count);
+        } else if (options?.match) {
+          result = await client.scan(cursor, "MATCH", options.match);
+        } else if (options?.count) {
+          result = await client.scan(cursor, "COUNT", options.count);
+        } else {
+          result = await client.scan(cursor);
+        }
+        const [nextCursor, keys] = result;
+        return [Number.parseInt(nextCursor, 10), keys];
+      });
+    },
+    async keys(pattern) {
+      return wrapOperation(() => client.keys(pattern));
+    },
+    async type(key) {
+      return wrapOperation(() => client.type(key));
+    }
+  };
+  const hash = {
+    async hget(key, field) {
+      return wrapOperation(async () => {
+        const value = await client.hget(key, field);
+        return deserialize(value);
+      });
+    },
+    async hset(key, fieldOrData, value) {
+      return wrapOperation(async () => {
+        if (typeof fieldOrData === "string" && value !== void 0) {
+          return client.hset(key, fieldOrData, serialize(value));
+        }
+        if (typeof fieldOrData === "object") {
+          const serialized = {};
+          for (const [k, v] of Object.entries(fieldOrData)) {
+            serialized[k] = serialize(v);
+          }
+          return client.hset(key, serialized);
+        }
+        return 0;
+      });
+    },
+    async hdel(key, ...fields) {
+      return wrapOperation(() => client.hdel(key, ...fields));
+    },
+    async hexists(key, field) {
+      return wrapOperation(async () => {
+        const result = await client.hexists(key, field);
+        return result === 1;
+      });
+    },
+    async hgetall(key) {
+      return wrapOperation(async () => {
+        const data = await client.hgetall(key);
+        const result = {};
+        for (const [k, v] of Object.entries(data)) {
+          result[k] = deserialize(v);
+        }
+        return result;
+      });
+    },
+    async hkeys(key) {
+      return wrapOperation(() => client.hkeys(key));
+    },
+    async hvals(key) {
+      return wrapOperation(async () => {
+        const values = await client.hvals(key);
+        return values.map((v) => deserialize(v));
+      });
+    },
+    async hlen(key) {
+      return wrapOperation(() => client.hlen(key));
+    },
+    async hmget(key, ...fields) {
+      return wrapOperation(async () => {
+        const values = await client.hmget(key, ...fields);
+        return values.map((v) => deserialize(v));
+      });
+    },
+    async hincrBy(key, field, increment) {
+      return wrapOperation(() => client.hincrby(key, field, increment));
+    }
+  };
+  const list = {
+    async lpush(key, ...values) {
+      return wrapOperation(() => client.lpush(key, ...values.map(serialize)));
+    },
+    async rpush(key, ...values) {
+      return wrapOperation(() => client.rpush(key, ...values.map(serialize)));
+    },
+    async lpop(key) {
+      return wrapOperation(async () => {
+        const value = await client.lpop(key);
+        return deserialize(value);
+      });
+    },
+    async rpop(key) {
+      return wrapOperation(async () => {
+        const value = await client.rpop(key);
+        return deserialize(value);
+      });
+    },
+    async llen(key) {
+      return wrapOperation(() => client.llen(key));
+    },
+    async lrange(key, start, stop) {
+      return wrapOperation(async () => {
+        const values = await client.lrange(key, start, stop);
+        return values.map((v) => deserialize(v));
+      });
+    },
+    async lindex(key, index) {
+      return wrapOperation(async () => {
+        const value = await client.lindex(key, index);
+        return deserialize(value);
+      });
+    },
+    async lset(key, index, value) {
+      return wrapOperation(async () => {
+        await client.lset(key, index, serialize(value));
+      });
+    },
+    async ltrim(key, start, stop) {
+      return wrapOperation(async () => {
+        await client.ltrim(key, start, stop);
+      });
+    },
+    async blpop(timeout, ...keys) {
+      return wrapOperation(async () => {
+        const result = await client.blpop(...keys, timeout);
+        if (!result)
+          return null;
+        return [result[0], deserialize(result[1])];
+      });
+    },
+    async brpop(timeout, ...keys) {
+      return wrapOperation(async () => {
+        const result = await client.brpop(...keys, timeout);
+        if (!result)
+          return null;
+        return [result[0], deserialize(result[1])];
+      });
+    }
+  };
+  const set_ = {
+    async sadd(key, ...members) {
+      return wrapOperation(() => client.sadd(key, ...members.map(serialize)));
+    },
+    async srem(key, ...members) {
+      return wrapOperation(() => client.srem(key, ...members.map(serialize)));
+    },
+    async smembers(key) {
+      return wrapOperation(async () => {
+        const members = await client.smembers(key);
+        return members.map((m) => deserialize(m));
+      });
+    },
+    async sismember(key, member) {
+      return wrapOperation(async () => {
+        const result = await client.sismember(key, serialize(member));
+        return result === 1;
+      });
+    },
+    async scard(key) {
+      return wrapOperation(() => client.scard(key));
+    },
+    async srandmember(key, count) {
+      return wrapOperation(async () => {
+        if (count !== void 0) {
+          const members = await client.srandmember(key, count);
+          return members.map((m) => deserialize(m));
+        }
+        const member = await client.srandmember(key);
+        return deserialize(member);
+      });
+    },
+    async spop(key, count) {
+      return wrapOperation(async () => {
+        if (count !== void 0) {
+          const members = await client.spop(key, count);
+          return members.map((m) => deserialize(m));
+        }
+        const member = await client.spop(key);
+        return deserialize(member);
+      });
+    },
+    async sinter(...keys) {
+      return wrapOperation(async () => {
+        const members = await client.sinter(...keys);
+        return members.map((m) => deserialize(m));
+      });
+    },
+    async sunion(...keys) {
+      return wrapOperation(async () => {
+        const members = await client.sunion(...keys);
+        return members.map((m) => deserialize(m));
+      });
+    },
+    async sdiff(...keys) {
+      return wrapOperation(async () => {
+        const members = await client.sdiff(...keys);
+        return members.map((m) => deserialize(m));
+      });
+    }
+  };
+  const zset = {
+    async zadd(key, ...members) {
+      return wrapOperation(async () => {
+        const args = [];
+        for (const { score, member } of members) {
+          args.push(score, member);
+        }
+        return client.zadd(key, ...args);
+      });
+    },
+    async zrem(key, ...members) {
+      return wrapOperation(() => client.zrem(key, ...members));
+    },
+    async zscore(key, member) {
+      return wrapOperation(async () => {
+        const score = await client.zscore(key, member);
+        return score !== null ? Number.parseFloat(score) : null;
+      });
+    },
+    async zrank(key, member) {
+      return wrapOperation(() => client.zrank(key, member));
+    },
+    async zrevrank(key, member) {
+      return wrapOperation(() => client.zrevrank(key, member));
+    },
+    async zrange(key, start, stop, withScores) {
+      return wrapOperation(async () => {
+        if (withScores) {
+          const result = await client.zrange(key, start, stop, "WITHSCORES");
+          const members = [];
+          for (let i = 0; i < result.length; i += 2) {
+            members.push({ member: result[i], score: Number.parseFloat(result[i + 1]) });
+          }
+          return members;
+        }
+        return client.zrange(key, start, stop);
+      });
+    },
+    async zrevrange(key, start, stop, withScores) {
+      return wrapOperation(async () => {
+        if (withScores) {
+          const result = await client.zrevrange(key, start, stop, "WITHSCORES");
+          const members = [];
+          for (let i = 0; i < result.length; i += 2) {
+            members.push({ member: result[i], score: Number.parseFloat(result[i + 1]) });
+          }
+          return members;
+        }
+        return client.zrevrange(key, start, stop);
+      });
+    },
+    async zrangeByScore(key, min, max, options) {
+      return wrapOperation(async () => {
+        const args = [key, String(min), String(max)];
+        if (options?.withScores)
+          args.push("WITHSCORES");
+        if (options?.offset !== void 0 && options?.count !== void 0) {
+          args.push("LIMIT", options.offset, options.count);
+        }
+        const result = await client.zrangebyscore.call(client, ...args);
+        if (options?.withScores) {
+          const members = [];
+          for (let i = 0; i < result.length; i += 2) {
+            members.push({ member: result[i], score: Number.parseFloat(result[i + 1]) });
+          }
+          return members;
+        }
+        return result;
+      });
+    },
+    async zcard(key) {
+      return wrapOperation(() => client.zcard(key));
+    },
+    async zcount(key, min, max) {
+      return wrapOperation(() => client.zcount(key, min, max));
+    },
+    async zincrBy(key, increment, member) {
+      return wrapOperation(async () => {
+        const result = await client.zincrby(key, increment, member);
+        return Number.parseFloat(result);
+      });
+    },
+    async zremRangeByRank(key, start, stop) {
+      return wrapOperation(() => client.zremrangebyrank(key, start, stop));
+    },
+    async zremRangeByScore(key, min, max) {
+      return wrapOperation(() => client.zremrangebyscore(key, min, max));
+    }
+  };
+  const LOCK_PREFIX = "__lock:";
+  const lock = {
+    async acquire(key, options) {
+      return wrapOperation(async () => {
+        const lockKey = `${LOCK_PREFIX}${key}`;
+        const ttl = options?.ttl ?? 30;
+        const owner = options?.owner ?? "default";
+        const result = await client.set(lockKey, owner, "EX", ttl, "NX");
+        return result === "OK";
+      });
+    },
+    async release(key, owner) {
+      return wrapOperation(async () => {
+        const lockKey = `${LOCK_PREFIX}${key}`;
+        if (owner !== void 0) {
+          const result = await client.eval(RELEASE_LOCK_SCRIPT, 1, lockKey, owner);
+          return result === 1;
+        }
+        const deleted = await client.del(lockKey);
+        return deleted === 1;
+      });
+    },
+    async isLocked(key) {
+      return wrapOperation(async () => {
+        const lockKey = `${LOCK_PREFIX}${key}`;
+        const exists = await client.exists(lockKey);
+        return exists === 1;
+      });
+    },
+    async extend(key, ttl, owner) {
+      return wrapOperation(async () => {
+        const lockKey = `${LOCK_PREFIX}${key}`;
+        if (owner !== void 0) {
+          const result2 = await client.eval(EXTEND_LOCK_SCRIPT, 1, lockKey, owner, ttl);
+          return result2 === 1;
+        }
+        const result = await client.expire(lockKey, ttl);
+        return result === 1;
+      });
+    }
+  };
+  return {
+    name: "redis",
+    /**
+     * 连接 Redis 服务
+     *
+     * 根据配置自动选择连接模式：
+     * 1. url → 单机 URL 连接
+     * 2. cluster → 集群模式
+     * 3. sentinel → 哨兵模式
+     * 4. host/port → 单机连接（默认）
+     *
+     * @param config - 已校验的 Redis 配置
+     * @returns 成功 ok(undefined)，失败 CONNECTION_FAILED
+     */
+    async connect(config) {
+      if (config.type !== "redis") {
+        return err(
+          HaiCacheError.UNSUPPORTED_TYPE,
+          cacheM("cache_unsupportedType", { params: { type: config.type } })
+        );
+      }
+      try {
+        const redisOptions = {
+          connectTimeout: config.connectTimeout,
+          commandTimeout: config.commandTimeout,
+          keyPrefix: config.keyPrefix,
+          maxRetriesPerRequest: config.maxRetries,
+          retryStrategy: (times) => {
+            if (times > config.maxRetries)
+              return null;
+            return config.retryDelay * times;
+          },
+          lazyConnect: true
+        };
+        if (config.tls)
+          redisOptions.tls = {};
+        if (config.readOnly)
+          redisOptions.readOnly = true;
+        if (config.url) {
+          client = new Redis(config.url, redisOptions);
+        } else if (config.cluster && config.cluster.length > 0) {
+          const clusterOptions = {
+            redisOptions,
+            clusterRetryStrategy: (times) => {
+              if (times > config.maxRetries)
+                return null;
+              return config.retryDelay * times;
+            }
+          };
+          client = new Redis.Cluster(config.cluster, clusterOptions);
+        } else if (config.sentinel) {
+          client = new Redis({
+            ...redisOptions,
+            sentinels: config.sentinel.sentinels,
+            name: config.sentinel.name,
+            password: config.password,
+            db: config.db
+          });
+        } else {
+          client = new Redis({
+            ...redisOptions,
+            host: config.host,
+            port: config.port,
+            password: config.password,
+            db: config.db
+          });
+        }
+        await client.connect();
+        await client.ping();
+        const address = config.url ? sanitizeRedisUrl(config.url) : `${config.host}:${config.port}`;
+        logger.info("Redis connected", { address });
+        return ok(void 0);
+      } catch (error) {
+        return err(
+          HaiCacheError.CONNECTION_FAILED,
+          cacheM("cache_redisConnectionFailed", { params: { error: error instanceof Error ? error.message : String(error) } }),
+          error
+        );
+      }
+    },
+    async close() {
+      if (client) {
+        logger.info("Disconnecting Redis");
+        await client.quit();
+        client = null;
+        logger.info("Redis disconnected");
+      }
+    },
+    isConnected: () => client !== null,
+    kv,
+    hash,
+    list,
+    set_,
+    zset,
+    lock,
+    async ping() {
+      return wrapOperation(() => client.ping());
+    }
+  };
+}
+
+// src/cache-main.ts
+var logger2 = core.logger.child({ module: "cache", scope: "main" });
+var currentProvider = null;
+var currentConfig = null;
+var initInProgress = false;
+function createProvider(config) {
+  switch (config.type) {
+    case "memory":
+      return createMemoryProvider();
+    case "redis":
+      return createRedisProvider();
+    default:
+      throw new Error(cacheM("cache_unsupportedType", { params: { type: config.type } }));
+  }
+}
+var notInitialized = core.module.createNotInitializedKit(
+  HaiCacheError.NOT_INITIALIZED,
+  () => cacheM("cache_notInitialized")
+);
+var notInitializedKv = notInitialized.proxy();
+var notInitializedHash = notInitialized.proxy();
+var notInitializedList = notInitialized.proxy();
+var notInitializedSet = notInitialized.proxy();
+var notInitializedZSet = notInitialized.proxy();
+var notInitializedLock = notInitialized.proxy();
+var cache = {
+  /**
+   * 初始化缓存连接。
+   *
+   * 会先关闭已有连接，再用新配置重新初始化。
+   * 配置经 Zod Schema parse 后传给 Provider。
+   *
+   * @param config 缓存配置（支持 memory / redis）。
+   * @returns 成功时返回 ok(undefined)；失败时返回 Provider 错误（如 CONNECTION_FAILED）。
+   *
+   * @example
+   * ```ts
+   * const result = await cache.init({ type: 'redis', host: 'localhost' })
+   * if (!result.success) {
+   *   // 生产代码中请使用项目 logger 输出错误
+   * }
+   * ```
+   */
+  async init(config) {
+    if (initInProgress) {
+      logger2.warn("Cache init already in progress, skipping concurrent call");
+      return err(
+        HaiCacheError.OPERATION_FAILED,
+        cacheM("cache_operationFailed", { params: { error: "Concurrent initialization detected" } })
+      );
+    }
+    initInProgress = true;
+    try {
+      if (currentProvider) {
+        logger2.warn("Cache module is already initialized, reinitializing");
+        await cache.close();
+      }
+      logger2.info("Initializing cache module");
+      const parseResult = CacheConfigSchema.safeParse(config);
+      if (!parseResult.success) {
+        logger2.error("Cache config validation failed", { error: parseResult.error.message });
+        return err(
+          HaiCacheError.CONFIG_ERROR,
+          cacheM("cache_configError", { params: { error: parseResult.error.message } }),
+          parseResult.error
+        );
+      }
+      const parsed = parseResult.data;
+      try {
+        const provider = createProvider(parsed);
+        const connectResult = await provider.connect(parsed);
+        if (!connectResult.success) {
+          logger2.error("Cache module initialization failed", {
+            code: connectResult.error.code,
+            message: connectResult.error.message
+          });
+          return connectResult;
+        }
+        currentProvider = provider;
+        currentConfig = parsed;
+        logger2.info("Cache module initialized", { type: parsed.type });
+        return ok(void 0);
+      } catch (error) {
+        logger2.error("Cache module initialization failed", { error });
+        return err(
+          HaiCacheError.CONNECTION_FAILED,
+          cacheM("cache_initFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    } finally {
+      initInProgress = false;
+    }
+  },
+  /** KV 操作子接口；未 init 时所有方法返回 NOT_INITIALIZED */
+  get kv() {
+    return currentProvider?.kv ?? notInitializedKv;
+  },
+  /** Hash 操作子接口 */
+  get hash() {
+    return currentProvider?.hash ?? notInitializedHash;
+  },
+  /** List 操作子接口 */
+  get list() {
+    return currentProvider?.list ?? notInitializedList;
+  },
+  /** Set 操作子接口（名称加 _ 以避免与 JS 关键字冲突） */
+  get set_() {
+    return currentProvider?.set_ ?? notInitializedSet;
+  },
+  /** ZSet（有序集合）操作子接口 */
+  get zset() {
+    return currentProvider?.zset ?? notInitializedZSet;
+  },
+  /** 分布式锁操作子接口 */
+  get lock() {
+    return currentProvider?.lock ?? notInitializedLock;
+  },
+  /** 当前配置（parse 后）；未初始化时返回 null */
+  get config() {
+    return currentConfig;
+  },
+  /** 是否已初始化并连接；Provider 不存在或未连接时返回 false */
+  get isInitialized() {
+    return currentProvider !== null && currentProvider.isConnected();
+  },
+  /**
+   * 测试缓存连接状态
+   *
+   * @returns 成功时返回 'PONG'；未初始化时返回 NOT_INITIALIZED 错误
+   */
+  ping() {
+    return currentProvider?.ping() ?? Promise.resolve(notInitialized.result());
+  },
+  /** 关闭缓存连接并释放资源；未初始化时调用安全无副作用 */
+  async close() {
+    if (!currentProvider) {
+      currentConfig = null;
+      logger2.info("Cache module already closed, skipping");
+      return;
+    }
+    logger2.info("Closing cache module");
+    try {
+      await currentProvider.close();
+      logger2.info("Cache module closed");
+    } catch (error) {
+      logger2.error("Cache module close failed", { error });
+    } finally {
+      currentProvider = null;
+      currentConfig = null;
+    }
+  }
+};
+
+export { CacheConfigSchema, HaiCacheError, MemoryConfigSchema, RedisClusterNodeSchema, RedisConfigSchema, RedisSentinelConfigSchema, cache };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map