weifuwu 0.61.2 → 0.63.0

package/dist/index.js

@@ -1087,6 +1087,9 @@ var MIME_TYPES = {
 
 // src/middleware/rate-limit.ts
 var PREFIX = "rl:";
+function requestIp(req) {
+  return req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? req.headers.get("x-real-ip") ?? "unknown";
+}
 function rateLimit(options) {
   const opts = {
     windowMs: options?.windowMs ?? 6e4,
@@ -1171,7 +1174,8 @@ function rateLimit(options) {
   const mw = (async (req, ctx, next) => {
     if (opts.store === "redis") requireRedis(ctx);
     ctx.limit = async (name, manual) => {
-      const key = `${PREFIX}${name}`;
+      const dim = (manual?.scope ?? "ip") === "global" ? "" : `:${requestIp(req)}`;
+      const key = `${PREFIX}${name}${dim}`;
       const max = manual?.max ?? opts.max;
       const windowMs = manual?.windowMs ?? opts.windowMs;
       const r2 = await check(key, max, windowMs);
@@ -1681,6 +1685,7 @@ function userSystem(options) {
 }
 
 // src/messager/index.ts
+var messagerSeq = 0;
 var CONVERSATIONS = "_weifuwu_conversations";
 var MEMBERS = "_weifuwu_conversation_members";
 var MESSAGES = "_weifuwu_messages";
@@ -1835,16 +1840,19 @@ function messager(options) {
       redisSub.psubscribe(`${REDIS_PREFIX}*`, (channel, message) => {
         const room = channel.slice(REDIS_PREFIX.length);
         const event = JSON.parse(message);
+        if (event._pid === SELF_PID) return;
         broadcastLocal(room, event);
       });
     }).catch((err) => {
       console.error("[messager] redis subscriber init error:", err);
     });
   }
+  const SELF_PID = `wf:${process.pid}:${++messagerSeq}`;
   function broadcastLocal(room, event) {
     const members = rooms.get(room);
     if (!members) return;
-    const payload = JSON.stringify(event);
+    const { _pid, ...clean } = event;
+    const payload = JSON.stringify(clean);
     for (const ws of [...members]) {
       if (ws.readyState === ws.OPEN) {
         try {
@@ -1858,7 +1866,7 @@ function messager(options) {
     broadcastLocal(room, event);
     const pool = options.redis?.redis;
     if (pool) {
-      pool.publish(`${REDIS_PREFIX}${room}`, JSON.stringify(event)).catch((err) => {
+      pool.publish(`${REDIS_PREFIX}${room}`, JSON.stringify({ ...event, _pid: SELF_PID })).catch((err) => {
         console.error("[messager] redis publish error:", err);
       });
     }
@@ -2326,6 +2334,7 @@ function indexOfCRLF(buf, from = 0) {
 
 // src/db/redis/connection.ts
 var PUSH_TYPES = /* @__PURE__ */ new Set(["message", "pmessage"]);
+var BLOCKING_COMMANDS = /* @__PURE__ */ new Set(["BLPOP", "BRPOP", "BLMPOP", "BRPOPLPUSH", "BZPOPMIN", "BZPOPMAX", "WAIT", "XREAD", "XREADGROUP"]);
 var RedisConnection = class {
   ready = false;
   opts;
@@ -2340,6 +2349,7 @@ var RedisConnection = class {
   status = "idle";
   retries = 0;
   reconnectTimer = null;
+  socketTimeoutTimer = null;
   connectPromise = null;
   closed = false;
   connectedOnce = false;
@@ -2350,7 +2360,10 @@ var RedisConnection = class {
       retryDelayMs: options.retryDelayMs ?? 100,
       maxRetries: options.maxRetries ?? 10,
       enableOfflineQueue: options.enableOfflineQueue ?? true,
-      maxOfflineQueue: options.maxOfflineQueue ?? 5e3
+      maxOfflineQueue: options.maxOfflineQueue ?? 5e3,
+      commandTimeoutMs: options.commandTimeoutMs ?? 0,
+      socketTimeoutMs: options.socketTimeoutMs ?? 0,
+      onCommand: options.onCommand
     };
   }
   /** 建立连接并等待 ready。重连失败（超过 maxRetries）抛 ConnectionError。 */
@@ -2404,8 +2417,10 @@ var RedisConnection = class {
     this.pending = [];
     this.pendingHead = 0;
     for (const p of queue2) p.reject(err);
+    this.clearSocketTimeout();
     if (this.closed || this.status === "closed") return;
     this.retries++;
+    this.status = "connecting";
     if (this.opts.maxRetries > 0 && this.retries > this.opts.maxRetries) {
       this.status = "closed";
       const failErr = err instanceof ConnectionError ? err : new ConnectionError(`redis: connect to ${this.opts.host}:${this.opts.port} failed`, this.retries, err);
@@ -2429,6 +2444,7 @@ var RedisConnection = class {
         }
         const p = this.pending[this.pendingHead++];
         if (!p) break;
+        if (p.timedOut) continue;
         if (raw instanceof RespError) p.reject(raw);
         else p.resolve(decodeValue(raw, !p.asBuffer));
       }
@@ -2436,6 +2452,10 @@ var RedisConnection = class {
         this.pending = this.pending.slice(this.pendingHead);
         this.pendingHead = 0;
       }
+      if (this.opts.socketTimeoutMs > 0) {
+        if (this.pendingHead < this.pending.length) this.armSocketTimeout();
+        else this.clearSocketTimeout();
+      }
     } catch (e) {
       const queue2 = this.pending.slice(this.pendingHead);
       this.pending = [];
@@ -2465,10 +2485,60 @@ var RedisConnection = class {
     });
   }
   sendNow(name, args, asBuffer) {
+    const start = performance.now();
     return new Promise((resolve3, reject) => {
-      this.pending.push({ resolve: resolve3, reject, asBuffer });
+      const p = {
+        resolve: resolve3,
+        reject,
+        asBuffer,
+        blocking: BLOCKING_COMMANDS.has(name.toUpperCase())
+      };
+      this.armTimeout(p);
+      this.pending.push(p);
+      this.armSocketTimeout();
       this.socket.write(encodeCommand([name, ...args]));
-    });
+    }).then(
+      (v) => {
+        if (this.opts.onCommand) this.opts.onCommand(name, args, performance.now() - start);
+        return v;
+      },
+      (e) => {
+        if (this.opts.onCommand) this.opts.onCommand(name, args, performance.now() - start);
+        throw e;
+      }
+    );
+  }
+  /** 命令超时（commandTimeoutMs > 0）：超时标记 timedOut + 处理（阻塞命令 resolve(null)，其余 reject） */
+  armTimeout(p) {
+    const ms = this.opts.commandTimeoutMs;
+    if (ms <= 0) return;
+    p.timer = setTimeout(() => {
+      p.timedOut = true;
+      if (p.blocking) p.resolve(null);
+      else p.reject(new TimeoutError("redis: command timeout", ms));
+    }, ms);
+  }
+  /** socket 响应超时（socketTimeoutMs > 0）：期望数据但超时未达 → 僵尸连接 → 主动断开走标准重连 */
+  armSocketTimeout() {
+    const ms = this.opts.socketTimeoutMs;
+    if (ms <= 0) return;
+    this.clearSocketTimeout();
+    this.socketTimeoutTimer = setTimeout(() => {
+      this.socketTimeoutTimer = null;
+      const err = new ConnectionError(`redis: socket timeout (no data in ${ms}ms)`);
+      const queue2 = this.pending.slice(this.pendingHead);
+      this.pending = [];
+      this.pendingHead = 0;
+      for (const q of queue2) q.reject(err);
+      this.clearSocketTimeout();
+      this.socket?.destroy();
+    }, ms);
+  }
+  clearSocketTimeout() {
+    if (this.socketTimeoutTimer) {
+      clearTimeout(this.socketTimeoutTimer);
+      this.socketTimeoutTimer = null;
+    }
   }
   flushOffline() {
     const queue2 = this.offlineQueue;
@@ -2484,11 +2554,18 @@ var RedisConnection = class {
     }
     return new Promise((resolve3, reject) => {
       const results = [];
+      const batchPending = [];
+      let settled = false;
       const maybeResolve = () => {
-        if (results.length === count) resolve3(results);
+        if (settled) return;
+        if (results.length === count) {
+          settled = true;
+          if (batchTimer) clearTimeout(batchTimer);
+          resolve3(results);
+        }
       };
       for (let i = 0; i < count; i++) {
-        this.pending.push({
+        const p = {
           // 正常响应与错误响应（RespError）都作为结果值收集——管道语义
           resolve: (v) => {
             results.push(v);
@@ -2498,9 +2575,21 @@ var RedisConnection = class {
             results.push(e);
             maybeResolve();
           }
-        });
+        };
+        batchPending.push(p);
+        this.pending.push(p);
+      }
+      let batchTimer;
+      const ms = this.opts.commandTimeoutMs;
+      if (ms > 0) {
+        batchTimer = setTimeout(() => {
+          settled = true;
+          for (const p of batchPending) p.timedOut = true;
+          reject(new TimeoutError("redis: batch timeout", ms));
+        }, ms);
       }
       this.socket.write(payload);
+      this.armSocketTimeout();
     });
   }
   /** 订阅频道：回调式（channel, message） */
@@ -2532,6 +2621,7 @@ var RedisConnection = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+    this.clearSocketTimeout();
     const queue2 = this.pending.slice(this.pendingHead);
     this.pending = [];
     this.pendingHead = 0;
@@ -2548,6 +2638,55 @@ var RedisConnection = class {
   }
 };
 
+// src/db/redis/pipeline.ts
+var RedisPipeline = class {
+  cmds = [];
+  conn;
+  constructor(conn) {
+    this.conn = conn;
+  }
+  set(key, value, ttl) {
+    this.cmds.push(ttl !== void 0 ? { name: "SET", args: [key, value, "EX", ttl] } : { name: "SET", args: [key, value] });
+    return this;
+  }
+  get(key) {
+    this.cmds.push({ name: "GET", args: [key] });
+    return this;
+  }
+  del(...keys) {
+    this.cmds.push({ name: "DEL", args: keys });
+    return this;
+  }
+  incr(key) {
+    this.cmds.push({ name: "INCR", args: [key] });
+    return this;
+  }
+  expire(key, seconds) {
+    this.cmds.push({ name: "EXPIRE", args: [key, seconds] });
+    return this;
+  }
+  ttl(key) {
+    this.cmds.push({ name: "TTL", args: [key] });
+    return this;
+  }
+  /** 任意命令透传 */
+  raw(name, ...args) {
+    this.cmds.push({ name, args });
+    return this;
+  }
+  /**
+   * 一次往返执行所有命令。结果按命令顺序；错误命令对应位置为 Error 实例，
+   * 其余命令不受影响（Redis 管道语义）。
+   */
+  async exec() {
+    const cmds = this.cmds;
+    this.cmds = [];
+    if (cmds.length === 0) return [];
+    const payload = Buffer.concat(cmds.map((c) => Buffer.from(encodeCommand([c.name, ...c.args]))));
+    return this.conn.batch(payload, cmds.length);
+  }
+};
+
 // src/db/redis/client.ts
 var RedisClient = class _RedisClient {
   conn;
@@ -2564,6 +2703,10 @@ var RedisClient = class _RedisClient {
   command(name, ...args) {
     return this.conn.command(name, ...args);
   }
+  /** 连接是否就绪（池坏连接剔除用） */
+  get connected() {
+    return this.conn.connected;
+  }
   // ── 基础命令 ──────────────────────────────
   async get(key) {
     const v = await this.conn.command("GET", key);
@@ -2602,6 +2745,104 @@ var RedisClient = class _RedisClient {
   async ttl(key) {
     return Number(await this.conn.command("TTL", key));
   }
+  // ── 批量 / 存在 / 计数 ────────────────────────
+  /** 批量读：返回与 key 一一对应的值（缺失为 null） */
+  async mget(...keys) {
+    const v = await this.conn.command("MGET", ...keys);
+    return v.map((x) => x === null ? null : String(x));
+  }
+  /** 批量写：mset(k1, v1, k2, v2, ...)（偶数参数） */
+  async mset(...kv) {
+    const reply = await this.conn.command("MSET", ...kv);
+    return String(reply);
+  }
+  /** 存在性：返回存在的 key 数 */
+  async exists(...keys) {
+    return Number(await this.conn.command("EXISTS", ...keys));
+  }
+  /** 原子设置（仅 key 不存在时）：1=设置成功 0=已存在（分布式锁基础） */
+  async setnx(key, value) {
+    return Number(await this.conn.command("SETNX", key, value));
+  }
+  /** 原子加增量，返回新值 */
+  async incrby(key, delta) {
+    return Number(await this.conn.command("INCRBY", key, delta));
+  }
+  // ── hash ─────────────────────────────────────
+  /** 设置字段，返回新增字段数 */
+  async hset(key, field, value) {
+    return Number(await this.conn.command("HSET", key, field, value));
+  }
+  /** 读字段（缺失 null） */
+  async hget(key, field) {
+    const v = await this.conn.command("HGET", key, field);
+    return v === null ? null : String(v);
+  }
+  /** 读整个 hash → Record（key 不存在 → {}） */
+  async hgetall(key) {
+    const v = await this.conn.command("HGETALL", key);
+    const arr = v;
+    const out = {};
+    for (let i = 0; i + 1 < arr.length; i += 2) out[String(arr[i])] = String(arr[i + 1]);
+    return out;
+  }
+  /** 删除字段，返回删除数 */
+  async hdel(key, ...fields) {
+    return Number(await this.conn.command("HDEL", key, ...fields));
+  }
+  // ── list ─────────────────────────────────────
+  /** 头插，返回长度 */
+  async lpush(key, ...values) {
+    return Number(await this.conn.command("LPUSH", key, ...values));
+  }
+  /** 尾插，返回长度 */
+  async rpush(key, ...values) {
+    return Number(await this.conn.command("RPUSH", key, ...values));
+  }
+  /** 头弹（缺失 null） */
+  async lpop(key) {
+    const v = await this.conn.command("LPOP", key);
+    return v === null ? null : String(v);
+  }
+  /** 尾弹（缺失 null） */
+  async rpop(key) {
+    const v = await this.conn.command("RPOP", key);
+    return v === null ? null : String(v);
+  }
+  /** 范围读（start/stop 支持负数，如 0 -1 全量） */
+  async lrange(key, start, stop) {
+    const v = await this.conn.command("LRANGE", key, start, stop);
+    return v.map(String);
+  }
+  // ── set ──────────────────────────────────────
+  /** 加成员，返回新增数（重复不加） */
+  async sadd(key, ...members) {
+    return Number(await this.conn.command("SADD", key, ...members));
+  }
+  /** 删成员，返回删除数 */
+  async srem(key, ...members) {
+    return Number(await this.conn.command("SREM", key, ...members));
+  }
+  /** 全部成员（无序） */
+  async smembers(key) {
+    const v = await this.conn.command("SMEMBERS", key);
+    return v.map(String);
+  }
+  // ── zset ─────────────────────────────────────
+  /** 加成员（score 排序），返回新增数 */
+  async zadd(key, score, member) {
+    return Number(await this.conn.command("ZADD", key, score, member));
+  }
+  /** 范围读（按 score 升序；start/stop 为排名，支持负数） */
+  async zrange(key, start, stop) {
+    const v = await this.conn.command("ZRANGE", key, start, stop);
+    return v.map(String);
+  }
+  // ── pipeline ─────────────────────────────────
+  /** 创建管道（批量命令一次往返；结果按序） */
+  pipeline() {
+    return new RedisPipeline(this.conn);
+  }
   // ── JSON 存取（自动序列化） ────────────────
   /** 读取并 JSON.parse；key 不存在返回 null */
   async jsonGet(key) {
@@ -2661,6 +2902,7 @@ var RedisSubscriber = class {
 var RedisPool = class _RedisPool {
   clients = [];
   rr = 0;
+  replenishWaiters = [];
   closed = false;
   keyPrefix;
   opts;
@@ -2696,65 +2938,218 @@ var RedisPool = class _RedisPool {
   k(key) {
     return this.keyPrefix + key;
   }
-  /** round-robin 选择连接 */
-  next() {
-    if (this.closed || this.clients.length === 0) {
-      throw new ConnectionError("redis: pool is closed");
+  /** round-robin 选择健康连接；跳过不可用连接（断线/重连中/closed）——剔除并异步重建，防分发到死连接。
+   * 全部不可用时等待 replenish 补位（Redis 真宕机 1s 后明确报错，不无限挂起）。 */
+  async acquireHealthy() {
+    if (this.closed) throw new ConnectionError("redis: pool is closed");
+    while (this.clients.length > 0) {
+      const idx = this.rr % this.clients.length;
+      this.rr++;
+      const c = this.clients[idx];
+      if (c.connected) return c;
+      this.clients.splice(idx, 1);
+      c.close().catch(() => {
+      });
+      this.replenish();
     }
-    const client = this.clients[this.rr % this.clients.length];
-    this.rr++;
-    return client;
+    return new Promise((resolve3, reject) => {
+      const waiter = () => {
+        if (this.clients.length > 0 && this.clients[0].connected) resolve3(this.clients[0]);
+        else reject(new ConnectionError("redis: pool exhausted after reconnect wait"));
+      };
+      this.replenishWaiters.push(waiter);
+      setTimeout(() => {
+        const i = this.replenishWaiters.indexOf(waiter);
+        if (i >= 0) this.replenishWaiters.splice(i, 1);
+        reject(new ConnectionError("redis: no healthy connection available"));
+      }, 1e3);
+    });
+  }
+  /** 剔除后补位：异步重建连接，就绪后回池并唤醒等待者 */
+  replenish() {
+    if (this.closed) return;
+    RedisClient.connect(this.opts).then((c) => {
+      if (this.closed) {
+        c.close();
+        return;
+      }
+      this.clients.push(c);
+      const ws = this.replenishWaiters;
+      this.replenishWaiters = [];
+      for (const w of ws) w();
+    }).catch(() => {
+      setTimeout(() => this.replenish(), 500);
+    });
   }
   // ── 与 RedisClient 相同的方法面（代理到轮询连接） ──
   async command(name, ...args) {
     await this.ensure();
-    return this.next().command(name, ...args);
+    const c = await this.acquireHealthy();
+    return c.command(name, ...args);
   }
   async get(key) {
     await this.ensure();
-    return this.next().get(this.k(key));
+    const c = await this.acquireHealthy();
+    return c.get(this.k(key));
   }
   /** 二进制安全读取（原始字节，不解码） */
   async getBuffer(key) {
     await this.ensure();
-    return this.next().getBuffer(this.k(key));
+    const c = await this.acquireHealthy();
+    return c.getBuffer(this.k(key));
   }
   async set(key, value, ttl) {
     await this.ensure();
-    return this.next().set(this.k(key), value, ttl);
+    const c = await this.acquireHealthy();
+    return c.set(this.k(key), value, ttl);
   }
   async del(...keys) {
     await this.ensure();
-    return this.next().del(...keys.map((k) => this.k(k)));
+    const c = await this.acquireHealthy();
+    return c.del(...keys.map((k) => this.k(k)));
   }
   async incr(key) {
     await this.ensure();
-    return this.next().incr(this.k(key));
+    const c = await this.acquireHealthy();
+    return c.incr(this.k(key));
   }
   async expire(key, seconds) {
     await this.ensure();
-    return this.next().expire(this.k(key), seconds);
+    const c = await this.acquireHealthy();
+    return c.expire(this.k(key), seconds);
   }
   async ttl(key) {
     await this.ensure();
-    return this.next().ttl(this.k(key));
+    const c = await this.acquireHealthy();
+    return c.ttl(this.k(key));
   }
   async jsonGet(key) {
     await this.ensure();
-    return this.next().jsonGet(this.k(key));
+    const c = await this.acquireHealthy();
+    return c.jsonGet(this.k(key));
   }
   async jsonSet(key, value, ttl) {
     await this.ensure();
-    return this.next().jsonSet(this.k(key), value, ttl);
+    const c = await this.acquireHealthy();
+    return c.jsonSet(this.k(key), value, ttl);
   }
   async cache(key, fn, ttl) {
     await this.ensure();
-    return this.next().cache(this.k(key), fn, ttl);
+    const c = await this.acquireHealthy();
+    return c.cache(this.k(key), fn, ttl);
+  }
+  // ── 批量 / 存在 / 计数 ────────────────────────
+  async mget(...keys) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.mget(...keys.map((k) => this.k(k)));
+  }
+  async mset(...kv) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    const prefixed = kv.map((x, i) => i % 2 === 0 ? this.k(String(x)) : x);
+    return c.mset(...prefixed);
+  }
+  async exists(...keys) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.exists(...keys.map((k) => this.k(k)));
+  }
+  async setnx(key, value) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.setnx(this.k(key), value);
+  }
+  async incrby(key, delta) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.incrby(this.k(key), delta);
+  }
+  // ── hash ─────────────────────────────────────
+  async hset(key, field, value) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.hset(this.k(key), field, value);
+  }
+  async hget(key, field) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.hget(this.k(key), field);
+  }
+  async hgetall(key) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.hgetall(this.k(key));
+  }
+  async hdel(key, ...fields) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.hdel(this.k(key), ...fields);
+  }
+  // ── list ─────────────────────────────────────
+  async lpush(key, ...values) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.lpush(this.k(key), ...values);
+  }
+  async rpush(key, ...values) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.rpush(this.k(key), ...values);
+  }
+  async lpop(key) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.lpop(this.k(key));
+  }
+  async rpop(key) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.rpop(this.k(key));
+  }
+  async lrange(key, start, stop) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.lrange(this.k(key), start, stop);
+  }
+  // ── set ──────────────────────────────────────
+  async sadd(key, ...members) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.sadd(this.k(key), ...members);
+  }
+  async srem(key, ...members) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.srem(this.k(key), ...members);
+  }
+  async smembers(key) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.smembers(this.k(key));
+  }
+  // ── zset ─────────────────────────────────────
+  async zadd(key, score, member) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.zadd(this.k(key), score, member);
+  }
+  async zrange(key, start, stop) {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.zrange(this.k(key), start, stop);
+  }
+  // ── pipeline（池级：选一健康连接；key 自动加前缀） ──
+  async pipeline() {
+    await this.ensure();
+    const c = await this.acquireHealthy();
+    return c.pipeline();
   }
   /** PUBLISH 消息到频道，返回收到消息的订阅者数 */
   async publish(channel, message) {
     await this.ensure();
-    return Number(await this.next().command("PUBLISH", channel, message));
+    const c = await this.acquireHealthy();
+    return Number(await c.command("PUBLISH", channel, message));
   }
   /** 创建独立订阅者连接（Pub/Sub 场景） */
   createSubscriber() {
@@ -2763,7 +3158,8 @@ var RedisPool = class _RedisPool {
   /** 清空当前库（测试/重置场景） */
   async flushdb() {
     await this.ensure();
-    const v = await this.next().command("FLUSHDB");
+    const c = await this.acquireHealthy();
+    const v = await c.command("FLUSHDB");
     return String(v);
   }
   /** 关闭所有池内连接 */
@@ -2780,18 +3176,18 @@ var RedisPool = class _RedisPool {
 
 // src/queue/index.ts
 var GROUP = "workers";
-function makePool(options) {
+function parseUrl(options) {
   const url = options?.url ?? process.env.REDIS_URL ?? "redis://localhost:6379";
   const u = new URL(url);
-  return new RedisPool({
+  const opts = {
     host: u.hostname,
-    port: Number(u.port || 6379),
-    poolSize: options?.poolSize
-  });
+    port: Number(u.port || 6379)
+  };
+  return { conn: opts, pool: new RedisPool({ ...opts, poolSize: options?.poolSize }) };
 }
 function queue(options) {
   const prefix = options?.prefix ?? "q:";
-  const pool = makePool(options);
+  const { conn: connOpts, pool } = parseUrl(options);
   const stream = (name) => `${prefix}${name}`;
   const deadStream = (name) => `${prefix}${name}:dead`;
   async function pushJob(name, payload) {
@@ -2820,21 +3216,48 @@ function queue(options) {
       const dead = deadStream(name);
       const delayed = `${prefix}${name}:delayed`;
       let running = false;
+      let lastErrAt = 0;
+      let epoch = 0;
+      let conn = null;
+      let connEpoch = -1;
+      const loops = /* @__PURE__ */ new Map();
       const inflight = /* @__PURE__ */ new Set();
+      async function getConn(myEpoch) {
+        if (conn && connEpoch === myEpoch) return conn;
+        if (conn) {
+          const c2 = conn;
+          conn = null;
+          connEpoch = -1;
+          await c2.close().catch(() => {
+          });
+        }
+        const c = new RedisConnection(connOpts);
+        await c.connect();
+        conn = c;
+        connEpoch = myEpoch;
+        return c;
+      }
       async function ensureGroup() {
-        try {
-          await pool.command("XGROUP", "CREATE", s, GROUP, "0", "MKSTREAM");
-        } catch (e) {
-          if (!String(e.message).includes("BUSYGROUP")) throw e;
+        let lastErr;
+        for (let attempt = 0; attempt < 3; attempt++) {
+          try {
+            await conn.command("XGROUP", "CREATE", s, GROUP, "0", "MKSTREAM");
+            return;
+          } catch (e) {
+            if (String(e.message).includes("BUSYGROUP")) return;
+            lastErr = e;
+            if (attempt < 2) await new Promise((r) => setTimeout(r, 50));
+          }
         }
+        throw lastErr;
       }
       async function processEntry(entryId, fields) {
         let payload;
         try {
           payload = JSON.parse(fields.payload ?? "{}");
         } catch {
-          await pool.command("XACK", s, GROUP, entryId);
-          await pool.command("XADD", dead, "*", "payload", JSON.stringify({
+          await conn.command("XACK", s, GROUP, entryId);
+          await conn.command("XADD", dead, "*", "payload", JSON.stringify({
             originalId: entryId,
             name,
             error: "unparseable payload",
@@ -2851,12 +3274,12 @@ function queue(options) {
             data: payload.data,
             attempts
           });
-          await pool.command("XACK", s, GROUP, entryId);
+          await conn.command("XACK", s, GROUP, entryId);
         } catch (err) {
           const nextAttempt = attempts + 1;
-          await pool.command("XACK", s, GROUP, entryId);
+          await conn.command("XACK", s, GROUP, entryId);
           if (nextAttempt >= maxAttempts) {
-            await pool.command("XADD", dead, "*", "payload", JSON.stringify({
+            await conn.command("XADD", dead, "*", "payload", JSON.stringify({
               originalId: entryId,
               name,
               data: payload.data,
@@ -2865,7 +3288,7 @@ function queue(options) {
             }));
             console.error(`[queue] ${name} job failed permanently (attempt ${nextAttempt}/${maxAttempts}):`, err);
           } else {
-            await pool.command("ZADD", delayed, String(Date.now() + visibilityTimeout), JSON.stringify({
+            await conn.command("ZADD", delayed, String(Date.now() + visibilityTimeout), JSON.stringify({
               ...payload,
               attempts: nextAttempt
             }));
@@ -2880,25 +3303,27 @@ function queue(options) {
         const now = Date.now();
         let due;
         try {
-          due = await pool.command("ZRANGEBYSCORE", delayed, 0, now);
+          due = await conn.command("ZRANGEBYSCORE", delayed, 0, now);
         } catch (e) {
-          if (isPoolClosed(e)) {
+          if (isConnClosed(e)) {
             running = false;
             return;
           }
-          if (running) console.error("[queue] ZRANGEBYSCORE:", e instanceof Error ? e.message : e);
+          if (running && shouldLogError()) {
+            console.error("[queue] ZRANGEBYSCORE:", e instanceof Error ? e.message : e);
+          }
           return;
         }
         for (const member of due) {
-          const removed = await pool.command("ZREM", delayed, member);
+          const removed = await conn.command("ZREM", delayed, member);
           if (removed) {
-            await pool.command("XADD", s, "*", "payload", member);
+            await conn.command("XADD", s, "*", "payload", member);
           }
         }
       }
       async function claimStale() {
         try {
-          const result = await pool.command(
+          const result = await conn.command(
             "XAUTOCLAIM",
             s,
             GROUP,
@@ -2913,21 +3338,41 @@ function queue(options) {
             await processEntry(entryId, flatFieldsToRecord(fields));
           }
         } catch (e) {
-          if (isPoolClosed(e)) {
+          if (isConnClosed(e)) {
             running = false;
             return;
           }
-          if (running) console.error("[queue] XAUTOCLAIM:", e instanceof Error ? e.message : e);
+          if (await recoverGroupIfMissing(e)) return;
+          if (running && shouldLogError()) {
+            console.error("[queue] XAUTOCLAIM:", e instanceof Error ? e.message : e);
+          }
+        }
+      }
+      async function recoverGroupIfMissing(e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (!/NOGROUP/.test(msg)) return false;
+        try {
+          await ensureGroup();
+          return true;
+        } catch {
+          return false;
         }
       }
-      async function loop() {
-        await ensureGroup();
-        while (running) {
+      function shouldLogError() {
+        const now = Date.now();
+        if (now - lastErrAt > 5e3) {
+          lastErrAt = now;
+          return true;
+        }
+        return false;
+      }
+      async function loop(myEpoch) {
+        while (running && myEpoch === epoch) {
           await claimStale();
           await requeueDelayed();
           let result;
           try {
-            result = await pool.command(
+            result = await conn.command(
               "XREADGROUP",
               "GROUP",
               GROUP,
@@ -2941,11 +3386,14 @@ function queue(options) {
               ">"
             );
           } catch (e) {
-            if (isPoolClosed(e)) {
+            if (isConnClosed(e)) {
               running = false;
               return;
             }
-            if (running) console.error("[queue] XREADGROUP:", e instanceof Error ? e.message : e);
+            if (await recoverGroupIfMissing(e)) continue;
+            if (running && shouldLogError()) {
+              console.error("[queue] XREADGROUP:", e instanceof Error ? e.message : e);
+            }
             continue;
           }
           if (!result) continue;
@@ -2963,11 +3411,42 @@ function queue(options) {
         start: async () => {
           if (running) return;
           running = true;
-          loop().catch((e) => console.error("[queue] worker loop crashed:", e));
+          const myEpoch = epoch;
+          try {
+            await getConn(myEpoch);
+            await ensureGroup();
+          } catch (e) {
+            running = false;
+            if (conn) {
+              const c = conn;
+              conn = null;
+              connEpoch = -1;
+              await c.close().catch(() => {
+              });
+            }
+            throw e;
+          }
+          const lp = loop(myEpoch);
+          loops.set(myEpoch, lp);
+          lp.finally(() => loops.delete(myEpoch)).catch(
+            (e) => console.error("[queue] worker loop crashed:", e)
+          );
         },
         stop: async () => {
+          if (!running) {
+            await Promise.allSettled([...loops.values()]);
+            return;
+          }
+          epoch++;
           running = false;
+          const oldConn = conn;
+          conn = null;
+          connEpoch = -1;
+          const oldLoops = [...loops.entries()].filter(([e]) => e < epoch).map(([, p]) => p);
           await Promise.allSettled([...inflight]);
+          await Promise.allSettled(oldLoops);
+          await oldConn?.close().catch(() => {
+          });
         }
       };
     }
@@ -2988,14 +3467,292 @@ function flatFieldsToRecord(fields) {
   }
   return rec;
 }
-function isPoolClosed(e) {
+function isConnClosed(e) {
   const msg = e instanceof Error ? e.message : String(e);
   return /pool is closed|connection closed/.test(msg);
 }
 
-// src/ai/client.ts
+// src/scheduler/index.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
+// src/scheduler/cron.ts
+var RANGES = [
+  [0, 59],
+  // 分
+  [0, 23],
+  // 时
+  [1, 31],
+  // 日
+  [1, 12],
+  // 月
+  [0, 6]
+  // 周
+];
+function parseField(field, idx) {
+  const [min, max] = RANGES[idx];
+  const name = ["minute", "hour", "day", "month", "weekday"][idx];
+  if (field === "*") return null;
+  if (field.startsWith("*/")) {
+    const n = Number(field.slice(2));
+    if (!Number.isInteger(n) || n <= 0 || n > max) {
+      throw new Error(`cron: invalid step '${field}' in ${name} field (must be 1..${max})`);
+    }
+    const set2 = /* @__PURE__ */ new Set();
+    for (let v = min; v <= max; v += n) set2.add(v);
+    return set2;
+  }
+  const set = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    if (part === "") throw new Error(`cron: empty item in '${field}' (${name})`);
+    if (part.includes("-")) {
+      const [rangePart, stepPart] = part.split("/");
+      const step = stepPart !== void 0 ? Number(stepPart) : 1;
+      const [a, b] = rangePart.split("-").map(Number);
+      if (!Number.isInteger(a) || !Number.isInteger(b) || a < min || b > max || a > b) {
+        throw new Error(`cron: invalid range '${part}' in ${name} field (${min}..${max})`);
+      }
+      if (!Number.isInteger(step) || step <= 0) throw new Error(`cron: invalid step in '${part}'`);
+      for (let v = a; v <= b; v += step) set.add(v);
+    } else {
+      const v = Number(part);
+      if (!Number.isInteger(v) || v < min || v > max) {
+        throw new Error(`cron: value '${part}' out of range ${min}..${max} in ${name} field`);
+      }
+      set.add(v);
+    }
+  }
+  return set;
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`cron: expected 5 fields (min hour dom month dow), got ${parts.length}: '${expr}'`);
+  }
+  const fields = parts.map((p, i) => parseField(p, i));
+  return {
+    fields: fields.map((values) => ({ values })),
+    domExplicit: fields[2] !== null,
+    dowExplicit: fields[4] !== null
+  };
+}
+function fieldMatches(values, v) {
+  if (values === null) return true;
+  return values.has(v);
+}
+function dayMatches(expr, dom, dow) {
+  const domOk = fieldMatches(expr.fields[2].values, dom);
+  const dowOk = fieldMatches(expr.fields[4].values, dow);
+  if (expr.domExplicit && expr.dowExplicit) return domOk || dowOk;
+  if (expr.domExplicit) return domOk;
+  if (expr.dowExplicit) return dowOk;
+  return true;
+}
+function nextMatch(values, v, min, max) {
+  if (values === null) return v;
+  for (let x = v; x <= max; x++) if (values.has(x)) return x;
+  return null;
+}
+function nextRun(expr, from) {
+  const d = new Date(from.getTime());
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const deadline = from.getTime() + 5 * 366 * 24 * 3600 * 1e3;
+  while (d.getTime() <= deadline) {
+    const year = d.getFullYear();
+    const month = d.getMonth() + 1;
+    const dom = d.getDate();
+    const dow = d.getDay();
+    if (!fieldMatches(expr.fields[3].values, month)) {
+      d.setMonth(month, 1);
+      d.setHours(0, 0, 0, 0);
+      d.setMonth(month);
+      continue;
+    }
+    if (!dayMatches(expr, dom, dow)) {
+      d.setDate(dom + 1);
+      d.setHours(0, 0, 0, 0);
+      continue;
+    }
+    const hour = d.getHours();
+    const nextHour = nextMatch(expr.fields[1].values, hour, 0, 23);
+    if (nextHour === null) {
+      d.setDate(dom + 1);
+      d.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (nextHour !== hour) {
+      d.setHours(nextHour, 0, 0, 0);
+      continue;
+    }
+    const minute = d.getMinutes();
+    const nextMinute = nextMatch(expr.fields[0].values, minute, 0, 59);
+    if (nextMinute === null) {
+      d.setHours(hour + 1, 0, 0, 0);
+      continue;
+    }
+    if (nextMinute !== minute) {
+      d.setMinutes(nextMinute, 0, 0);
+      continue;
+    }
+    return d;
+  }
+  throw new Error("cron: no next run within 5 years (invalid expression?)");
+}
+
+// src/scheduler/index.ts
+function parseUrl2(options) {
+  const url = options?.url ?? process.env.REDIS_URL ?? "redis://localhost:6379";
+  const u = new URL(url);
+  return { host: u.hostname, port: Number(u.port || 6379) };
+}
+function scheduler(options) {
+  const prefix = options.prefix ?? "wf:sched:";
+  const tickMs = options.tickMs ?? 1e3;
+  const delayedKey = `${prefix}delayed`;
+  const cronsKey = `${prefix}crons`;
+  const connOpts = parseUrl2(options);
+  const queueModule = options.queue;
+  const conn = new RedisConnection(connOpts);
+  let running = false;
+  let tickTimer = null;
+  async function tick() {
+    await tickCrons();
+    let due;
+    try {
+      due = await conn.command("ZRANGEBYSCORE", delayedKey, 0, Date.now());
+    } catch {
+      return;
+    }
+    for (const member of due) {
+      let removed;
+      try {
+        removed = await conn.command("ZREM", delayedKey, member);
+      } catch {
+        return;
+      }
+      if (removed !== 1) continue;
+      try {
+        const task = JSON.parse(member);
+        await queueModule.queue.add(task.name, task.data);
+      } catch (e) {
+        console.error("[scheduler] enqueue:", e instanceof Error ? e.message : e);
+      }
+    }
+  }
+  async function tickCrons() {
+    let crons;
+    try {
+      crons = await conn.command("HGETALL", cronsKey);
+    } catch {
+      return;
+    }
+    const now = Date.now();
+    const entries = crons;
+    for (let i = 0; i + 1 < entries.length; i += 2) {
+      const field = entries[i];
+      const value = entries[i + 1];
+      let def;
+      try {
+        def = JSON.parse(value);
+      } catch {
+        continue;
+      }
+      const parsed = parseCron(def.expr);
+      let next = def.nextRunAt;
+      while (next <= now) {
+        const ts = next;
+        const member = JSON.stringify({ id: `cron:${field}:${ts}`, name: def.name, data: def.data });
+        try {
+          await conn.command("ZADD", delayedKey, "NX", ts, member);
+        } catch {
+          break;
+        }
+        next = nextRun(parsed, new Date(ts)).getTime();
+      }
+      if (next !== def.nextRunAt) {
+        await conn.command("HSET", cronsKey, field, JSON.stringify({ ...def, nextRunAt: next }));
+      }
+    }
+  }
+  const cron = async (expr, name, data) => {
+    const parsed = parseCron(expr);
+    const firstRun = nextRun(parsed, /* @__PURE__ */ new Date());
+    const def = JSON.stringify({ expr, name, data, nextRunAt: firstRun.getTime() });
+    await conn.command("HSET", cronsKey, name, def);
+  };
+  const cancelCron = async (name) => {
+    const removed = await conn.command("HDEL", cronsKey, name);
+    try {
+      const pending = await conn.command("ZRANGE", delayedKey, 0, -1);
+      for (const member of pending) {
+        if (member.includes(`"id":"cron:${name}:`)) {
+          await conn.command("ZREM", delayedKey, member);
+        }
+      }
+    } catch {
+    }
+    return removed === 1;
+  };
+  async function start() {
+    if (running) return;
+    running = true;
+    await conn.connect();
+    await tick();
+    tickTimer = setInterval(() => {
+      tick().catch((e) => console.error("[scheduler] tick:", e instanceof Error ? e.message : e));
+    }, tickMs);
+    tickTimer.unref?.();
+  }
+  const schedule = async (name, data, opts = {}) => {
+    const delayMs = opts.delayMs ?? 0;
+    const runAt = opts.when ? opts.when.getTime() : Date.now() + delayMs;
+    if (!Number.isFinite(runAt)) throw new Error("scheduler: invalid when/delayMs");
+    const id = randomUUID2();
+    const member = JSON.stringify({ id, name, data });
+    await conn.command("ZADD", delayedKey, runAt, member);
+    return { id };
+  };
+  const cancelSchedule = async (id) => {
+    try {
+      const pending = await conn.command("ZRANGE", delayedKey, 0, -1);
+      for (const member of pending) {
+        if (member.includes(`"id":"${id}"`)) {
+          const removed = await conn.command("ZREM", delayedKey, member);
+          if (removed === 1) return true;
+        }
+      }
+    } catch {
+    }
+    return false;
+  };
+  const mw = (async (req, ctx, next) => {
+    ctx.schedule = schedule;
+    ctx.cron = cron;
+    ctx.cancelCron = cancelCron;
+    ctx.cancelSchedule = cancelSchedule;
+    return next(req, ctx);
+  });
+  mw.__meta = { injects: ["schedule", "cron", "cancelCron", "cancelSchedule"], depends: ["queue"] };
+  mw.schedule = schedule;
+  mw.cron = cron;
+  mw.cancelCron = cancelCron;
+  mw.cancelSchedule = cancelSchedule;
+  mw.close = async () => {
+    running = false;
+    if (tickTimer) {
+      clearInterval(tickTimer);
+      tickTimer = null;
+    }
+    await conn.close().catch(() => {
+    });
+  };
+  start().catch((e) => console.error("[scheduler] start:", e instanceof Error ? e.message : e));
+  return mw;
+}
+
+// src/ai/client.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+
 // src/ai/sse.ts
 function sseResponse(run, options) {
   const encoder = new TextEncoder();
@@ -3200,7 +3957,7 @@ function createAiClient(opts) {
     }
     return sseResponse(
       async (emit) => {
-        emit("wf:message_start", { id: options?.traceId ?? randomUUID2() });
+        emit("wf:message_start", { id: options?.traceId ?? randomUUID3() });
         await streamStep(params, {
           emit,
           signal: controller.signal,
@@ -3294,7 +4051,7 @@ function safeParseArgs(raw) {
 }
 
 // src/ai/agent.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 function createAgent(client, config) {
   const maxSteps = config.maxSteps ?? 10;
   const toolDefs = config.tools.map((t) => ({
@@ -3313,14 +4070,14 @@ function createAgent(client, config) {
     const controller = createController(options?.signal);
     const emit = options?.emit ?? (() => {
     });
-    emit("wf:message_start", { id: options?.traceId ?? randomUUID3() });
+    emit("wf:message_start", { id: options?.traceId ?? randomUUID4() });
     await loop(messages, emit, controller.signal);
   }
   function run(messages, options) {
     const controller = createController(options?.signal);
     return sseResponse(
       async (emit) => {
-        emit("wf:message_start", { id: options?.traceId ?? randomUUID3() });
+        emit("wf:message_start", { id: options?.traceId ?? randomUUID4() });
         await loop(messages, emit, controller.signal);
       },
       { onAbort: () => controller.abort() }
@@ -3399,7 +4156,7 @@ function createAgent(client, config) {
         let execArgs = args;
         if (config.humanInTheLoop) {
           const decision = await client.waitApproval(
-            { id: randomUUID3(), toolCallId: tc.id, name, args },
+            { id: randomUUID4(), toolCallId: tc.id, name, args },
             emit,
             config.approvalTimeoutMs
           );
@@ -4210,6 +4967,9 @@ function concat(...parts) {
 }
 
 // src/db/postgres/connection.ts
+function isCacheInvalidationError(message) {
+  return message.includes("cached plan must not change result type") || message.includes("cache lookup failed for type");
+}
 var PgConnection = class _PgConnection {
   opts;
   timeoutSet = false;
@@ -4233,6 +4993,8 @@ var PgConnection = class _PgConnection {
   get connected() {
     return this.status === "ready";
   }
+  /** 池空闲回收用：最近一次查询完成时间戳（pool release 时更新） */
+  lastUsed = 0;
   connect() {
     return new Promise((resolve3, reject) => {
       this.status = "connecting";
@@ -4282,7 +5044,13 @@ var PgConnection = class _PgConnection {
   // sig → stmt + 列缓存（LRU）
   static PREPARED_MAX = 128;
   stmtSeq = 0;
+  /** LRU 淘汰的 statement 名——连接空闲时批量 DEALLOCATE（服务端同步释放，防 plan 缓存膨胀） */
+  deallocQueue = [];
+  /** DEALLOCATE 批量的响应 Z——仅消费（不 resolve 查询） */
+  awaitingDeallocZ = false;
   currentQuery = null;
+  /** DDL 失效重试：缓存语句被 DROP 后服务器拒绝执行，Sync 复位后以新语句名重 Parse */
+  pendingRetry = null;
   onData(chunk) {
     const msgs = this.stream.push(new Uint8Array(chunk));
     for (const msg of msgs) {
@@ -4378,9 +5146,15 @@ var PgConnection = class _PgConnection {
         }
         break;
       }
-      case "C":
+      case "C": {
+        const q = this.currentQuery;
+        if (q) {
+          const tag = new TextDecoder().decode(msg.payload).replace(/\0+$/, "");
+          const m = tag.match(/^(?:INSERT|UPDATE|DELETE|MERGE)\s+(?:\d+\s+)?(\d+)$/);
+          if (m) q.affectedRows = parseInt(m[1], 10);
+        }
         break;
-      // CommandComplete——忽略 tag
+      }
       case "t": {
         if (this.currentQuery?.awaitingDescribe && this.currentQuery.sql !== void 0) {
           this.currentQuery.awaitingDescribe = false;
@@ -4399,11 +5173,32 @@ var PgConnection = class _PgConnection {
       case "Z": {
         if (this.pendingErrorZ) {
           this.pendingErrorZ = false;
+          if (this.pendingRetry) {
+            const r = this.pendingRetry;
+            this.pendingRetry = null;
+            this.issueExtendedQuery(r.sql, r.params ?? [], r.resolve, r.reject, r.retried);
+          }
+          break;
+        }
+        if (this.awaitingDeallocZ) {
+          this.awaitingDeallocZ = false;
           break;
         }
         const q = this.currentQuery;
         this.currentQuery = null;
-        if (q) q.resolve(q.rows);
+        if (q) {
+          const rows = q.rows;
+          if (q.affectedRows !== void 0) {
+            Object.defineProperty(rows, "affectedRows", {
+              value: q.affectedRows,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            });
+          }
+          q.resolve(rows);
+        }
+        this.flushDealloc();
         if (this.awaitingReady) {
           this.awaitingReady = false;
           this.onReady?.();
@@ -4417,9 +5212,24 @@ var PgConnection = class _PgConnection {
         this.currentQuery = null;
         if (q) {
           this.pendingErrorZ = true;
-          if (q.awaitingDescribe) this.send(syncMessage());
           const err = new Error(fields.message ?? "postgres query error");
           err.code = fields.code;
+          if (q.prepKey && isCacheInvalidationError(fields.message ?? "")) {
+            this.prepared.clear();
+            if (!q.retried) {
+              this.pendingRetry = {
+                sql: q.sql ?? "",
+                params: q.params,
+                columns: q.columns,
+                resolve: q.resolve,
+                reject: q.reject,
+                retried: true
+              };
+              if (q.awaitingDescribe) this.send(syncMessage());
+              break;
+            }
+          }
+          if (q.awaitingDescribe) this.send(syncMessage());
           q.reject(err);
         }
         break;
@@ -4478,15 +5288,28 @@ var PgConnection = class _PgConnection {
     }
     return entry;
   }
-  /** LRU 写入：刷新位置；超上限淘汰最旧（长运行服务防无限累积） */
+  /** LRU 写入：刷新位置；超上限淘汰最旧（长运行服务防无限累积）——淘汰的 statement 推入 deallocQueue，连接空闲时服务端同步释放 */
   setPrepared(sig, entry) {
     this.prepared.delete(sig);
     this.prepared.set(sig, entry);
     if (this.prepared.size > _PgConnection.PREPARED_MAX) {
       const oldest = this.prepared.keys().next().value;
-      if (oldest !== void 0) this.prepared.delete(oldest);
+      if (oldest !== void 0) {
+        const evicted = this.prepared.get(oldest);
+        this.prepared.delete(oldest);
+        if (evicted) this.deallocQueue.push(evicted.name);
+      }
     }
   }
+  /** 连接空闲时批量 DEALLOCATE：LRU 淘汰的 statement 不残留服务端（plan 缓存膨胀防线）。
+   * 同步 write 先于后续查询（调用点在 Z handler 的同步段内，resolve 的微任务后至）。
+   * 其响应 C+Z 在无 currentQuery 时到达——awaitingDeallocZ 消费首个 Z，后续查询 Z 正常。 */
+  flushDealloc() {
+    if (this.deallocQueue.length === 0 || !this.socket) return;
+    const names = this.deallocQueue.splice(0);
+    this.awaitingDeallocZ = true;
+    this.socket.write(queryMessage(names.map((n) => `DEALLOCATE "${n}"`).join("; ")));
+  }
   /** 事务：BEGIN → fn(tx) → COMMIT；fn 抛错 → ROLLBACK（回滚失败吞掉，保留原始错误） */
   async transaction(fn) {
     await this.query("BEGIN");
@@ -4524,21 +5347,7 @@ var PgConnection = class _PgConnection {
         let stmtEntry = this.getPrepared(sig);
         const encoded = encodeParams(params);
         if (!stmtEntry) {
-          const name = `wf_s${++this.stmtSeq}`;
-          this.currentQuery = {
-            columns: [],
-            rows: [],
-            resolve: resolve3,
-            reject,
-            sql,
-            params: encoded,
-            awaitingDescribe: true,
-            prepKey: sig,
-            prepName: name
-          };
-          this.socket.write(parseMessage(name, sql, params.map(() => 0)));
-          this.socket.write(describeMessage("S", name));
-          this.socket.write(flushMessage());
+          this.issueExtendedQuery(sql, encoded, resolve3, reject);
         } else {
           this.currentQuery = {
             columns: [...stmtEntry.columns],
@@ -4547,7 +5356,9 @@ var PgConnection = class _PgConnection {
             reject,
             sql,
             params: encoded,
-            awaitingDescribe: false
+            awaitingDescribe: false,
+            prepKey: sig,
+            prepName: stmtEntry.name
           };
           this.socket.write(bindMessage(stmtEntry.name, encoded));
           this.socket.write(executeMessage());
@@ -4556,6 +5367,28 @@ var PgConnection = class _PgConnection {
       }
     });
   }
+  /**
+   * 扩展查询首次准备：Parse + Describe + Flush（无 Sync——错误时由调用方发 Sync 复位）。
+   * retry 路径复用：新语句名强制服务器按当前 schema 重新解析（DDL 失效恢复）。
+   */
+  issueExtendedQuery(sql, params, resolve3, reject, retried) {
+    const name = `wf_s${++this.stmtSeq}`;
+    this.currentQuery = {
+      columns: [],
+      rows: [],
+      resolve: resolve3,
+      reject,
+      sql,
+      params,
+      awaitingDescribe: true,
+      prepKey: `${sql}|${params.length}`,
+      prepName: name,
+      retried
+    };
+    this.socket?.write(parseMessage(name, sql, params.map(() => 0)));
+    this.socket?.write(describeMessage("S", name));
+    this.socket?.write(flushMessage());
+  }
   send(data) {
     this.socket?.write(data);
   }
@@ -4631,6 +5464,8 @@ function convertValue(oid, value) {
       return parseFloat(value);
     case 16:
       return value === "t";
+    case 1184:
+      return new Date(value);
     default:
       return value;
   }
@@ -4691,6 +5526,7 @@ var PgPool = class _PgPool {
   opts;
   initPromise = null;
   schemas = /* @__PURE__ */ new Map();
+  idleTimer = null;
   /** 懒连接：构造不连接，ensure() 首次初始化（中间件注入场景） */
   constructor(options = {}) {
     this.opts = options;
@@ -4720,13 +5556,54 @@ var PgPool = class _PgPool {
     this.all = conns;
     this.available = [...conns];
     this.readyPromise = Promise.resolve();
+    this.startIdleReaper();
+  }
+  /** 空闲回收定时器（idleTimeoutMs > 0 时启动；unref 不阻塞进程退出） */
+  startIdleReaper() {
+    const ms = this.opts.idleTimeoutMs ?? 0;
+    if (ms <= 0 || this.idleTimer) return;
+    this.idleTimer = setInterval(() => this.reapIdle(), ms);
+    this.idleTimer.unref?.();
+  }
+  /** 扫描空闲连接：超时未使用 → close + 从池移除（容量收缩；acquire 时自动重建） */
+  reapIdle() {
+    if (this.closed) return;
+    const now = Date.now();
+    const ms = this.opts.idleTimeoutMs ?? 0;
+    for (let i = this.available.length - 1; i >= 0; i--) {
+      const conn = this.available[i];
+      if (conn.lastUsed > 0 && now - conn.lastUsed >= ms) {
+        this.available.splice(i, 1);
+        const idx = this.all.indexOf(conn);
+        if (idx >= 0) this.all.splice(idx, 1);
+        conn.close();
+      }
+    }
   }
-  /** 获取一个空闲连接（全忙则排队等待） */
+  /** 当前打开的连接数（含借出；测试/观测用） */
+  get open() {
+    return this.all.length;
+  }
+  /** 获取一个空闲连接（全忙则排队等待；池被空闲回收收缩时自动新建恢复容量） */
   acquire() {
     if (this.closed) return Promise.reject(new ConnectionError("postgres: pool is closed"));
     if (this.available.length > 0) {
       return Promise.resolve(this.available.pop());
     }
+    const poolSize = this.opts.poolSize ?? 5;
+    if (this.all.length < poolSize) {
+      const c = new PgConnection(this.opts);
+      return c.connect().then(
+        () => {
+          this.all.push(c);
+          return c;
+        },
+        () => {
+          setTimeout(() => this.replenish(), 500);
+          throw new ConnectionError("postgres: failed to establish connection");
+        }
+      );
+    }
     const timeoutMs = this.opts.acquireTimeoutMs ?? 3e4;
     return new Promise((resolve3, reject) => {
       const waiter = {
@@ -4753,6 +5630,7 @@ var PgPool = class _PgPool {
       this.replenish();
       return;
     }
+    conn.lastUsed = Date.now();
     this.dispatchAvailable(conn);
   }
   /** 连接可用事件统一入口：优先唤醒等待者，否则回空闲池（release 与 replenish 共用） */
@@ -4796,6 +5674,69 @@ var PgPool = class _PgPool {
   register(table, schema) {
     this.schemas.set(table, schema);
   }
+  /**
+   * 批量插入：多行 VALUES 单次往返（种子/批量写场景 N 往返 → 1）。
+   * 诚实裁剪：所有行必须键集合一致（否则抛 ValidationError）；batchSize 分批（默认 500）。
+   */
+  async insertMany(table, rows, opts = {}) {
+    const empty = [];
+    if (rows.length === 0) {
+      Object.defineProperty(empty, "affectedRows", { value: 0, enumerable: false, writable: true });
+      return empty;
+    }
+    const schema = this.schemas.get(table);
+    const keys = Object.keys(rows[0]).sort();
+    const batchSize = Math.max(1, opts.batchSize ?? 500);
+    let total = 0;
+    let last = empty;
+    for (let i = 0; i < rows.length; i += batchSize) {
+      const batch = rows.slice(i, i + batchSize);
+      for (let r2 = 0; r2 < batch.length; r2++) {
+        const row = batch[r2];
+        const rowKeys = Object.keys(row).sort();
+        if (rowKeys.length !== keys.length || rowKeys.some((k, j) => k !== keys[j])) {
+          throw new ValidationError(
+            `schema: insertMany requires identical keys across rows (row ${i + r2} has [${rowKeys}], expected [${keys}])`
+          );
+        }
+        if (schema) validateRow(schema, row);
+      }
+      const vals = batch.map((_, r2) => `(${keys.map((_2, c) => `$${r2 * keys.length + c + 1}`).join(", ")})`).join(", ");
+      const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${vals}`;
+      const params = batch.flatMap((row) => keys.map((k) => row[k]));
+      const r = await this.query(sql, params);
+      total += r.affectedRows ?? batch.length;
+      if (r.length > 0) last = r;
+    }
+    Object.defineProperty(last, "affectedRows", { value: total, enumerable: false, writable: true });
+    return last;
+  }
+  /** 参数化 UPDATE：SET + WHERE 全部参数化（防注入）；返回 affectedRows；returning 可回读修改行 */
+  async update(table, set, where, opts = {}) {
+    const schema = this.schemas.get(table);
+    if (schema) validateRow(schema, { ...set, ...where });
+    const setCols = Object.keys(set);
+    if (setCols.length === 0) throw new ValidationError("schema: update requires at least one SET column");
+    const whereCols = Object.keys(where);
+    if (whereCols.length === 0) {
+      throw new ValidationError("schema: update requires a WHERE clause (full-table update via unsafe)");
+    }
+    const setSql = setCols.map((c, i) => `${c} = $${i + 1}`).join(", ");
+    const whereSql = whereCols.map((c, i) => `${c} = $${setCols.length + i + 1}`).join(" AND ");
+    const returning = opts.returning?.length ? ` RETURNING ${opts.returning.join(", ")}` : "";
+    const sql = `UPDATE ${table} SET ${setSql} WHERE ${whereSql}${returning}`;
+    const params = [...setCols.map((c) => set[c]), ...whereCols.map((c) => where[c])];
+    return this.query(sql, params);
+  }
+  /** 参数化 DELETE：WHERE 参数化；返回 affectedRows。WHERE 必填（防全表误删） */
+  async delete(table, where) {
+    const schema = this.schemas.get(table);
+    if (schema) validateRow(schema, where);
+    const whereCols = Object.keys(where);
+    if (whereCols.length === 0) throw new ValidationError("schema: delete requires a WHERE clause");
+    const sql = `DELETE FROM ${table} WHERE ${whereCols.map((c, i) => `${c} = $${i + 1}`).join(" AND ")}`;
+    return this.query(sql, whereCols.map((c) => where[c]));
+  }
   /** 写前校验 + 参数化插入（schema 驱动，脏数据源头拦截） */
   async insert(table, row) {
     const schema = this.schemas.get(table);
@@ -4865,6 +5806,10 @@ var PgPool = class _PgPool {
   }
   async close() {
     this.closed = true;
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
     this.readyPromise = null;
     this.available = [];
     await Promise.all(this.all.map((c) => c.close()));
@@ -4900,7 +5845,9 @@ function parseTagged(strings, values) {
 }
 
 // src/postgres/client.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 var MIGRATIONS_TABLE = "_weifuwu_migrations";
+var traceStore = new AsyncLocalStorage();
 function postgres(options) {
   const opts = typeof options === "string" ? { connection: options } : options ?? {};
   const connection = opts.connection ?? process.env.DATABASE_URL;
@@ -4919,12 +5866,16 @@ function postgres(options) {
     poolSize: opts.max ?? opts.poolSize ?? 10,
     acquireTimeoutMs: opts.acquireTimeoutMs,
     statementTimeoutMs: opts.statementTimeoutMs ?? opts.statementTimeout,
-    onQuery: opts.onQuery
+    // onQuery 包装：从 ALS 读请求级 traceId 追加到第 4 参数（后端兼容——不传时不注入）
+    onQuery: opts.onQuery ? (sql2, durationMs, rowCount) => {
+      const tid = traceStore.getStore();
+      opts.onQuery?.(sql2, durationMs, rowCount, tid || void 0);
+    } : void 0
   });
   const sql = makeSql(pool);
   const mw = ((req, ctx, next) => {
     ctx.sql = sql;
-    return next(req, ctx);
+    return traceStore.run(req.headers.get("x-trace-id") ?? "", () => next(req, ctx));
   });
   mw.__meta = { injects: ["sql"], depends: [] };
   mw.sql = sql;
@@ -5030,6 +5981,8 @@ function wrapError(promise) {
 }
 
 // src/redis/client.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var traceStore2 = new AsyncLocalStorage2();
 function redis(options) {
   const opts = typeof options === "string" ? { url: options } : options ?? {};
   const url = opts.url ?? process.env.REDIS_URL ?? "redis://localhost:6379";
@@ -5039,11 +5992,18 @@ function redis(options) {
     port: Number(u.port || 6379),
     poolSize: opts.poolSize,
     keyPrefix: opts.keyPrefix,
-    enableOfflineQueue: opts.enableOfflineQueue
+    enableOfflineQueue: opts.enableOfflineQueue,
+    commandTimeoutMs: opts.commandTimeoutMs,
+    socketTimeoutMs: opts.socketTimeoutMs,
+    // onCommand 包装：从 ALS 读请求级 traceId 追加到第 4 参数（无头不注入）
+    onCommand: opts.onCommand ? (cmd, args, dur) => {
+      const tid = traceStore2.getStore();
+      opts.onCommand?.(cmd, args, dur, tid || void 0);
+    } : void 0
   });
   const mw = (async (req, ctx, next) => {
     ctx.redis = pool;
-    return next(req, ctx);
+    return traceStore2.run(req.headers.get("x-trace-id") ?? "", () => next(req, ctx));
   });
   mw.__meta = { injects: ["redis"], depends: [] };
   mw.redis = pool;
@@ -5085,6 +6045,7 @@ export {
   rateLimit,
   redirect,
   redis,
+  scheduler,
   sendSmtp,
   serve,
   serveStatic,