weifuwu 0.55.3 → 0.56.1

package/dist/index.js

@@ -1083,23 +1083,219 @@ import { build } from "esbuild";
 import { readFile, stat } from "node:fs/promises";
 import { resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
+
+// src/ui/html-safe.ts
 var HtmlSafe = class {
+  value;
   constructor(value) {
     this.value = value;
   }
-  value;
   toString() {
     return this.value;
   }
 };
+
+// src/client/vnode.ts
+var ASYNC_MARK = "__wfAsyncComponent";
+function isAsyncComponent(type) {
+  return typeof type === "function" && type?.[ASYNC_MARK] === true;
+}
+var Fragment = /* @__PURE__ */ Symbol("Fragment");
+var Portal = /* @__PURE__ */ Symbol("Portal");
+
+// src/client/reactive.ts
+function createReactiveState(dirty) {
+  const proxyCache = /* @__PURE__ */ new WeakMap();
+  const reactive = (target) => {
+    if (target === null || typeof target !== "object") return target;
+    if (proxyCache.has(target)) return proxyCache.get(target);
+    const proxy = new Proxy(target, {
+      set(target2, key, value) {
+        const old = Reflect.get(target2, key);
+        if (old === value) return true;
+        Reflect.set(target2, key, value);
+        dirty();
+        return true;
+      },
+      get(target2, key) {
+        const value = Reflect.get(target2, key);
+        if (typeof value === "object" && value !== null) return reactive(value);
+        return value;
+      },
+      deleteProperty(target2, key) {
+        if (Reflect.has(target2, key)) {
+          Reflect.deleteProperty(target2, key);
+          dirty();
+        }
+        return true;
+      }
+    });
+    proxyCache.set(target, proxy);
+    return proxy;
+  };
+  return reactive({});
+}
+
+// src/ui/ssr.ts
 function escape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function classToString(v) {
+  if (typeof v === "string") return v;
+  if (Array.isArray(v)) return v.filter(Boolean).join(" ");
+  if (v && typeof v === "object") {
+    return Object.entries(v).filter(([, b]) => b).map(([k]) => k).join(" ");
+  }
+  return "";
+}
+function styleToString(v) {
+  if (typeof v === "string") return v;
+  if (v && typeof v === "object") {
+    return Object.entries(v).filter(([, x]) => x != null).map(([k, x]) => `${k}:${typeof x === "number" ? x + "px" : String(x)}`).join(";");
+  }
+  return "";
+}
+function createSsrContext(serverCtx, dataStore) {
+  const usedIds = /* @__PURE__ */ new Set();
+  const ui2 = {
+    $: () => createReactiveState(() => {
+    }),
+    dirty: () => {
+    },
+    render: () => {
+    },
+    selfId: (name) => {
+      if (usedIds.has(name)) throw new Error(`[weifuwu] Duplicate component ID: "${name}"`);
+      usedIds.add(name);
+    },
+    useMedia: () => {
+    },
+    useBreakpoint: () => {
+    },
+    usePopupPosition: () => ({ top: 0, left: 0, refresh: () => {
+    } })
+  };
+  const ctx = Object.create(serverCtx ?? {});
+  ctx.ui = ui2;
+  ctx.data = {
+    async get(key, fetcher) {
+      if (dataStore.has(key)) return dataStore.get(key);
+      if (!fetcher) return void 0;
+      const val = await fetcher();
+      dataStore.set(key, val);
+      return val;
+    },
+    set(key, val) {
+      dataStore.set(key, val);
+    },
+    has(key) {
+      return dataStore.has(key);
+    }
+  };
+  return ctx;
+}
+async function renderSsr(input, ctx) {
+  if (input == null || typeof input === "boolean") return "";
+  if (typeof input === "string" || typeof input === "number") return escape(String(input));
+  if (Array.isArray(input)) {
+    let s = "";
+    for (const c of input) s += await renderSsr(c, ctx);
+    return s;
+  }
+  const vnode = input;
+  if (vnode.type === Portal) return renderSsr(vnode.props?.children, ctx);
+  if (vnode.type === Fragment) return renderSsr(vnode.props?.children, ctx);
+  if (typeof vnode.type === "function") {
+    let def;
+    if (isAsyncComponent(vnode.type)) {
+      def = await vnode.type(ctx);
+      if (typeof def !== "function") {
+        throw new Error(
+          `asyncComponent factory <${vnode.type.name || "anonymous"}> must return a Component (initProps, ctx) => (props) => VNode.`
+        );
+      }
+    } else {
+      def = vnode.type;
+    }
+    const childCtx = Object.create(ctx);
+    const renderFn = def(vnode.props ?? {}, childCtx);
+    if (typeof renderFn !== "function") {
+      throw new Error(
+        `Component ${vnode.type.name || "anonymous"} must return a render function. Use (init_props, ctx) => (props) => VNode pattern.`
+      );
+    }
+    return renderSsr(renderFn(vnode.props ?? {}), childCtx);
+  }
+  const tag = vnode.type;
+  const props = vnode.props ?? {};
+  const attrs = [];
+  let innerHTML;
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children" || key === "key") continue;
+    if (key === "ref") continue;
+    if (key.startsWith("on") && typeof value === "function") continue;
+    if (key === "innerHTML") {
+      innerHTML = String(value ?? "");
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      const cls = classToString(value);
+      if (cls) attrs.push(` class="${escape(cls)}"`);
+      continue;
+    }
+    if (key === "style" && value && typeof value === "object") {
+      attrs.push(` style="${escape(styleToString(value))}"`);
+      continue;
+    }
+    if (value === true) {
+      attrs.push(` ${key}`);
+      continue;
+    }
+    if (value === false || value == null) continue;
+    attrs.push(` ${key}="${escape(String(value))}"`);
+  }
+  const attrStr = attrs.join("");
+  if (VOID_TAGS.has(tag)) return `<${tag}${attrStr}>`;
+  if (innerHTML !== void 0) return `<${tag}${attrStr}>${innerHTML}</${tag}>`;
+  const children = await renderSsr(props.children, ctx);
+  return `<${tag}${attrStr}>${children}</${tag}>`;
+}
+async function ssrToString(Comp, props, serverCtx, opts = {}) {
+  const dataStore = opts.data ?? /* @__PURE__ */ new Map();
+  const ctx = createSsrContext(serverCtx, dataStore);
+  const html = await renderSsr({ type: Comp, props: props ?? {}, key: void 0 }, ctx);
+  return new HtmlSafe(html);
+}
+function serializeData(data) {
+  const json = JSON.stringify(Object.fromEntries(data)).replace(/</g, "\\u003c");
+  return `<script>window.__DATA__=${json};</script>`;
+}
+
+// src/ui/index.ts
+function escape2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
 function stringify(v) {
   if (v == null || v === false || v === true) return "";
   if (Array.isArray(v)) return v.map(stringify).join("");
   if (v instanceof HtmlSafe) return v.value;
-  return escape(String(v));
+  return escape2(String(v));
 }
 function unsafe(s) {
   return new HtmlSafe(s);
@@ -1153,6 +1349,15 @@ function ui() {
     }
     ctx.ui = {
       html: Object.assign(htmlTag, { unsafe }),
+      /** SSR 渲染组件 → HTML 片段（HtmlSafe：内联进 ctx.ui.html 不二次转义） */
+      async ssr(Comp, props, opts) {
+        const safe = await ssrToString(Comp, props ?? {}, ctx, opts);
+        return safe;
+      },
+      /** 序列化 SSR 数据存储 → window.__DATA__ 脚本（HtmlSafe） */
+      ssrData(data) {
+        return new HtmlSafe(serializeData(data));
+      },
       async js(entryPath) {
         const absPath = resolveEntry(entryPath);
         const cached = jsCache.get(absPath);
@@ -1217,6 +1422,98 @@ function ui() {
   };
 }
 
+// src/client/route-match.ts
+function joinPaths(a, b) {
+  if (!b || b === "/") return a || "/";
+  const left = a.endsWith("/") ? a.slice(0, -1) : a;
+  const right = b.startsWith("/") ? b : "/" + b;
+  return left + right;
+}
+function compilePath(path) {
+  const keys = [];
+  const reStr = path.replace(/:(\w+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*/g, ".*");
+  return { re: new RegExp(`^${reStr}$`), keys };
+}
+function flattenRoutes(routes, basePath = "", chain = []) {
+  const result = [];
+  for (const route of routes) {
+    const fullPath = joinPaths(basePath, route.path);
+    const { re, keys } = compilePath(fullPath);
+    const fullChain = [...chain, route];
+    result.push({ re, keys, def: route, chain: fullChain });
+    if (route.children) {
+      result.push(...flattenRoutes(route.children, fullPath, fullChain));
+    }
+  }
+  return result;
+}
+function matchRoute(path, routes) {
+  let best = null;
+  for (const fr of routes) {
+    if (path.match(fr.re)) {
+      if (!best || fr.chain.length > best.chain.length) best = fr;
+    }
+  }
+  return best;
+}
+function extractParams(path, match) {
+  const params = {};
+  const m = path.match(match.re);
+  if (m) {
+    for (let i = 0; i < match.keys.length; i++) {
+      params[match.keys[i]] = decodeURIComponent(m[i + 1]);
+    }
+  }
+  return params;
+}
+
+// src/ui/ssr-page.ts
+var DEFAULT_TEMPLATE = (p) => `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(p.title)}</title>
+  ${(p.styles ?? []).map((s) => `<link rel="stylesheet" href="${escapeHtml(s)}">`).join("\n  ")}
+</head>
+<body>
+  <div id="root">${p.html}</div>
+  ${p.dataScript}
+  ${p.bundle ? `<script src="${escapeHtml(p.bundle)}"></script>` : ""}
+</body>
+</html>`;
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function uiSsr(opts) {
+  const flatRoutes = flattenRoutes(opts.routes);
+  const template = opts.template ?? DEFAULT_TEMPLATE;
+  return async (req, ctx, next) => {
+    if (req.method !== "GET") return next(req, ctx);
+    const url = new URL(req.url);
+    const match = matchRoute(url.pathname, flatRoutes);
+    if (!match) return next(req, ctx);
+    const params = extractParams(url.pathname, match);
+    const def = match.chain[match.chain.length - 1] ?? match.def;
+    const pageCtx = Object.assign(Object.create(ctx), {
+      params,
+      route: { path: url.pathname, params, query: Object.fromEntries(url.searchParams) }
+    });
+    if (!def.component) return next(req, ctx);
+    const data = /* @__PURE__ */ new Map();
+    const html = await ssrToString(def.component, {}, pageCtx, { data });
+    const title = opts.title ? opts.title({ params, def }) : def.title || "weifuwu";
+    const dataScript = new HtmlSafe(serializeData(data)).toString();
+    const body = template({ html: html.toString(), dataScript, title, bundle: opts.bundle, styles: opts.styles });
+    return new Response(body, {
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  };
+}
+
 // src/db/postgres/connection.ts
 import net from "node:net";
 import crypto2 from "node:crypto";
@@ -1270,23 +1567,61 @@ function parseMessage(name, sql, paramTypes = []) {
   return encodeMessage("P", concat(body, types));
 }
 function bindMessage(statement, params, paramFormats = []) {
-  const body = [...utf8(""), 0, ...utf8(statement), 0];
-  body.push(0, paramFormats.length);
+  const stmtBytes = utf8(statement);
+  const lens = new Array(params.length);
+  let total = 1 + stmtBytes.length + 1;
+  total += 2 + paramFormats.length * 2;
+  total += 2;
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i];
+    total += 4;
+    if (p !== null) {
+      const len = typeof p === "string" ? utf8Len(p) : p.length;
+      lens[i] = len;
+      total += len;
+    }
+  }
+  total += 2;
+  const body = new Uint8Array(total);
+  let off = 0;
+  body[off++] = 0;
+  body.set(stmtBytes, off);
+  off += stmtBytes.length;
+  body[off++] = 0;
+  body[off] = paramFormats.length >> 8 & 255;
+  body[off + 1] = paramFormats.length & 255;
+  off += 2;
   for (const f of paramFormats) {
-    body.push(f >> 8 & 255, f & 255);
-  }
-  body.push(0, params.length);
-  for (const p of params) {
+    body[off] = f >> 8 & 255;
+    body[off + 1] = f & 255;
+    off += 2;
+  }
+  body[off] = params.length >> 8 & 255;
+  body[off + 1] = params.length & 255;
+  off += 2;
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i];
     if (p === null) {
-      body.push(255, 255, 255, 255);
+      body[off] = body[off + 1] = body[off + 2] = body[off + 3] = 255;
+      off += 4;
     } else {
-      const bytes = typeof p === "string" ? utf8(p) : p;
-      body.push(bytes.length >> 24 & 255, bytes.length >> 16 & 255, bytes.length >> 8 & 255, bytes.length & 255);
-      for (const b of bytes) body.push(b);
+      const len = lens[i];
+      body[off] = len >> 24 & 255;
+      body[off + 1] = len >> 16 & 255;
+      body[off + 2] = len >> 8 & 255;
+      body[off + 3] = len & 255;
+      off += 4;
+      if (typeof p === "string") body.set(utf8(p), off);
+      else body.set(p, off);
+      off += len;
     }
   }
-  body.push(0, 0);
-  return encodeMessage("B", new Uint8Array(body));
+  body[off] = 0;
+  body[off + 1] = 0;
+  return encodeMessage("B", body);
+}
+function utf8Len(s) {
+  return Buffer.byteLength(s);
 }
 function executeMessage(portal = "", maxRows = 0) {
   const body = new Uint8Array(portal.length + 1 + 4);
@@ -1378,7 +1713,7 @@ function parseRowDescription(payload) {
   for (let c = 0; c < count; c++) {
     let j = i;
     while (payload[j] !== 0) j++;
-    const name = new TextDecoder().decode(payload.subarray(i, j));
+    const name = _decoder.decode(payload.subarray(i, j));
     i = j + 1;
     i += 6;
     const typeOid = payload[i] << 24 | payload[i + 1] << 16 | payload[i + 2] << 8 | payload[i + 3];
@@ -1400,7 +1735,7 @@ function parseDataRow(payload) {
     if (len === -1) {
       values.push(null);
     } else {
-      values.push(new TextDecoder().decode(payload.subarray(i, i + len)));
+      values.push(_decoder.decode(payload.subarray(i, i + len)));
       i += len;
     }
   }
@@ -1413,7 +1748,7 @@ function parseErrorFields(payload) {
     const type = String.fromCharCode(payload[i]);
     let j = i + 1;
     while (j < payload.length && payload[j] !== 0) j++;
-    const value = new TextDecoder().decode(payload.subarray(i + 1, j));
+    const value = _decoder.decode(payload.subarray(i + 1, j));
     switch (type) {
       case "S":
         out.severity = value;
@@ -1438,8 +1773,10 @@ function parseErrorFields(payload) {
   }
   return out;
 }
+var _decoder = new TextDecoder();
+var _encoder = new TextEncoder();
 function utf8(s) {
-  return new TextEncoder().encode(s);
+  return _encoder.encode(s);
 }
 function concat(...parts) {
   let total = 0;
@@ -1492,7 +1829,7 @@ var ValidationError = class extends DbError {
 };
 
 // src/db/postgres/connection.ts
-var PgConnection = class {
+var PgConnection = class _PgConnection {
   opts;
   timeoutSet = false;
   awaitingReady = false;
@@ -1526,11 +1863,7 @@ var PgConnection = class {
       }, this.opts.connectTimeoutMs);
       sock.once("connect", () => {
         sock.setNoDelay(true);
-        sock.write(
-          Buffer.from(
-            startupMessage({ user: this.opts.user, database: this.opts.database })
-          )
-        );
+        sock.write(startupMessage({ user: this.opts.user, database: this.opts.database }));
       });
       sock.on("data", (chunk) => this.onData(chunk));
       sock.on("error", (err) => {
@@ -1563,10 +1896,10 @@ var PgConnection = class {
   onReady = null;
   onAuthFail = null;
   expectingAuth = true;
-  authStage = "start";
   authCtx = null;
   prepared = /* @__PURE__ */ new Map();
-  // sig → stmt + 列缓存
+  // sig → stmt + 列缓存（LRU）
+  static PREPARED_MAX = 128;
   stmtSeq = 0;
   currentQuery = null;
   onData(chunk) {
@@ -1588,7 +1921,6 @@ var PgConnection = class {
           const outer = crypto2.createHash("md5").update(inner + Buffer.from(salt).toString("latin1")).digest("hex");
           this.send(passwordMessage(`md5${outer}`));
         } else if (code === 10) {
-          this.authStage = "sasl-initial";
           const nonce = crypto2.randomBytes(18).toString("base64url");
           const clientFirstBare = `n=,r=${nonce}`;
           this.authCtx = { clientNonce: nonce, clientFirstBare, serverFirst: "" };
@@ -1610,7 +1942,6 @@ var PgConnection = class {
           }
           this.authCtx.serverFirst = serverFirst;
           const clientFinal = this.scramFinal(this.authCtx);
-          this.authStage = "sasl-final";
           this.send(encodeP(utf82(clientFinal)));
         } else if (code === 12) {
           const serverFinal = new TextDecoder().decode(msg.payload.subarray(4));
@@ -1637,9 +1968,7 @@ var PgConnection = class {
         if (this.opts.statementTimeoutMs > 0 && !this.timeoutSet) {
           this.timeoutSet = true;
           this.awaitingReady = true;
-          this.socket?.write(
-            Buffer.from(queryMessage(`SET statement_timeout = ${this.opts.statementTimeoutMs}`))
-          );
+          this.socket?.write(queryMessage(`SET statement_timeout = ${this.opts.statementTimeoutMs}`));
           return;
         }
         this.onReady?.();
@@ -1651,9 +1980,8 @@ var PgConnection = class {
       case "T": {
         if (this.currentQuery) {
           this.currentQuery.columns = parseRowDescription(msg.payload);
-          const entry = this.prepared.get(
-            `${this.currentQuery.sql}|${this.currentQuery.params?.length ?? 0}`
-          );
+          const sig = `${this.currentQuery.sql}|${this.currentQuery.params?.length ?? 0}`;
+          const entry = this.getPrepared(sig);
           if (entry) entry.columns = this.currentQuery.columns;
         }
         break;
@@ -1676,7 +2004,7 @@ var PgConnection = class {
         if (this.currentQuery?.awaitingDescribe && this.currentQuery.sql !== void 0) {
           this.currentQuery.awaitingDescribe = false;
           if (this.currentQuery.prepKey && this.currentQuery.prepName) {
-            this.prepared.set(this.currentQuery.prepKey, {
+            this.setPrepared(this.currentQuery.prepKey, {
               name: this.currentQuery.prepName,
               columns: this.currentQuery.columns
             });
@@ -1760,6 +2088,24 @@ var PgConnection = class {
     const authMessage = `${ctx.clientFirstBare},${ctx.serverFirst},${clientFinalWithoutProof}`;
     return Buffer.from(hmac(serverKey, authMessage)).toString("base64");
   }
+  /** LRU 读取：命中移到尾部（最近使用），超限删最旧 */
+  getPrepared(sig) {
+    const entry = this.prepared.get(sig);
+    if (entry) {
+      this.prepared.delete(sig);
+      this.prepared.set(sig, entry);
+    }
+    return entry;
+  }
+  /** LRU 写入：刷新位置；超上限淘汰最旧（长运行服务防无限累积） */
+  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);
+    }
+  }
   /** 事务：BEGIN → fn(tx) → COMMIT；fn 抛错 → ROLLBACK（回滚失败吞掉，保留原始错误） */
   async transaction(fn) {
     await this.query("BEGIN");
@@ -1791,10 +2137,10 @@ var PgConnection = class {
           resolve: resolve3,
           reject
         };
-        this.socket.write(Buffer.from(queryMessage(sql)));
+        this.socket.write(queryMessage(sql));
       } else {
         const sig = `${sql}|${params.length}`;
-        let stmtEntry = this.prepared.get(sig);
+        let stmtEntry = this.getPrepared(sig);
         const encoded = encodeParams(params);
         if (!stmtEntry) {
           const name = `wf_s${++this.stmtSeq}`;
@@ -1809,9 +2155,9 @@ var PgConnection = class {
             prepKey: sig,
             prepName: name
           };
-          this.socket.write(Buffer.from(parseMessage(name, sql, params.map(() => 0))));
-          this.socket.write(Buffer.from(describeMessage("S", name)));
-          this.socket.write(Buffer.from(flushMessage()));
+          this.socket.write(parseMessage(name, sql, params.map(() => 0)));
+          this.socket.write(describeMessage("S", name));
+          this.socket.write(flushMessage());
         } else {
           this.currentQuery = {
             columns: [...stmtEntry.columns],
@@ -1822,15 +2168,15 @@ var PgConnection = class {
             params: encoded,
             awaitingDescribe: false
           };
-          this.socket.write(Buffer.from(bindMessage(stmtEntry.name, encoded)));
-          this.socket.write(Buffer.from(executeMessage()));
-          this.socket.write(Buffer.from(syncMessage()));
+          this.socket.write(bindMessage(stmtEntry.name, encoded));
+          this.socket.write(executeMessage());
+          this.socket.write(syncMessage());
         }
       }
     });
   }
   send(data) {
-    this.socket?.write(Buffer.from(data));
+    this.socket?.write(data);
   }
   notifyIdle() {
     const ws = this.waiters;
@@ -1846,7 +2192,7 @@ var PgConnection = class {
   async close() {
     const sock = this.socket;
     if (this.status === "ready" && sock) {
-      sock.write(Buffer.from(terminateMessage()));
+      sock.write(terminateMessage());
     }
     this.status = "closed";
     if (sock) sock.destroy();
@@ -2318,19 +2664,56 @@ var IncompleteError = class extends Error {
     this.name = "IncompleteError";
   }
 };
+function decodeValue(v, decodeBytes) {
+  if (v instanceof Uint8Array) return decodeBytes ? _decoder2.decode(v) : v;
+  if (Array.isArray(v)) return v.map((x) => decodeValue(x, decodeBytes));
+  return v;
+}
 function encodeCommand(args) {
-  const parts = [`*${args.length}\r
-`];
-  for (const arg of args) {
-    const s = typeof arg === "string" ? arg : arg instanceof Buffer ? arg.toString() : String(arg);
-    parts.push(`$${Buffer.byteLength(s)}\r
-${s}\r
-`);
+  const lens = new Array(args.length);
+  let total = headerLen(args.length);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const len = typeof arg === "string" ? Buffer.byteLength(arg) : arg instanceof Buffer ? arg.length : String(arg).length;
+    lens[i] = len;
+    total += headerLen(len) + len + 2;
   }
-  return _encoder.encode(parts.join(""));
+  const out = new Uint8Array(total);
+  let off = 0;
+  const head = `*${args.length}\r
+`;
+  out.set(_encoder2.encode(head), 0);
+  off = head.length;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const len = lens[i];
+    const lh = `$${len}\r
+`;
+    out.set(_encoder2.encode(lh), off);
+    off += lh.length;
+    if (typeof arg === "string") {
+      out.set(_encoder2.encode(arg), off);
+    } else if (arg instanceof Buffer) {
+      out.set(arg, off);
+    } else {
+      out.set(_encoder2.encode(String(arg)), off);
+    }
+    off += len;
+    out[off] = 13;
+    out[off + 1] = 10;
+    off += 2;
+  }
+  return out;
 }
-var _decoder = new TextDecoder();
-var _encoder = new TextEncoder();
+function headerLen(n) {
+  if (n < 10) return 4;
+  if (n < 100) return 5;
+  if (n < 1e3) return 6;
+  if (n < 1e4) return 7;
+  return 8;
+}
+var _decoder2 = new TextDecoder();
+var _encoder2 = new TextEncoder();
 var RespParser = class {
   buf = new Uint8Array(0);
   off = 0;
@@ -2404,16 +2787,15 @@ var RespParser = class {
         return new RespError(line);
       }
       case ":": {
-        const line = this.readLine();
-        return parseInt(line, 10);
+        return this.readInt();
       }
       case "$": {
-        const len = parseInt(this.readLine(), 10);
+        const len = this.readInt();
         if (len === -1) return null;
-        return this.readBulk(len);
+        return this.readBulkBytes(len);
       }
       case "*": {
-        const count = parseInt(this.readLine(), 10);
+        const count = this.readInt();
         if (count === -1) return null;
         const items = [];
         for (let i = 0; i < count; i++) items.push(this.parseValue());
@@ -2423,25 +2805,50 @@ var RespParser = class {
         throw new DbError("protocol", `unknown RESP type byte: ${type}`, { code: "RESP" });
     }
   }
+  /**
+   * 读整数（: 或 $ 长度）：扫描数字字符边算值，直到 \r\n（手动解析，免 parseInt + 字符串）。
+   * 支持负号（-1）。未读到终止符抛 IncompleteError（push 回滚）。
+   */
+  readInt() {
+    const buf = this.buf;
+    let i = this.off;
+    let neg = false;
+    if (i < buf.length && buf[i] === 45) {
+      neg = true;
+      i++;
+    }
+    let n = 0;
+    while (i < buf.length && buf[i] >= 48 && buf[i] <= 57) {
+      n = n * 10 + (buf[i] - 48);
+      i++;
+    }
+    if (i + 1 < buf.length && buf[i] === 13 && buf[i + 1] === 10) {
+      this.off = i + 2;
+      return neg ? -n : n;
+    }
+    throw new IncompleteError();
+  }
   /** 读一行（到 \r\n），返回行内容（不含 type 字节与 \r\n），并推进 off */
   readLine() {
     const idx = indexOfCRLF(this.buf, this.off);
     if (idx === -1) throw new IncompleteError();
-    const line = _decoder.decode(this.buf.subarray(this.off, idx));
+    const line = _decoder2.decode(this.buf.subarray(this.off, idx));
     this.off = idx + 2;
     return line;
   }
-  /** 读 len 字节的 bulk 内容 + \r\n */
-  readBulk(len) {
+  /** 读 len 字节的 bulk 内容 + \r\n（字节中立——不 decode，由调用方决定 string/Buffer） */
+  readBulkBytes(len) {
     if (this.buf.length - this.off < len + 2) throw new IncompleteError();
-    const value = _decoder.decode(this.buf.subarray(this.off, this.off + len));
+    const value = this.buf.subarray(this.off, this.off + len);
     this.off += len + 2;
     return value;
   }
 };
 function indexOfCRLF(buf, from = 0) {
-  for (let i = from; i < buf.length - 1; i++) {
-    if (buf[i] === 13 && buf[i + 1] === 10) return i;
+  let i = buf.indexOf(13, from);
+  while (i !== -1) {
+    if (i + 1 < buf.length && buf[i + 1] === 10) return i;
+    i = buf.indexOf(13, i + 1);
   }
   return -1;
 }
@@ -2454,6 +2861,8 @@ var RedisConnection = class {
   socket = null;
   parser = new RespParser();
   pending = [];
+  /** pending 头指针（避免 shift() O(n)——消费后定期 compact） */
+  pendingHead = 0;
   offlineQueue = [];
   subs = /* @__PURE__ */ new Map();
   psubs = /* @__PURE__ */ new Map();
@@ -2469,7 +2878,8 @@ var RedisConnection = class {
       port: options.port ?? 6379,
       retryDelayMs: options.retryDelayMs ?? 100,
       maxRetries: options.maxRetries ?? 10,
-      enableOfflineQueue: options.enableOfflineQueue ?? true
+      enableOfflineQueue: options.enableOfflineQueue ?? true,
+      maxOfflineQueue: options.maxOfflineQueue ?? 5e3
     };
   }
   /** 建立连接并等待 ready。重连失败（超过 maxRetries）抛 ConnectionError。 */
@@ -2519,10 +2929,10 @@ var RedisConnection = class {
     });
   }
   handleDisconnect(err) {
-    const queue = this.pending;
+    const queue = this.pending.slice(this.pendingHead);
     this.pending = [];
-    const retryErr = err instanceof ConnectionError ? err : err;
-    for (const p of queue) p.reject(retryErr);
+    this.pendingHead = 0;
+    for (const p of queue) p.reject(err);
     if (this.closed || this.status === "closed") return;
     this.retries++;
     if (this.opts.maxRetries > 0 && this.retries > this.opts.maxRetries) {
@@ -2540,38 +2950,52 @@ var RedisConnection = class {
   onData(chunk) {
     try {
       const values = this.parser.pushAll(chunk);
-      for (const value of values) {
-        if (Array.isArray(value) && typeof value[0] === "string" && PUSH_TYPES.has(value[0])) {
-          this.dispatchSubscribe(value);
+      for (const raw of values) {
+        const first = Array.isArray(raw) && raw.length > 0 ? decodeValue(raw[0], true) : void 0;
+        if (typeof first === "string" && PUSH_TYPES.has(first)) {
+          this.dispatchSubscribe(decodeValue(raw, true));
           continue;
         }
-        const p = this.pending.shift();
+        const p = this.pending[this.pendingHead++];
         if (!p) break;
-        if (value instanceof RespError) p.reject(value);
-        else p.resolve(value);
+        if (raw instanceof RespError) p.reject(raw);
+        else p.resolve(decodeValue(raw, !p.asBuffer));
+      }
+      if (this.pendingHead > 64 && this.pendingHead * 2 > this.pending.length) {
+        this.pending = this.pending.slice(this.pendingHead);
+        this.pendingHead = 0;
       }
     } catch (e) {
-      const queue = this.pending;
+      const queue = this.pending.slice(this.pendingHead);
       this.pending = [];
+      this.pendingHead = 0;
       for (const q of queue) q.reject(e);
       this.socket?.destroy();
     }
   }
-  /** 发送命令并等待响应（单连接严格有序）。未 ready 时入离线队列（enableOfflineQueue）或拒绝。 */
+  /**
+   * 发送命令并等待响应（单连接严格有序）。未 ready 时入离线队列（enableOfflineQueue）或拒绝。
+   * opts.asBuffer=true：响应保留原始字节（Uint8Array）——getBuffer 等二进制场景。
+   */
   command(name, ...args) {
+    const last = args[args.length - 1];
+    const opts = typeof last === "object" && last !== null && !(last instanceof Uint8Array) ? args.pop() : void 0;
     if (this.status === "ready" && this.socket) {
-      return this.sendNow(name, args);
+      return this.sendNow(name, args, opts?.asBuffer);
     }
     if (this.closed || this.status === "closed" || !this.opts.enableOfflineQueue) {
       return Promise.reject(new ConnectionError("redis: not connected"));
     }
+    if (this.offlineQueue.length >= this.opts.maxOfflineQueue) {
+      return Promise.reject(new ConnectionError(`redis: offline queue full (${this.opts.maxOfflineQueue})`));
+    }
     return new Promise((resolve3, reject) => {
-      this.offlineQueue.push({ name, args, resolve: resolve3, reject });
+      this.offlineQueue.push({ name, args, resolve: resolve3, reject, asBuffer: opts?.asBuffer });
     });
   }
-  sendNow(name, args) {
+  sendNow(name, args, asBuffer) {
     return new Promise((resolve3, reject) => {
-      this.pending.push({ resolve: resolve3, reject });
+      this.pending.push({ resolve: resolve3, reject, asBuffer });
       this.socket.write(encodeCommand([name, ...args]));
     });
   }
@@ -2579,7 +3003,7 @@ var RedisConnection = class {
     const queue = this.offlineQueue;
     this.offlineQueue = [];
     for (const q of queue) {
-      this.sendNow(q.name, q.args).then(q.resolve, q.reject);
+      this.sendNow(q.name, q.args, q.asBuffer).then(q.resolve, q.reject);
     }
   }
   /** 批量执行：一次 write 发送所有命令字节，响应按序路由（管道） */
@@ -2637,15 +3061,16 @@ var RedisConnection = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
-    const queue = this.pending;
+    const queue = this.pending.slice(this.pendingHead);
     this.pending = [];
+    this.pendingHead = 0;
     for (const p of queue) p.reject(new ConnectionError("redis: connection closed"));
+    const oq = this.offlineQueue;
+    this.offlineQueue = [];
+    for (const q of oq) q.reject(new ConnectionError("redis: connection closed"));
     const sock = this.socket;
     this.socket = null;
-    if (sock) {
-      sock.destroy();
-      await new Promise((r) => setTimeout(r, 0));
-    }
+    sock?.destroy();
   }
   get connected() {
     return this.status === "ready";
@@ -2664,7 +3089,7 @@ var RedisClient = class _RedisClient {
     await conn.connect();
     return new _RedisClient(conn);
   }
-  /** 底层命令透传（RESP 值） */
+  /** 底层命令透传（RESP 值）；Buffer 参数字节原样发送 */
   command(name, ...args) {
     return this.conn.command(name, ...args);
   }
@@ -2673,6 +3098,15 @@ var RedisClient = class _RedisClient {
     const v = await this.conn.command("GET", key);
     return v === null ? null : String(v);
   }
+  /**
+   * 二进制安全读取：返回原始字节（Uint8Array），不经过字符串解码。
+   * 用于缓存二进制 payload（序列化字节、图片等）。key 不存在返回 null。
+   */
+  async getBuffer(key) {
+    const v = await this.conn.command("GET", key, { asBuffer: true });
+    if (v === null) return null;
+    return v instanceof Uint8Array ? v : new TextEncoder().encode(String(v));
+  }
   /**
    * SET。ttl 秒可省略；传入即安全生效（内部转 SET key val EX ttl）。
    */
@@ -2809,6 +3243,11 @@ var RedisPool = class _RedisPool {
     await this.ensure();
     return this.next().get(this.k(key));
   }
+  /** 二进制安全读取（原始字节，不解码） */
+  async getBuffer(key) {
+    await this.ensure();
+    return this.next().getBuffer(this.k(key));
+  }
   async set(key, value, ttl) {
     await this.ensure();
     return this.next().set(this.k(key), value, ttl);
@@ -2962,6 +3401,7 @@ export {
   serverError,
   tooManyRequests,
   ui,
+  uiSsr,
   unauthorized,
   unprocessable
 };