@kevisual/cnb 0.0.12 → 0.0.14

package/dist/routes.js

@@ -1,4 +1,21 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -7,9 +24,3121 @@ var __export = (target, all) => {
       configurable: true,
       set: (newValue) => all[name] = () => newValue
     });
-};
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/.pnpm/dayjs@1.11.19/node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = __commonJS((exports, module) => {
+  (function(t, e) {
+    typeof exports == "object" && typeof module != "undefined" ? module.exports = e() : typeof define == "function" && define.amd ? define(e) : (t = typeof globalThis != "undefined" ? globalThis : t || self).dayjs = e();
+  })(exports, function() {
+    var t = 1000, e = 60000, n = 3600000, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
+      var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
+      return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+    } }, m = function(t2, e2, n2) {
+      var r2 = String(t2);
+      return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+    }, v = { s: m, z: function(t2) {
+      var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+      return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+    }, m: function t2(e2, n2) {
+      if (e2.date() < n2.date())
+        return -t2(n2, e2);
+      var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
+      return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+    }, a: function(t2) {
+      return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+    }, p: function(t2) {
+      return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+    }, u: function(t2) {
+      return t2 === undefined;
+    } }, g = "en", D = {};
+    D[g] = M;
+    var p = "$isDayjsObject", S = function(t2) {
+      return t2 instanceof _ || !(!t2 || !t2[p]);
+    }, w = function t2(e2, n2, r2) {
+      var i2;
+      if (!e2)
+        return g;
+      if (typeof e2 == "string") {
+        var s2 = e2.toLowerCase();
+        D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+        var u2 = e2.split("-");
+        if (!i2 && u2.length > 1)
+          return t2(u2[0]);
+      } else {
+        var a2 = e2.name;
+        D[a2] = e2, i2 = a2;
+      }
+      return !r2 && i2 && (g = i2), i2 || !r2 && g;
+    }, O = function(t2, e2) {
+      if (S(t2))
+        return t2.clone();
+      var n2 = typeof e2 == "object" ? e2 : {};
+      return n2.date = t2, n2.args = arguments, new _(n2);
+    }, b = v;
+    b.l = w, b.i = S, b.w = function(t2, e2) {
+      return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
+    };
+    var _ = function() {
+      function M2(t2) {
+        this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true;
+      }
+      var m2 = M2.prototype;
+      return m2.parse = function(t2) {
+        this.$d = function(t3) {
+          var { date: e2, utc: n2 } = t3;
+          if (e2 === null)
+            return new Date(NaN);
+          if (b.u(e2))
+            return new Date;
+          if (e2 instanceof Date)
+            return new Date(e2);
+          if (typeof e2 == "string" && !/Z$/i.test(e2)) {
+            var r2 = e2.match($);
+            if (r2) {
+              var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+              return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+            }
+          }
+          return new Date(e2);
+        }(t2), this.init();
+      }, m2.init = function() {
+        var t2 = this.$d;
+        this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+      }, m2.$utils = function() {
+        return b;
+      }, m2.isValid = function() {
+        return !(this.$d.toString() === l);
+      }, m2.isSame = function(t2, e2) {
+        var n2 = O(t2);
+        return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+      }, m2.isAfter = function(t2, e2) {
+        return O(t2) < this.startOf(e2);
+      }, m2.isBefore = function(t2, e2) {
+        return this.endOf(e2) < O(t2);
+      }, m2.$g = function(t2, e2, n2) {
+        return b.u(t2) ? this[e2] : this.set(n2, t2);
+      }, m2.unix = function() {
+        return Math.floor(this.valueOf() / 1000);
+      }, m2.valueOf = function() {
+        return this.$d.getTime();
+      }, m2.startOf = function(t2, e2) {
+        var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = function(t3, e3) {
+          var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+          return r2 ? i2 : i2.endOf(a);
+        }, $2 = function(t3, e3) {
+          return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
+        }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+        switch (f2) {
+          case h:
+            return r2 ? l2(1, 0) : l2(31, 11);
+          case c:
+            return r2 ? l2(1, M3) : l2(0, M3 + 1);
+          case o:
+            var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+            return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+          case a:
+          case d:
+            return $2(v2 + "Hours", 0);
+          case u:
+            return $2(v2 + "Minutes", 1);
+          case s:
+            return $2(v2 + "Seconds", 2);
+          case i:
+            return $2(v2 + "Milliseconds", 3);
+          default:
+            return this.clone();
+        }
+      }, m2.endOf = function(t2) {
+        return this.startOf(t2, false);
+      }, m2.$set = function(t2, e2) {
+        var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+        if (o2 === c || o2 === h) {
+          var y2 = this.clone().set(d, 1);
+          y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+        } else
+          l2 && this.$d[l2]($2);
+        return this.init(), this;
+      }, m2.set = function(t2, e2) {
+        return this.clone().$set(t2, e2);
+      }, m2.get = function(t2) {
+        return this[b.p(t2)]();
+      }, m2.add = function(r2, f2) {
+        var d2, l2 = this;
+        r2 = Number(r2);
+        var $2 = b.p(f2), y2 = function(t2) {
+          var e2 = O(l2);
+          return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+        };
+        if ($2 === c)
+          return this.set(c, this.$M + r2);
+        if ($2 === h)
+          return this.set(h, this.$y + r2);
+        if ($2 === a)
+          return y2(1);
+        if ($2 === o)
+          return y2(7);
+        var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+        return b.w(m3, this);
+      }, m2.subtract = function(t2, e2) {
+        return this.add(-1 * t2, e2);
+      }, m2.format = function(t2) {
+        var e2 = this, n2 = this.$locale();
+        if (!this.isValid())
+          return n2.invalidDate || l;
+        var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) {
+          return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+        }, d2 = function(t3) {
+          return b.s(s2 % 12 || 12, t3, "0");
+        }, $2 = f2 || function(t3, e3, n3) {
+          var r3 = t3 < 12 ? "AM" : "PM";
+          return n3 ? r3.toLowerCase() : r3;
+        };
+        return r2.replace(y, function(t3, r3) {
+          return r3 || function(t4) {
+            switch (t4) {
+              case "YY":
+                return String(e2.$y).slice(-2);
+              case "YYYY":
+                return b.s(e2.$y, 4, "0");
+              case "M":
+                return a2 + 1;
+              case "MM":
+                return b.s(a2 + 1, 2, "0");
+              case "MMM":
+                return h2(n2.monthsShort, a2, c2, 3);
+              case "MMMM":
+                return h2(c2, a2);
+              case "D":
+                return e2.$D;
+              case "DD":
+                return b.s(e2.$D, 2, "0");
+              case "d":
+                return String(e2.$W);
+              case "dd":
+                return h2(n2.weekdaysMin, e2.$W, o2, 2);
+              case "ddd":
+                return h2(n2.weekdaysShort, e2.$W, o2, 3);
+              case "dddd":
+                return o2[e2.$W];
+              case "H":
+                return String(s2);
+              case "HH":
+                return b.s(s2, 2, "0");
+              case "h":
+                return d2(1);
+              case "hh":
+                return d2(2);
+              case "a":
+                return $2(s2, u2, true);
+              case "A":
+                return $2(s2, u2, false);
+              case "m":
+                return String(u2);
+              case "mm":
+                return b.s(u2, 2, "0");
+              case "s":
+                return String(e2.$s);
+              case "ss":
+                return b.s(e2.$s, 2, "0");
+              case "SSS":
+                return b.s(e2.$ms, 3, "0");
+              case "Z":
+                return i2;
+            }
+            return null;
+          }(t3) || i2.replace(":", "");
+        });
+      }, m2.utcOffset = function() {
+        return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+      }, m2.diff = function(r2, d2, l2) {
+        var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() {
+          return b.m(y2, m3);
+        };
+        switch (M3) {
+          case h:
+            $2 = D2() / 12;
+            break;
+          case c:
+            $2 = D2();
+            break;
+          case f:
+            $2 = D2() / 3;
+            break;
+          case o:
+            $2 = (g2 - v2) / 604800000;
+            break;
+          case a:
+            $2 = (g2 - v2) / 86400000;
+            break;
+          case u:
+            $2 = g2 / n;
+            break;
+          case s:
+            $2 = g2 / e;
+            break;
+          case i:
+            $2 = g2 / t;
+            break;
+          default:
+            $2 = g2;
+        }
+        return l2 ? $2 : b.a($2);
+      }, m2.daysInMonth = function() {
+        return this.endOf(c).$D;
+      }, m2.$locale = function() {
+        return D[this.$L];
+      }, m2.locale = function(t2, e2) {
+        if (!t2)
+          return this.$L;
+        var n2 = this.clone(), r2 = w(t2, e2, true);
+        return r2 && (n2.$L = r2), n2;
+      }, m2.clone = function() {
+        return b.w(this.$d, this);
+      }, m2.toDate = function() {
+        return new Date(this.valueOf());
+      }, m2.toJSON = function() {
+        return this.isValid() ? this.toISOString() : null;
+      }, m2.toISOString = function() {
+        return this.$d.toISOString();
+      }, m2.toString = function() {
+        return this.$d.toUTCString();
+      }, M2;
+    }(), k = _.prototype;
+    return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) {
+      k[t2[1]] = function(e2) {
+        return this.$g(e2, t2[0], t2[1]);
+      };
+    }), O.extend = function(t2, e2) {
+      return t2.$i || (t2(e2, _, O), t2.$i = true), O;
+    }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
+      return O(1000 * t2);
+    }, O.en = D[g], O.Ls = D, O.p = {}, O;
+  });
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/constants.js
+var require_constants = __commonJS((exports, module) => {
+  var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+  var hasBlob = typeof Blob !== "undefined";
+  if (hasBlob)
+    BINARY_TYPES.push("blob");
+  module.exports = {
+    BINARY_TYPES,
+    CLOSE_TIMEOUT: 30000,
+    EMPTY_BUFFER: Buffer.alloc(0),
+    GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+    hasBlob,
+    kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+    kListener: Symbol("kListener"),
+    kStatusCode: Symbol("status-code"),
+    kWebSocket: Symbol("websocket"),
+    NOOP: () => {}
+  };
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/buffer-util.js
+var require_buffer_util = __commonJS((exports, module) => {
+  var { EMPTY_BUFFER } = require_constants();
+  var FastBuffer = Buffer[Symbol.species];
+  function concat(list, totalLength) {
+    if (list.length === 0)
+      return EMPTY_BUFFER;
+    if (list.length === 1)
+      return list[0];
+    const target = Buffer.allocUnsafe(totalLength);
+    let offset = 0;
+    for (let i = 0;i < list.length; i++) {
+      const buf = list[i];
+      target.set(buf, offset);
+      offset += buf.length;
+    }
+    if (offset < totalLength) {
+      return new FastBuffer(target.buffer, target.byteOffset, offset);
+    }
+    return target;
+  }
+  function _mask(source, mask, output, offset, length) {
+    for (let i = 0;i < length; i++) {
+      output[offset + i] = source[i] ^ mask[i & 3];
+    }
+  }
+  function _unmask(buffer, mask) {
+    for (let i = 0;i < buffer.length; i++) {
+      buffer[i] ^= mask[i & 3];
+    }
+  }
+  function toArrayBuffer(buf) {
+    if (buf.length === buf.buffer.byteLength) {
+      return buf.buffer;
+    }
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+  }
+  function toBuffer(data) {
+    toBuffer.readOnly = true;
+    if (Buffer.isBuffer(data))
+      return data;
+    let buf;
+    if (data instanceof ArrayBuffer) {
+      buf = new FastBuffer(data);
+    } else if (ArrayBuffer.isView(data)) {
+      buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      buf = Buffer.from(data);
+      toBuffer.readOnly = false;
+    }
+    return buf;
+  }
+  module.exports = {
+    concat,
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask
+  };
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/limiter.js
+var require_limiter = __commonJS((exports, module) => {
+  var kDone = Symbol("kDone");
+  var kRun = Symbol("kRun");
+
+  class Limiter {
+    constructor(concurrency) {
+      this[kDone] = () => {
+        this.pending--;
+        this[kRun]();
+      };
+      this.concurrency = concurrency || Infinity;
+      this.jobs = [];
+      this.pending = 0;
+    }
+    add(job) {
+      this.jobs.push(job);
+      this[kRun]();
+    }
+    [kRun]() {
+      if (this.pending === this.concurrency)
+        return;
+      if (this.jobs.length) {
+        const job = this.jobs.shift();
+        this.pending++;
+        job(this[kDone]);
+      }
+    }
+  }
+  module.exports = Limiter;
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/permessage-deflate.js
+var require_permessage_deflate = __commonJS((exports, module) => {
+  var zlib = __require("zlib");
+  var bufferUtil2 = require_buffer_util();
+  var Limiter = require_limiter();
+  var { kStatusCode } = require_constants();
+  var FastBuffer = Buffer[Symbol.species];
+  var TRAILER = Buffer.from([0, 0, 255, 255]);
+  var kPerMessageDeflate = Symbol("permessage-deflate");
+  var kTotalLength = Symbol("total-length");
+  var kCallback = Symbol("callback");
+  var kBuffers = Symbol("buffers");
+  var kError = Symbol("error");
+  var zlibLimiter;
+
+  class PerMessageDeflate {
+    constructor(options, isServer, maxPayload) {
+      this._maxPayload = maxPayload | 0;
+      this._options = options || {};
+      this._threshold = this._options.threshold !== undefined ? this._options.threshold : 1024;
+      this._isServer = !!isServer;
+      this._deflate = null;
+      this._inflate = null;
+      this.params = null;
+      if (!zlibLimiter) {
+        const concurrency = this._options.concurrencyLimit !== undefined ? this._options.concurrencyLimit : 10;
+        zlibLimiter = new Limiter(concurrency);
+      }
+    }
+    static get extensionName() {
+      return "permessage-deflate";
+    }
+    offer() {
+      const params = {};
+      if (this._options.serverNoContextTakeover) {
+        params.server_no_context_takeover = true;
+      }
+      if (this._options.clientNoContextTakeover) {
+        params.client_no_context_takeover = true;
+      }
+      if (this._options.serverMaxWindowBits) {
+        params.server_max_window_bits = this._options.serverMaxWindowBits;
+      }
+      if (this._options.clientMaxWindowBits) {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      } else if (this._options.clientMaxWindowBits == null) {
+        params.client_max_window_bits = true;
+      }
+      return params;
+    }
+    accept(configurations) {
+      configurations = this.normalizeParams(configurations);
+      this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+      return this.params;
+    }
+    cleanup() {
+      if (this._inflate) {
+        this._inflate.close();
+        this._inflate = null;
+      }
+      if (this._deflate) {
+        const callback = this._deflate[kCallback];
+        this._deflate.close();
+        this._deflate = null;
+        if (callback) {
+          callback(new Error("The deflate stream was closed while data was being processed"));
+        }
+      }
+    }
+    acceptAsServer(offers) {
+      const opts = this._options;
+      const accepted = offers.find((params) => {
+        if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
+          return false;
+        }
+        return true;
+      });
+      if (!accepted) {
+        throw new Error("None of the extension offers can be accepted");
+      }
+      if (opts.serverNoContextTakeover) {
+        accepted.server_no_context_takeover = true;
+      }
+      if (opts.clientNoContextTakeover) {
+        accepted.client_no_context_takeover = true;
+      }
+      if (typeof opts.serverMaxWindowBits === "number") {
+        accepted.server_max_window_bits = opts.serverMaxWindowBits;
+      }
+      if (typeof opts.clientMaxWindowBits === "number") {
+        accepted.client_max_window_bits = opts.clientMaxWindowBits;
+      } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
+        delete accepted.client_max_window_bits;
+      }
+      return accepted;
+    }
+    acceptAsClient(response) {
+      const params = response[0];
+      if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
+        throw new Error('Unexpected parameter "client_no_context_takeover"');
+      }
+      if (!params.client_max_window_bits) {
+        if (typeof this._options.clientMaxWindowBits === "number") {
+          params.client_max_window_bits = this._options.clientMaxWindowBits;
+        }
+      } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
+        throw new Error('Unexpected or invalid parameter "client_max_window_bits"');
+      }
+      return params;
+    }
+    normalizeParams(configurations) {
+      configurations.forEach((params) => {
+        Object.keys(params).forEach((key) => {
+          let value = params[key];
+          if (value.length > 1) {
+            throw new Error(`Parameter "${key}" must have only a single value`);
+          }
+          value = value[0];
+          if (key === "client_max_window_bits") {
+            if (value !== true) {
+              const num = +value;
+              if (!Number.isInteger(num) || num < 8 || num > 15) {
+                throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+              }
+              value = num;
+            } else if (!this._isServer) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+          } else if (key === "server_max_window_bits") {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+            value = num;
+          } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
+            if (value !== true) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+          } else {
+            throw new Error(`Unknown parameter "${key}"`);
+          }
+          params[key] = value;
+        });
+      });
+      return configurations;
+    }
+    decompress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._decompress(data, fin, (err, result) => {
+          done();
+          callback(err, result);
+        });
+      });
+    }
+    compress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._compress(data, fin, (err, result) => {
+          done();
+          callback(err, result);
+        });
+      });
+    }
+    _decompress(data, fin, callback) {
+      const endpoint = this._isServer ? "client" : "server";
+      if (!this._inflate) {
+        const key = `${endpoint}_max_window_bits`;
+        const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+        this._inflate = zlib.createInflateRaw({
+          ...this._options.zlibInflateOptions,
+          windowBits
+        });
+        this._inflate[kPerMessageDeflate] = this;
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+        this._inflate.on("error", inflateOnError);
+        this._inflate.on("data", inflateOnData);
+      }
+      this._inflate[kCallback] = callback;
+      this._inflate.write(data);
+      if (fin)
+        this._inflate.write(TRAILER);
+      this._inflate.flush(() => {
+        const err = this._inflate[kError];
+        if (err) {
+          this._inflate.close();
+          this._inflate = null;
+          callback(err);
+          return;
+        }
+        const data2 = bufferUtil2.concat(this._inflate[kBuffers], this._inflate[kTotalLength]);
+        if (this._inflate._readableState.endEmitted) {
+          this._inflate.close();
+          this._inflate = null;
+        } else {
+          this._inflate[kTotalLength] = 0;
+          this._inflate[kBuffers] = [];
+          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+            this._inflate.reset();
+          }
+        }
+        callback(null, data2);
+      });
+    }
+    _compress(data, fin, callback) {
+      const endpoint = this._isServer ? "server" : "client";
+      if (!this._deflate) {
+        const key = `${endpoint}_max_window_bits`;
+        const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+        this._deflate = zlib.createDeflateRaw({
+          ...this._options.zlibDeflateOptions,
+          windowBits
+        });
+        this._deflate[kTotalLength] = 0;
+        this._deflate[kBuffers] = [];
+        this._deflate.on("data", deflateOnData);
+      }
+      this._deflate[kCallback] = callback;
+      this._deflate.write(data);
+      this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+        if (!this._deflate) {
+          return;
+        }
+        let data2 = bufferUtil2.concat(this._deflate[kBuffers], this._deflate[kTotalLength]);
+        if (fin) {
+          data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
+        }
+        this._deflate[kCallback] = null;
+        this._deflate[kTotalLength] = 0;
+        this._deflate[kBuffers] = [];
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._deflate.reset();
+        }
+        callback(null, data2);
+      });
+    }
+  }
+  module.exports = PerMessageDeflate;
+  function deflateOnData(chunk) {
+    this[kBuffers].push(chunk);
+    this[kTotalLength] += chunk.length;
+  }
+  function inflateOnData(chunk) {
+    this[kTotalLength] += chunk.length;
+    if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
+      this[kBuffers].push(chunk);
+      return;
+    }
+    this[kError] = new RangeError("Max payload size exceeded");
+    this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+    this[kError][kStatusCode] = 1009;
+    this.removeListener("data", inflateOnData);
+    this.reset();
+  }
+  function inflateOnError(err) {
+    this[kPerMessageDeflate]._inflate = null;
+    if (this[kError]) {
+      this[kCallback](this[kError]);
+      return;
+    }
+    err[kStatusCode] = 1007;
+    this[kCallback](err);
+  }
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/validation.js
+var require_validation = __commonJS((exports, module) => {
+  var { isUtf8 } = __require("buffer");
+  var { hasBlob } = require_constants();
+  var tokenChars = [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    1,
+    0,
+    1,
+    0
+  ];
+  function isValidStatusCode(code) {
+    return code >= 1000 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3000 && code <= 4999;
+  }
+  function _isValidUTF8(buf) {
+    const len = buf.length;
+    let i = 0;
+    while (i < len) {
+      if ((buf[i] & 128) === 0) {
+        i++;
+      } else if ((buf[i] & 224) === 192) {
+        if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
+          return false;
+        }
+        i += 2;
+      } else if ((buf[i] & 240) === 224) {
+        if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) {
+          return false;
+        }
+        i += 3;
+      } else if ((buf[i] & 248) === 240) {
+        if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
+          return false;
+        }
+        i += 4;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  function isBlob(value) {
+    return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
+  }
+  module.exports = {
+    isBlob,
+    isValidStatusCode,
+    isValidUTF8: _isValidUTF8,
+    tokenChars
+  };
+  if (isUtf8) {
+    module.exports.isValidUTF8 = function(buf) {
+      return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+    };
+  }
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/receiver.js
+var require_receiver = __commonJS((exports, module) => {
+  var { Writable } = __require("stream");
+  var PerMessageDeflate = require_permessage_deflate();
+  var {
+    BINARY_TYPES,
+    EMPTY_BUFFER,
+    kStatusCode,
+    kWebSocket
+  } = require_constants();
+  var { concat, toArrayBuffer, unmask } = require_buffer_util();
+  var { isValidStatusCode, isValidUTF8 } = require_validation();
+  var FastBuffer = Buffer[Symbol.species];
+  var GET_INFO = 0;
+  var GET_PAYLOAD_LENGTH_16 = 1;
+  var GET_PAYLOAD_LENGTH_64 = 2;
+  var GET_MASK = 3;
+  var GET_DATA = 4;
+  var INFLATING = 5;
+  var DEFER_EVENT = 6;
+
+  class Receiver extends Writable {
+    constructor(options = {}) {
+      super();
+      this._allowSynchronousEvents = options.allowSynchronousEvents !== undefined ? options.allowSynchronousEvents : true;
+      this._binaryType = options.binaryType || BINARY_TYPES[0];
+      this._extensions = options.extensions || {};
+      this._isServer = !!options.isServer;
+      this._maxPayload = options.maxPayload | 0;
+      this._skipUTF8Validation = !!options.skipUTF8Validation;
+      this[kWebSocket] = undefined;
+      this._bufferedBytes = 0;
+      this._buffers = [];
+      this._compressed = false;
+      this._payloadLength = 0;
+      this._mask = undefined;
+      this._fragmented = 0;
+      this._masked = false;
+      this._fin = false;
+      this._opcode = 0;
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragments = [];
+      this._errored = false;
+      this._loop = false;
+      this._state = GET_INFO;
+    }
+    _write(chunk, encoding, cb) {
+      if (this._opcode === 8 && this._state == GET_INFO)
+        return cb();
+      this._bufferedBytes += chunk.length;
+      this._buffers.push(chunk);
+      this.startLoop(cb);
+    }
+    consume(n) {
+      this._bufferedBytes -= n;
+      if (n === this._buffers[0].length)
+        return this._buffers.shift();
+      if (n < this._buffers[0].length) {
+        const buf = this._buffers[0];
+        this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
+        return new FastBuffer(buf.buffer, buf.byteOffset, n);
+      }
+      const dst = Buffer.allocUnsafe(n);
+      do {
+        const buf = this._buffers[0];
+        const offset = dst.length - n;
+        if (n >= buf.length) {
+          dst.set(this._buffers.shift(), offset);
+        } else {
+          dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+          this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
+        }
+        n -= buf.length;
+      } while (n > 0);
+      return dst;
+    }
+    startLoop(cb) {
+      this._loop = true;
+      do {
+        switch (this._state) {
+          case GET_INFO:
+            this.getInfo(cb);
+            break;
+          case GET_PAYLOAD_LENGTH_16:
+            this.getPayloadLength16(cb);
+            break;
+          case GET_PAYLOAD_LENGTH_64:
+            this.getPayloadLength64(cb);
+            break;
+          case GET_MASK:
+            this.getMask();
+            break;
+          case GET_DATA:
+            this.getData(cb);
+            break;
+          case INFLATING:
+          case DEFER_EVENT:
+            this._loop = false;
+            return;
+        }
+      } while (this._loop);
+      if (!this._errored)
+        cb();
+    }
+    getInfo(cb) {
+      if (this._bufferedBytes < 2) {
+        this._loop = false;
+        return;
+      }
+      const buf = this.consume(2);
+      if ((buf[0] & 48) !== 0) {
+        const error49 = this.createError(RangeError, "RSV2 and RSV3 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_2_3");
+        cb(error49);
+        return;
+      }
+      const compressed = (buf[0] & 64) === 64;
+      if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+        const error49 = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+        cb(error49);
+        return;
+      }
+      this._fin = (buf[0] & 128) === 128;
+      this._opcode = buf[0] & 15;
+      this._payloadLength = buf[1] & 127;
+      if (this._opcode === 0) {
+        if (compressed) {
+          const error49 = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+          cb(error49);
+          return;
+        }
+        if (!this._fragmented) {
+          const error49 = this.createError(RangeError, "invalid opcode 0", true, 1002, "WS_ERR_INVALID_OPCODE");
+          cb(error49);
+          return;
+        }
+        this._opcode = this._fragmented;
+      } else if (this._opcode === 1 || this._opcode === 2) {
+        if (this._fragmented) {
+          const error49 = this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+          cb(error49);
+          return;
+        }
+        this._compressed = compressed;
+      } else if (this._opcode > 7 && this._opcode < 11) {
+        if (!this._fin) {
+          const error49 = this.createError(RangeError, "FIN must be set", true, 1002, "WS_ERR_EXPECTED_FIN");
+          cb(error49);
+          return;
+        }
+        if (compressed) {
+          const error49 = this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+          cb(error49);
+          return;
+        }
+        if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+          const error49 = this.createError(RangeError, `invalid payload length ${this._payloadLength}`, true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");
+          cb(error49);
+          return;
+        }
+      } else {
+        const error49 = this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+        cb(error49);
+        return;
+      }
+      if (!this._fin && !this._fragmented)
+        this._fragmented = this._opcode;
+      this._masked = (buf[1] & 128) === 128;
+      if (this._isServer) {
+        if (!this._masked) {
+          const error49 = this.createError(RangeError, "MASK must be set", true, 1002, "WS_ERR_EXPECTED_MASK");
+          cb(error49);
+          return;
+        }
+      } else if (this._masked) {
+        const error49 = this.createError(RangeError, "MASK must be clear", true, 1002, "WS_ERR_UNEXPECTED_MASK");
+        cb(error49);
+        return;
+      }
+      if (this._payloadLength === 126)
+        this._state = GET_PAYLOAD_LENGTH_16;
+      else if (this._payloadLength === 127)
+        this._state = GET_PAYLOAD_LENGTH_64;
+      else
+        this.haveLength(cb);
+    }
+    getPayloadLength16(cb) {
+      if (this._bufferedBytes < 2) {
+        this._loop = false;
+        return;
+      }
+      this._payloadLength = this.consume(2).readUInt16BE(0);
+      this.haveLength(cb);
+    }
+    getPayloadLength64(cb) {
+      if (this._bufferedBytes < 8) {
+        this._loop = false;
+        return;
+      }
+      const buf = this.consume(8);
+      const num = buf.readUInt32BE(0);
+      if (num > Math.pow(2, 53 - 32) - 1) {
+        const error49 = this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", false, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH");
+        cb(error49);
+        return;
+      }
+      this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+      this.haveLength(cb);
+    }
+    haveLength(cb) {
+      if (this._payloadLength && this._opcode < 8) {
+        this._totalPayloadLength += this._payloadLength;
+        if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+          const error49 = this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+          cb(error49);
+          return;
+        }
+      }
+      if (this._masked)
+        this._state = GET_MASK;
+      else
+        this._state = GET_DATA;
+    }
+    getMask() {
+      if (this._bufferedBytes < 4) {
+        this._loop = false;
+        return;
+      }
+      this._mask = this.consume(4);
+      this._state = GET_DATA;
+    }
+    getData(cb) {
+      let data = EMPTY_BUFFER;
+      if (this._payloadLength) {
+        if (this._bufferedBytes < this._payloadLength) {
+          this._loop = false;
+          return;
+        }
+        data = this.consume(this._payloadLength);
+        if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
+          unmask(data, this._mask);
+        }
+      }
+      if (this._opcode > 7) {
+        this.controlMessage(data, cb);
+        return;
+      }
+      if (this._compressed) {
+        this._state = INFLATING;
+        this.decompress(data, cb);
+        return;
+      }
+      if (data.length) {
+        this._messageLength = this._totalPayloadLength;
+        this._fragments.push(data);
+      }
+      this.dataMessage(cb);
+    }
+    decompress(data, cb) {
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+        if (err)
+          return cb(err);
+        if (buf.length) {
+          this._messageLength += buf.length;
+          if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+            const error49 = this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+            cb(error49);
+            return;
+          }
+          this._fragments.push(buf);
+        }
+        this.dataMessage(cb);
+        if (this._state === GET_INFO)
+          this.startLoop(cb);
+      });
+    }
+    dataMessage(cb) {
+      if (!this._fin) {
+        this._state = GET_INFO;
+        return;
+      }
+      const messageLength = this._messageLength;
+      const fragments = this._fragments;
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragmented = 0;
+      this._fragments = [];
+      if (this._opcode === 2) {
+        let data;
+        if (this._binaryType === "nodebuffer") {
+          data = concat(fragments, messageLength);
+        } else if (this._binaryType === "arraybuffer") {
+          data = toArrayBuffer(concat(fragments, messageLength));
+        } else if (this._binaryType === "blob") {
+          data = new Blob(fragments);
+        } else {
+          data = fragments;
+        }
+        if (this._allowSynchronousEvents) {
+          this.emit("message", data, true);
+          this._state = GET_INFO;
+        } else {
+          this._state = DEFER_EVENT;
+          setImmediate(() => {
+            this.emit("message", data, true);
+            this._state = GET_INFO;
+            this.startLoop(cb);
+          });
+        }
+      } else {
+        const buf = concat(fragments, messageLength);
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          const error49 = this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+          cb(error49);
+          return;
+        }
+        if (this._state === INFLATING || this._allowSynchronousEvents) {
+          this.emit("message", buf, false);
+          this._state = GET_INFO;
+        } else {
+          this._state = DEFER_EVENT;
+          setImmediate(() => {
+            this.emit("message", buf, false);
+            this._state = GET_INFO;
+            this.startLoop(cb);
+          });
+        }
+      }
+    }
+    controlMessage(data, cb) {
+      if (this._opcode === 8) {
+        if (data.length === 0) {
+          this._loop = false;
+          this.emit("conclude", 1005, EMPTY_BUFFER);
+          this.end();
+        } else {
+          const code = data.readUInt16BE(0);
+          if (!isValidStatusCode(code)) {
+            const error49 = this.createError(RangeError, `invalid status code ${code}`, true, 1002, "WS_ERR_INVALID_CLOSE_CODE");
+            cb(error49);
+            return;
+          }
+          const buf = new FastBuffer(data.buffer, data.byteOffset + 2, data.length - 2);
+          if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+            const error49 = this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+            cb(error49);
+            return;
+          }
+          this._loop = false;
+          this.emit("conclude", code, buf);
+          this.end();
+        }
+        this._state = GET_INFO;
+        return;
+      }
+      if (this._allowSynchronousEvents) {
+        this.emit(this._opcode === 9 ? "ping" : "pong", data);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit(this._opcode === 9 ? "ping" : "pong", data);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    }
+    createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+      this._loop = false;
+      this._errored = true;
+      const err = new ErrorCtor(prefix ? `Invalid WebSocket frame: ${message}` : message);
+      Error.captureStackTrace(err, this.createError);
+      err.code = errorCode;
+      err[kStatusCode] = statusCode;
+      return err;
+    }
+  }
+  module.exports = Receiver;
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/sender.js
+var require_sender = __commonJS((exports, module) => {
+  var { Duplex } = __require("stream");
+  var { randomFillSync } = __require("crypto");
+  var PerMessageDeflate = require_permessage_deflate();
+  var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
+  var { isBlob, isValidStatusCode } = require_validation();
+  var { mask: applyMask, toBuffer } = require_buffer_util();
+  var kByteLength = Symbol("kByteLength");
+  var maskBuffer = Buffer.alloc(4);
+  var RANDOM_POOL_SIZE = 8 * 1024;
+  var randomPool;
+  var randomPoolPointer = RANDOM_POOL_SIZE;
+  var DEFAULT = 0;
+  var DEFLATING = 1;
+  var GET_BLOB_DATA = 2;
+
+  class Sender {
+    constructor(socket, extensions, generateMask) {
+      this._extensions = extensions || {};
+      if (generateMask) {
+        this._generateMask = generateMask;
+        this._maskBuffer = Buffer.alloc(4);
+      }
+      this._socket = socket;
+      this._firstFragment = true;
+      this._compress = false;
+      this._bufferedBytes = 0;
+      this._queue = [];
+      this._state = DEFAULT;
+      this.onerror = NOOP;
+      this[kWebSocket] = undefined;
+    }
+    static frame(data, options) {
+      let mask;
+      let merge3 = false;
+      let offset = 2;
+      let skipMasking = false;
+      if (options.mask) {
+        mask = options.maskBuffer || maskBuffer;
+        if (options.generateMask) {
+          options.generateMask(mask);
+        } else {
+          if (randomPoolPointer === RANDOM_POOL_SIZE) {
+            if (randomPool === undefined) {
+              randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+            }
+            randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+            randomPoolPointer = 0;
+          }
+          mask[0] = randomPool[randomPoolPointer++];
+          mask[1] = randomPool[randomPoolPointer++];
+          mask[2] = randomPool[randomPoolPointer++];
+          mask[3] = randomPool[randomPoolPointer++];
+        }
+        skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+        offset = 6;
+      }
+      let dataLength;
+      if (typeof data === "string") {
+        if ((!options.mask || skipMasking) && options[kByteLength] !== undefined) {
+          dataLength = options[kByteLength];
+        } else {
+          data = Buffer.from(data);
+          dataLength = data.length;
+        }
+      } else {
+        dataLength = data.length;
+        merge3 = options.mask && options.readOnly && !skipMasking;
+      }
+      let payloadLength = dataLength;
+      if (dataLength >= 65536) {
+        offset += 8;
+        payloadLength = 127;
+      } else if (dataLength > 125) {
+        offset += 2;
+        payloadLength = 126;
+      }
+      const target = Buffer.allocUnsafe(merge3 ? dataLength + offset : offset);
+      target[0] = options.fin ? options.opcode | 128 : options.opcode;
+      if (options.rsv1)
+        target[0] |= 64;
+      target[1] = payloadLength;
+      if (payloadLength === 126) {
+        target.writeUInt16BE(dataLength, 2);
+      } else if (payloadLength === 127) {
+        target[2] = target[3] = 0;
+        target.writeUIntBE(dataLength, 4, 6);
+      }
+      if (!options.mask)
+        return [target, data];
+      target[1] |= 128;
+      target[offset - 4] = mask[0];
+      target[offset - 3] = mask[1];
+      target[offset - 2] = mask[2];
+      target[offset - 1] = mask[3];
+      if (skipMasking)
+        return [target, data];
+      if (merge3) {
+        applyMask(data, mask, target, offset, dataLength);
+        return [target];
+      }
+      applyMask(data, mask, data, 0, dataLength);
+      return [target, data];
+    }
+    close(code, data, mask, cb) {
+      let buf;
+      if (code === undefined) {
+        buf = EMPTY_BUFFER;
+      } else if (typeof code !== "number" || !isValidStatusCode(code)) {
+        throw new TypeError("First argument must be a valid error code number");
+      } else if (data === undefined || !data.length) {
+        buf = Buffer.allocUnsafe(2);
+        buf.writeUInt16BE(code, 0);
+      } else {
+        const length = Buffer.byteLength(data);
+        if (length > 123) {
+          throw new RangeError("The message must not be greater than 123 bytes");
+        }
+        buf = Buffer.allocUnsafe(2 + length);
+        buf.writeUInt16BE(code, 0);
+        if (typeof data === "string") {
+          buf.write(data, 2);
+        } else {
+          buf.set(data, 2);
+        }
+      }
+      const options = {
+        [kByteLength]: buf.length,
+        fin: true,
+        generateMask: this._generateMask,
+        mask,
+        maskBuffer: this._maskBuffer,
+        opcode: 8,
+        readOnly: false,
+        rsv1: false
+      };
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, buf, false, options, cb]);
+      } else {
+        this.sendFrame(Sender.frame(buf, options), cb);
+      }
+    }
+    ping(data, mask, cb) {
+      let byteLength;
+      let readOnly;
+      if (typeof data === "string") {
+        byteLength = Buffer.byteLength(data);
+        readOnly = false;
+      } else if (isBlob(data)) {
+        byteLength = data.size;
+        readOnly = false;
+      } else {
+        data = toBuffer(data);
+        byteLength = data.length;
+        readOnly = toBuffer.readOnly;
+      }
+      if (byteLength > 125) {
+        throw new RangeError("The data size must not be greater than 125 bytes");
+      }
+      const options = {
+        [kByteLength]: byteLength,
+        fin: true,
+        generateMask: this._generateMask,
+        mask,
+        maskBuffer: this._maskBuffer,
+        opcode: 9,
+        readOnly,
+        rsv1: false
+      };
+      if (isBlob(data)) {
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.getBlobData, data, false, options, cb]);
+        } else {
+          this.getBlobData(data, false, options, cb);
+        }
+      } else if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, data, false, options, cb]);
+      } else {
+        this.sendFrame(Sender.frame(data, options), cb);
+      }
+    }
+    pong(data, mask, cb) {
+      let byteLength;
+      let readOnly;
+      if (typeof data === "string") {
+        byteLength = Buffer.byteLength(data);
+        readOnly = false;
+      } else if (isBlob(data)) {
+        byteLength = data.size;
+        readOnly = false;
+      } else {
+        data = toBuffer(data);
+        byteLength = data.length;
+        readOnly = toBuffer.readOnly;
+      }
+      if (byteLength > 125) {
+        throw new RangeError("The data size must not be greater than 125 bytes");
+      }
+      const options = {
+        [kByteLength]: byteLength,
+        fin: true,
+        generateMask: this._generateMask,
+        mask,
+        maskBuffer: this._maskBuffer,
+        opcode: 10,
+        readOnly,
+        rsv1: false
+      };
+      if (isBlob(data)) {
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.getBlobData, data, false, options, cb]);
+        } else {
+          this.getBlobData(data, false, options, cb);
+        }
+      } else if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, data, false, options, cb]);
+      } else {
+        this.sendFrame(Sender.frame(data, options), cb);
+      }
+    }
+    send(data, options, cb) {
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      let opcode = options.binary ? 2 : 1;
+      let rsv1 = options.compress;
+      let byteLength;
+      let readOnly;
+      if (typeof data === "string") {
+        byteLength = Buffer.byteLength(data);
+        readOnly = false;
+      } else if (isBlob(data)) {
+        byteLength = data.size;
+        readOnly = false;
+      } else {
+        data = toBuffer(data);
+        byteLength = data.length;
+        readOnly = toBuffer.readOnly;
+      }
+      if (this._firstFragment) {
+        this._firstFragment = false;
+        if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
+          rsv1 = byteLength >= perMessageDeflate._threshold;
+        }
+        this._compress = rsv1;
+      } else {
+        rsv1 = false;
+        opcode = 0;
+      }
+      if (options.fin)
+        this._firstFragment = true;
+      const opts = {
+        [kByteLength]: byteLength,
+        fin: options.fin,
+        generateMask: this._generateMask,
+        mask: options.mask,
+        maskBuffer: this._maskBuffer,
+        opcode,
+        readOnly,
+        rsv1
+      };
+      if (isBlob(data)) {
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
+        } else {
+          this.getBlobData(data, this._compress, opts, cb);
+        }
+      } else if (this._state !== DEFAULT) {
+        this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+      } else {
+        this.dispatch(data, this._compress, opts, cb);
+      }
+    }
+    getBlobData(blob, compress, options, cb) {
+      this._bufferedBytes += options[kByteLength];
+      this._state = GET_BLOB_DATA;
+      blob.arrayBuffer().then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error("The socket was closed while the blob was being read");
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer(arrayBuffer);
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      }).catch((err) => {
+        process.nextTick(onError, this, err, cb);
+      });
+    }
+    dispatch(data, compress, options, cb) {
+      if (!compress) {
+        this.sendFrame(Sender.frame(data, options), cb);
+        return;
+      }
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      this._bufferedBytes += options[kByteLength];
+      this._state = DEFLATING;
+      perMessageDeflate.compress(data, options.fin, (_, buf) => {
+        if (this._socket.destroyed) {
+          const err = new Error("The socket was closed while data was being compressed");
+          callCallbacks(this, err, cb);
+          return;
+        }
+        this._bufferedBytes -= options[kByteLength];
+        this._state = DEFAULT;
+        options.readOnly = false;
+        this.sendFrame(Sender.frame(buf, options), cb);
+        this.dequeue();
+      });
+    }
+    dequeue() {
+      while (this._state === DEFAULT && this._queue.length) {
+        const params = this._queue.shift();
+        this._bufferedBytes -= params[3][kByteLength];
+        Reflect.apply(params[0], this, params.slice(1));
+      }
+    }
+    enqueue(params) {
+      this._bufferedBytes += params[3][kByteLength];
+      this._queue.push(params);
+    }
+    sendFrame(list, cb) {
+      if (list.length === 2) {
+        this._socket.cork();
+        this._socket.write(list[0]);
+        this._socket.write(list[1], cb);
+        this._socket.uncork();
+      } else {
+        this._socket.write(list[0], cb);
+      }
+    }
+  }
+  module.exports = Sender;
+  function callCallbacks(sender2, err, cb) {
+    if (typeof cb === "function")
+      cb(err);
+    for (let i = 0;i < sender2._queue.length; i++) {
+      const params = sender2._queue[i];
+      const callback = params[params.length - 1];
+      if (typeof callback === "function")
+        callback(err);
+    }
+  }
+  function onError(sender2, err, cb) {
+    callCallbacks(sender2, err, cb);
+    sender2.onerror(err);
+  }
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/event-target.js
+var require_event_target = __commonJS((exports, module) => {
+  var { kForOnEventAttribute, kListener } = require_constants();
+  var kCode = Symbol("kCode");
+  var kData = Symbol("kData");
+  var kError = Symbol("kError");
+  var kMessage = Symbol("kMessage");
+  var kReason = Symbol("kReason");
+  var kTarget = Symbol("kTarget");
+  var kType = Symbol("kType");
+  var kWasClean = Symbol("kWasClean");
+
+  class Event {
+    constructor(type) {
+      this[kTarget] = null;
+      this[kType] = type;
+    }
+    get target() {
+      return this[kTarget];
+    }
+    get type() {
+      return this[kType];
+    }
+  }
+  Object.defineProperty(Event.prototype, "target", { enumerable: true });
+  Object.defineProperty(Event.prototype, "type", { enumerable: true });
+
+  class CloseEvent extends Event {
+    constructor(type, options = {}) {
+      super(type);
+      this[kCode] = options.code === undefined ? 0 : options.code;
+      this[kReason] = options.reason === undefined ? "" : options.reason;
+      this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+    }
+    get code() {
+      return this[kCode];
+    }
+    get reason() {
+      return this[kReason];
+    }
+    get wasClean() {
+      return this[kWasClean];
+    }
+  }
+  Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
+  Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
+  Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
+
+  class ErrorEvent extends Event {
+    constructor(type, options = {}) {
+      super(type);
+      this[kError] = options.error === undefined ? null : options.error;
+      this[kMessage] = options.message === undefined ? "" : options.message;
+    }
+    get error() {
+      return this[kError];
+    }
+    get message() {
+      return this[kMessage];
+    }
+  }
+  Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
+  Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
+
+  class MessageEvent extends Event {
+    constructor(type, options = {}) {
+      super(type);
+      this[kData] = options.data === undefined ? null : options.data;
+    }
+    get data() {
+      return this[kData];
+    }
+  }
+  Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
+  var EventTarget = {
+    addEventListener(type, handler, options = {}) {
+      for (const listener of this.listeners(type)) {
+        if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+          return;
+        }
+      }
+      let wrapper;
+      if (type === "message") {
+        wrapper = function onMessage(data, isBinary) {
+          const event = new MessageEvent("message", {
+            data: isBinary ? data : data.toString()
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "close") {
+        wrapper = function onClose(code, message) {
+          const event = new CloseEvent("close", {
+            code,
+            reason: message.toString(),
+            wasClean: this._closeFrameReceived && this._closeFrameSent
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "error") {
+        wrapper = function onError(error49) {
+          const event = new ErrorEvent("error", {
+            error: error49,
+            message: error49.message
+          });
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else if (type === "open") {
+        wrapper = function onOpen() {
+          const event = new Event("open");
+          event[kTarget] = this;
+          callListener(handler, this, event);
+        };
+      } else {
+        return;
+      }
+      wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+      wrapper[kListener] = handler;
+      if (options.once) {
+        this.once(type, wrapper);
+      } else {
+        this.on(type, wrapper);
+      }
+    },
+    removeEventListener(type, handler) {
+      for (const listener of this.listeners(type)) {
+        if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+          this.removeListener(type, listener);
+          break;
+        }
+      }
+    }
+  };
+  module.exports = {
+    CloseEvent,
+    ErrorEvent,
+    Event,
+    EventTarget,
+    MessageEvent
+  };
+  function callListener(listener, thisArg, event) {
+    if (typeof listener === "object" && listener.handleEvent) {
+      listener.handleEvent.call(listener, event);
+    } else {
+      listener.call(thisArg, event);
+    }
+  }
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/extension.js
+var require_extension = __commonJS((exports, module) => {
+  var { tokenChars } = require_validation();
+  function push(dest, name, elem) {
+    if (dest[name] === undefined)
+      dest[name] = [elem];
+    else
+      dest[name].push(elem);
+  }
+  function parse6(header) {
+    const offers = Object.create(null);
+    let params = Object.create(null);
+    let mustUnescape = false;
+    let isEscaping = false;
+    let inQuotes = false;
+    let extensionName;
+    let paramName;
+    let start = -1;
+    let code = -1;
+    let end = -1;
+    let i = 0;
+    for (;i < header.length; i++) {
+      code = header.charCodeAt(i);
+      if (extensionName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (i !== 0 && (code === 32 || code === 9)) {
+          if (end === -1 && start !== -1)
+            end = i;
+        } else if (code === 59 || code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1)
+            end = i;
+          const name = header.slice(start, end);
+          if (code === 44) {
+            push(offers, name, params);
+            params = Object.create(null);
+          } else {
+            extensionName = name;
+          }
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (paramName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (code === 32 || code === 9) {
+          if (end === -1 && start !== -1)
+            end = i;
+        } else if (code === 59 || code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1)
+            end = i;
+          push(params, header.slice(start, end), true);
+          if (code === 44) {
+            push(offers, extensionName, params);
+            params = Object.create(null);
+            extensionName = undefined;
+          }
+          start = end = -1;
+        } else if (code === 61 && start !== -1 && end === -1) {
+          paramName = header.slice(start, i);
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else {
+        if (isEscaping) {
+          if (tokenChars[code] !== 1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (start === -1)
+            start = i;
+          else if (!mustUnescape)
+            mustUnescape = true;
+          isEscaping = false;
+        } else if (inQuotes) {
+          if (tokenChars[code] === 1) {
+            if (start === -1)
+              start = i;
+          } else if (code === 34 && start !== -1) {
+            inQuotes = false;
+            end = i;
+          } else if (code === 92) {
+            isEscaping = true;
+          } else {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+        } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
+          inQuotes = true;
+        } else if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (start !== -1 && (code === 32 || code === 9)) {
+          if (end === -1)
+            end = i;
+        } else if (code === 59 || code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1)
+            end = i;
+          let value = header.slice(start, end);
+          if (mustUnescape) {
+            value = value.replace(/\\/g, "");
+            mustUnescape = false;
+          }
+          push(params, paramName, value);
+          if (code === 44) {
+            push(offers, extensionName, params);
+            params = Object.create(null);
+            extensionName = undefined;
+          }
+          paramName = undefined;
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      }
+    }
+    if (start === -1 || inQuotes || code === 32 || code === 9) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    if (end === -1)
+      end = i;
+    const token = header.slice(start, end);
+    if (extensionName === undefined) {
+      push(offers, token, params);
+    } else {
+      if (paramName === undefined) {
+        push(params, token, true);
+      } else if (mustUnescape) {
+        push(params, paramName, token.replace(/\\/g, ""));
+      } else {
+        push(params, paramName, token);
+      }
+      push(offers, extensionName, params);
+    }
+    return offers;
+  }
+  function format(extensions) {
+    return Object.keys(extensions).map((extension2) => {
+      let configurations = extensions[extension2];
+      if (!Array.isArray(configurations))
+        configurations = [configurations];
+      return configurations.map((params) => {
+        return [extension2].concat(Object.keys(params).map((k) => {
+          let values = params[k];
+          if (!Array.isArray(values))
+            values = [values];
+          return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
+        })).join("; ");
+      }).join(", ");
+    }).join(", ");
+  }
+  module.exports = { format, parse: parse6 };
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/websocket.js
+var require_websocket = __commonJS((exports, module) => {
+  var EventEmitter4 = __require("events");
+  var https = __require("https");
+  var http = __require("http");
+  var net = __require("net");
+  var tls = __require("tls");
+  var { randomBytes, createHash } = __require("crypto");
+  var { Duplex, Readable } = __require("stream");
+  var { URL: URL2 } = __require("url");
+  var PerMessageDeflate = require_permessage_deflate();
+  var Receiver = require_receiver();
+  var Sender = require_sender();
+  var { isBlob } = require_validation();
+  var {
+    BINARY_TYPES,
+    CLOSE_TIMEOUT,
+    EMPTY_BUFFER,
+    GUID,
+    kForOnEventAttribute,
+    kListener,
+    kStatusCode,
+    kWebSocket,
+    NOOP
+  } = require_constants();
+  var {
+    EventTarget: { addEventListener, removeEventListener }
+  } = require_event_target();
+  var { format, parse: parse6 } = require_extension();
+  var { toBuffer } = require_buffer_util();
+  var kAborted = Symbol("kAborted");
+  var protocolVersions = [8, 13];
+  var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+  var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+
+  class WebSocket extends EventEmitter4 {
+    constructor(address, protocols, options) {
+      super();
+      this._binaryType = BINARY_TYPES[0];
+      this._closeCode = 1006;
+      this._closeFrameReceived = false;
+      this._closeFrameSent = false;
+      this._closeMessage = EMPTY_BUFFER;
+      this._closeTimer = null;
+      this._errorEmitted = false;
+      this._extensions = {};
+      this._paused = false;
+      this._protocol = "";
+      this._readyState = WebSocket.CONNECTING;
+      this._receiver = null;
+      this._sender = null;
+      this._socket = null;
+      if (address !== null) {
+        this._bufferedAmount = 0;
+        this._isServer = false;
+        this._redirects = 0;
+        if (protocols === undefined) {
+          protocols = [];
+        } else if (!Array.isArray(protocols)) {
+          if (typeof protocols === "object" && protocols !== null) {
+            options = protocols;
+            protocols = [];
+          } else {
+            protocols = [protocols];
+          }
+        }
+        initAsClient(this, address, protocols, options);
+      } else {
+        this._autoPong = options.autoPong;
+        this._closeTimeout = options.closeTimeout;
+        this._isServer = true;
+      }
+    }
+    get binaryType() {
+      return this._binaryType;
+    }
+    set binaryType(type) {
+      if (!BINARY_TYPES.includes(type))
+        return;
+      this._binaryType = type;
+      if (this._receiver)
+        this._receiver._binaryType = type;
+    }
+    get bufferedAmount() {
+      if (!this._socket)
+        return this._bufferedAmount;
+      return this._socket._writableState.length + this._sender._bufferedBytes;
+    }
+    get extensions() {
+      return Object.keys(this._extensions).join();
+    }
+    get isPaused() {
+      return this._paused;
+    }
+    get onclose() {
+      return null;
+    }
+    get onerror() {
+      return null;
+    }
+    get onopen() {
+      return null;
+    }
+    get onmessage() {
+      return null;
+    }
+    get protocol() {
+      return this._protocol;
+    }
+    get readyState() {
+      return this._readyState;
+    }
+    get url() {
+      return this._url;
+    }
+    setSocket(socket, head, options) {
+      const receiver2 = new Receiver({
+        allowSynchronousEvents: options.allowSynchronousEvents,
+        binaryType: this.binaryType,
+        extensions: this._extensions,
+        isServer: this._isServer,
+        maxPayload: options.maxPayload,
+        skipUTF8Validation: options.skipUTF8Validation
+      });
+      const sender2 = new Sender(socket, this._extensions, options.generateMask);
+      this._receiver = receiver2;
+      this._sender = sender2;
+      this._socket = socket;
+      receiver2[kWebSocket] = this;
+      sender2[kWebSocket] = this;
+      socket[kWebSocket] = this;
+      receiver2.on("conclude", receiverOnConclude);
+      receiver2.on("drain", receiverOnDrain);
+      receiver2.on("error", receiverOnError);
+      receiver2.on("message", receiverOnMessage);
+      receiver2.on("ping", receiverOnPing);
+      receiver2.on("pong", receiverOnPong);
+      sender2.onerror = senderOnError;
+      if (socket.setTimeout)
+        socket.setTimeout(0);
+      if (socket.setNoDelay)
+        socket.setNoDelay();
+      if (head.length > 0)
+        socket.unshift(head);
+      socket.on("close", socketOnClose);
+      socket.on("data", socketOnData);
+      socket.on("end", socketOnEnd);
+      socket.on("error", socketOnError);
+      this._readyState = WebSocket.OPEN;
+      this.emit("open");
+    }
+    emitClose() {
+      if (!this._socket) {
+        this._readyState = WebSocket.CLOSED;
+        this.emit("close", this._closeCode, this._closeMessage);
+        return;
+      }
+      if (this._extensions[PerMessageDeflate.extensionName]) {
+        this._extensions[PerMessageDeflate.extensionName].cleanup();
+      }
+      this._receiver.removeAllListeners();
+      this._readyState = WebSocket.CLOSED;
+      this.emit("close", this._closeCode, this._closeMessage);
+    }
+    close(code, data) {
+      if (this.readyState === WebSocket.CLOSED)
+        return;
+      if (this.readyState === WebSocket.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        abortHandshake(this, this._req, msg);
+        return;
+      }
+      if (this.readyState === WebSocket.CLOSING) {
+        if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
+          this._socket.end();
+        }
+        return;
+      }
+      this._readyState = WebSocket.CLOSING;
+      this._sender.close(code, data, !this._isServer, (err) => {
+        if (err)
+          return;
+        this._closeFrameSent = true;
+        if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
+          this._socket.end();
+        }
+      });
+      setCloseTimer(this);
+    }
+    pause() {
+      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      this._paused = true;
+      this._socket.pause();
+    }
+    ping(data, mask, cb) {
+      if (this.readyState === WebSocket.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof data === "function") {
+        cb = data;
+        data = mask = undefined;
+      } else if (typeof mask === "function") {
+        cb = mask;
+        mask = undefined;
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+    }
+    pong(data, mask, cb) {
+      if (this.readyState === WebSocket.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof data === "function") {
+        cb = data;
+        data = mask = undefined;
+      } else if (typeof mask === "function") {
+        cb = mask;
+        mask = undefined;
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+    }
+    resume() {
+      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+        return;
+      }
+      this._paused = false;
+      if (!this._receiver._writableState.needDrain)
+        this._socket.resume();
+    }
+    send(data, options, cb) {
+      if (this.readyState === WebSocket.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      const opts = {
+        binary: typeof data !== "string",
+        mask: !this._isServer,
+        compress: true,
+        fin: true,
+        ...options
+      };
+      if (!this._extensions[PerMessageDeflate.extensionName]) {
+        opts.compress = false;
+      }
+      this._sender.send(data || EMPTY_BUFFER, opts, cb);
+    }
+    terminate() {
+      if (this.readyState === WebSocket.CLOSED)
+        return;
+      if (this.readyState === WebSocket.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        abortHandshake(this, this._req, msg);
+        return;
+      }
+      if (this._socket) {
+        this._readyState = WebSocket.CLOSING;
+        this._socket.destroy();
+      }
+    }
+  }
+  Object.defineProperty(WebSocket, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket.prototype, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket.prototype, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket.prototype, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  Object.defineProperty(WebSocket.prototype, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  [
+    "binaryType",
+    "bufferedAmount",
+    "extensions",
+    "isPaused",
+    "protocol",
+    "readyState",
+    "url"
+  ].forEach((property) => {
+    Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+  });
+  ["open", "error", "close", "message"].forEach((method) => {
+    Object.defineProperty(WebSocket.prototype, `on${method}`, {
+      enumerable: true,
+      get() {
+        for (const listener of this.listeners(method)) {
+          if (listener[kForOnEventAttribute])
+            return listener[kListener];
+        }
+        return null;
+      },
+      set(handler) {
+        for (const listener of this.listeners(method)) {
+          if (listener[kForOnEventAttribute]) {
+            this.removeListener(method, listener);
+            break;
+          }
+        }
+        if (typeof handler !== "function")
+          return;
+        this.addEventListener(method, handler, {
+          [kForOnEventAttribute]: true
+        });
+      }
+    });
+  });
+  WebSocket.prototype.addEventListener = addEventListener;
+  WebSocket.prototype.removeEventListener = removeEventListener;
+  module.exports = WebSocket;
+  function initAsClient(websocket2, address, protocols, options) {
+    const opts = {
+      allowSynchronousEvents: true,
+      autoPong: true,
+      closeTimeout: CLOSE_TIMEOUT,
+      protocolVersion: protocolVersions[1],
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: false,
+      perMessageDeflate: true,
+      followRedirects: false,
+      maxRedirects: 10,
+      ...options,
+      socketPath: undefined,
+      hostname: undefined,
+      protocol: undefined,
+      timeout: undefined,
+      method: "GET",
+      host: undefined,
+      path: undefined,
+      port: undefined
+    };
+    websocket2._autoPong = opts.autoPong;
+    websocket2._closeTimeout = opts.closeTimeout;
+    if (!protocolVersions.includes(opts.protocolVersion)) {
+      throw new RangeError(`Unsupported protocol version: ${opts.protocolVersion} ` + `(supported versions: ${protocolVersions.join(", ")})`);
+    }
+    let parsedUrl;
+    if (address instanceof URL2) {
+      parsedUrl = address;
+    } else {
+      try {
+        parsedUrl = new URL2(address);
+      } catch (e) {
+        throw new SyntaxError(`Invalid URL: ${address}`);
+      }
+    }
+    if (parsedUrl.protocol === "http:") {
+      parsedUrl.protocol = "ws:";
+    } else if (parsedUrl.protocol === "https:") {
+      parsedUrl.protocol = "wss:";
+    }
+    websocket2._url = parsedUrl.href;
+    const isSecure = parsedUrl.protocol === "wss:";
+    const isIpcUrl = parsedUrl.protocol === "ws+unix:";
+    let invalidUrlMessage;
+    if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
+      invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", ` + '"http:", "https:", or "ws+unix:"';
+    } else if (isIpcUrl && !parsedUrl.pathname) {
+      invalidUrlMessage = "The URL's pathname is empty";
+    } else if (parsedUrl.hash) {
+      invalidUrlMessage = "The URL contains a fragment identifier";
+    }
+    if (invalidUrlMessage) {
+      const err = new SyntaxError(invalidUrlMessage);
+      if (websocket2._redirects === 0) {
+        throw err;
+      } else {
+        emitErrorAndClose(websocket2, err);
+        return;
+      }
+    }
+    const defaultPort = isSecure ? 443 : 80;
+    const key = randomBytes(16).toString("base64");
+    const request = isSecure ? https.request : http.request;
+    const protocolSet = new Set;
+    let perMessageDeflate;
+    opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
+    opts.defaultPort = opts.defaultPort || defaultPort;
+    opts.port = parsedUrl.port || defaultPort;
+    opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
+    opts.headers = {
+      ...opts.headers,
+      "Sec-WebSocket-Version": opts.protocolVersion,
+      "Sec-WebSocket-Key": key,
+      Connection: "Upgrade",
+      Upgrade: "websocket"
+    };
+    opts.path = parsedUrl.pathname + parsedUrl.search;
+    opts.timeout = opts.handshakeTimeout;
+    if (opts.perMessageDeflate) {
+      perMessageDeflate = new PerMessageDeflate(opts.perMessageDeflate !== true ? opts.perMessageDeflate : {}, false, opts.maxPayload);
+      opts.headers["Sec-WebSocket-Extensions"] = format({
+        [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+      });
+    }
+    if (protocols.length) {
+      for (const protocol of protocols) {
+        if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
+          throw new SyntaxError("An invalid or duplicated subprotocol was specified");
+        }
+        protocolSet.add(protocol);
+      }
+      opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
+    }
+    if (opts.origin) {
+      if (opts.protocolVersion < 13) {
+        opts.headers["Sec-WebSocket-Origin"] = opts.origin;
+      } else {
+        opts.headers.Origin = opts.origin;
+      }
+    }
+    if (parsedUrl.username || parsedUrl.password) {
+      opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+    }
+    if (isIpcUrl) {
+      const parts = opts.path.split(":");
+      opts.socketPath = parts[0];
+      opts.path = parts[1];
+    }
+    let req;
+    if (opts.followRedirects) {
+      if (websocket2._redirects === 0) {
+        websocket2._originalIpc = isIpcUrl;
+        websocket2._originalSecure = isSecure;
+        websocket2._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
+        const headers = options && options.headers;
+        options = { ...options, headers: {} };
+        if (headers) {
+          for (const [key2, value] of Object.entries(headers)) {
+            options.headers[key2.toLowerCase()] = value;
+          }
+        }
+      } else if (websocket2.listenerCount("redirect") === 0) {
+        const isSameHost = isIpcUrl ? websocket2._originalIpc ? opts.socketPath === websocket2._originalHostOrSocketPath : false : websocket2._originalIpc ? false : parsedUrl.host === websocket2._originalHostOrSocketPath;
+        if (!isSameHost || websocket2._originalSecure && !isSecure) {
+          delete opts.headers.authorization;
+          delete opts.headers.cookie;
+          if (!isSameHost)
+            delete opts.headers.host;
+          opts.auth = undefined;
+        }
+      }
+      if (opts.auth && !options.headers.authorization) {
+        options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
+      }
+      req = websocket2._req = request(opts);
+      if (websocket2._redirects) {
+        websocket2.emit("redirect", websocket2.url, req);
+      }
+    } else {
+      req = websocket2._req = request(opts);
+    }
+    if (opts.timeout) {
+      req.on("timeout", () => {
+        abortHandshake(websocket2, req, "Opening handshake has timed out");
+      });
+    }
+    req.on("error", (err) => {
+      if (req === null || req[kAborted])
+        return;
+      req = websocket2._req = null;
+      emitErrorAndClose(websocket2, err);
+    });
+    req.on("response", (res) => {
+      const location2 = res.headers.location;
+      const statusCode = res.statusCode;
+      if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+        if (++websocket2._redirects > opts.maxRedirects) {
+          abortHandshake(websocket2, req, "Maximum redirects exceeded");
+          return;
+        }
+        req.abort();
+        let addr;
+        try {
+          addr = new URL2(location2, address);
+        } catch (e) {
+          const err = new SyntaxError(`Invalid URL: ${location2}`);
+          emitErrorAndClose(websocket2, err);
+          return;
+        }
+        initAsClient(websocket2, addr, protocols, options);
+      } else if (!websocket2.emit("unexpected-response", req, res)) {
+        abortHandshake(websocket2, req, `Unexpected server response: ${res.statusCode}`);
+      }
+    });
+    req.on("upgrade", (res, socket, head) => {
+      websocket2.emit("upgrade", res);
+      if (websocket2.readyState !== WebSocket.CONNECTING)
+        return;
+      req = websocket2._req = null;
+      const upgrade = res.headers.upgrade;
+      if (upgrade === undefined || upgrade.toLowerCase() !== "websocket") {
+        abortHandshake(websocket2, socket, "Invalid Upgrade header");
+        return;
+      }
+      const digest = createHash("sha1").update(key + GUID).digest("base64");
+      if (res.headers["sec-websocket-accept"] !== digest) {
+        abortHandshake(websocket2, socket, "Invalid Sec-WebSocket-Accept header");
+        return;
+      }
+      const serverProt = res.headers["sec-websocket-protocol"];
+      let protError;
+      if (serverProt !== undefined) {
+        if (!protocolSet.size) {
+          protError = "Server sent a subprotocol but none was requested";
+        } else if (!protocolSet.has(serverProt)) {
+          protError = "Server sent an invalid subprotocol";
+        }
+      } else if (protocolSet.size) {
+        protError = "Server sent no subprotocol";
+      }
+      if (protError) {
+        abortHandshake(websocket2, socket, protError);
+        return;
+      }
+      if (serverProt)
+        websocket2._protocol = serverProt;
+      const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
+      if (secWebSocketExtensions !== undefined) {
+        if (!perMessageDeflate) {
+          const message = "Server sent a Sec-WebSocket-Extensions header but no extension " + "was requested";
+          abortHandshake(websocket2, socket, message);
+          return;
+        }
+        let extensions;
+        try {
+          extensions = parse6(secWebSocketExtensions);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket2, socket, message);
+          return;
+        }
+        const extensionNames = Object.keys(extensions);
+        if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+          const message = "Server indicated an extension that was not requested";
+          abortHandshake(websocket2, socket, message);
+          return;
+        }
+        try {
+          perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket2, socket, message);
+          return;
+        }
+        websocket2._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+      }
+      websocket2.setSocket(socket, head, {
+        allowSynchronousEvents: opts.allowSynchronousEvents,
+        generateMask: opts.generateMask,
+        maxPayload: opts.maxPayload,
+        skipUTF8Validation: opts.skipUTF8Validation
+      });
+    });
+    if (opts.finishRequest) {
+      opts.finishRequest(req, websocket2);
+    } else {
+      req.end();
+    }
+  }
+  function emitErrorAndClose(websocket2, err) {
+    websocket2._readyState = WebSocket.CLOSING;
+    websocket2._errorEmitted = true;
+    websocket2.emit("error", err);
+    websocket2.emitClose();
+  }
+  function netConnect(options) {
+    options.path = options.socketPath;
+    return net.connect(options);
+  }
+  function tlsConnect(options) {
+    options.path = undefined;
+    if (!options.servername && options.servername !== "") {
+      options.servername = net.isIP(options.host) ? "" : options.host;
+    }
+    return tls.connect(options);
+  }
+  function abortHandshake(websocket2, stream2, message) {
+    websocket2._readyState = WebSocket.CLOSING;
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshake);
+    if (stream2.setHeader) {
+      stream2[kAborted] = true;
+      stream2.abort();
+      if (stream2.socket && !stream2.socket.destroyed) {
+        stream2.socket.destroy();
+      }
+      process.nextTick(emitErrorAndClose, websocket2, err);
+    } else {
+      stream2.destroy(err);
+      stream2.once("error", websocket2.emit.bind(websocket2, "error"));
+      stream2.once("close", websocket2.emitClose.bind(websocket2));
+    }
+  }
+  function sendAfterClose(websocket2, data, cb) {
+    if (data) {
+      const length = isBlob(data) ? data.size : toBuffer(data).length;
+      if (websocket2._socket)
+        websocket2._sender._bufferedBytes += length;
+      else
+        websocket2._bufferedAmount += length;
+    }
+    if (cb) {
+      const err = new Error(`WebSocket is not open: readyState ${websocket2.readyState} ` + `(${readyStates[websocket2.readyState]})`);
+      process.nextTick(cb, err);
+    }
+  }
+  function receiverOnConclude(code, reason) {
+    const websocket2 = this[kWebSocket];
+    websocket2._closeFrameReceived = true;
+    websocket2._closeMessage = reason;
+    websocket2._closeCode = code;
+    if (websocket2._socket[kWebSocket] === undefined)
+      return;
+    websocket2._socket.removeListener("data", socketOnData);
+    process.nextTick(resume, websocket2._socket);
+    if (code === 1005)
+      websocket2.close();
+    else
+      websocket2.close(code, reason);
+  }
+  function receiverOnDrain() {
+    const websocket2 = this[kWebSocket];
+    if (!websocket2.isPaused)
+      websocket2._socket.resume();
+  }
+  function receiverOnError(err) {
+    const websocket2 = this[kWebSocket];
+    if (websocket2._socket[kWebSocket] !== undefined) {
+      websocket2._socket.removeListener("data", socketOnData);
+      process.nextTick(resume, websocket2._socket);
+      websocket2.close(err[kStatusCode]);
+    }
+    if (!websocket2._errorEmitted) {
+      websocket2._errorEmitted = true;
+      websocket2.emit("error", err);
+    }
+  }
+  function receiverOnFinish() {
+    this[kWebSocket].emitClose();
+  }
+  function receiverOnMessage(data, isBinary) {
+    this[kWebSocket].emit("message", data, isBinary);
+  }
+  function receiverOnPing(data) {
+    const websocket2 = this[kWebSocket];
+    if (websocket2._autoPong)
+      websocket2.pong(data, !this._isServer, NOOP);
+    websocket2.emit("ping", data);
+  }
+  function receiverOnPong(data) {
+    this[kWebSocket].emit("pong", data);
+  }
+  function resume(stream2) {
+    stream2.resume();
+  }
+  function senderOnError(err) {
+    const websocket2 = this[kWebSocket];
+    if (websocket2.readyState === WebSocket.CLOSED)
+      return;
+    if (websocket2.readyState === WebSocket.OPEN) {
+      websocket2._readyState = WebSocket.CLOSING;
+      setCloseTimer(websocket2);
+    }
+    this._socket.end();
+    if (!websocket2._errorEmitted) {
+      websocket2._errorEmitted = true;
+      websocket2.emit("error", err);
+    }
+  }
+  function setCloseTimer(websocket2) {
+    websocket2._closeTimer = setTimeout(websocket2._socket.destroy.bind(websocket2._socket), websocket2._closeTimeout);
+  }
+  function socketOnClose() {
+    const websocket2 = this[kWebSocket];
+    this.removeListener("close", socketOnClose);
+    this.removeListener("data", socketOnData);
+    this.removeListener("end", socketOnEnd);
+    websocket2._readyState = WebSocket.CLOSING;
+    if (!this._readableState.endEmitted && !websocket2._closeFrameReceived && !websocket2._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
+      const chunk = this.read(this._readableState.length);
+      websocket2._receiver.write(chunk);
+    }
+    websocket2._receiver.end();
+    this[kWebSocket] = undefined;
+    clearTimeout(websocket2._closeTimer);
+    if (websocket2._receiver._writableState.finished || websocket2._receiver._writableState.errorEmitted) {
+      websocket2.emitClose();
+    } else {
+      websocket2._receiver.on("error", receiverOnFinish);
+      websocket2._receiver.on("finish", receiverOnFinish);
+    }
+  }
+  function socketOnData(chunk) {
+    if (!this[kWebSocket]._receiver.write(chunk)) {
+      this.pause();
+    }
+  }
+  function socketOnEnd() {
+    const websocket2 = this[kWebSocket];
+    websocket2._readyState = WebSocket.CLOSING;
+    websocket2._receiver.end();
+    this.end();
+  }
+  function socketOnError() {
+    const websocket2 = this[kWebSocket];
+    this.removeListener("error", socketOnError);
+    this.on("error", NOOP);
+    if (websocket2) {
+      websocket2._readyState = WebSocket.CLOSING;
+      this.destroy();
+    }
+  }
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/stream.js
+var require_stream = __commonJS((exports, module) => {
+  var WebSocket = require_websocket();
+  var { Duplex } = __require("stream");
+  function emitClose(stream2) {
+    stream2.emit("close");
+  }
+  function duplexOnEnd() {
+    if (!this.destroyed && this._writableState.finished) {
+      this.destroy();
+    }
+  }
+  function duplexOnError(err) {
+    this.removeListener("error", duplexOnError);
+    this.destroy();
+    if (this.listenerCount("error") === 0) {
+      this.emit("error", err);
+    }
+  }
+  function createWebSocketStream(ws, options) {
+    let terminateOnDestroy = true;
+    const duplex = new Duplex({
+      ...options,
+      autoDestroy: false,
+      emitClose: false,
+      objectMode: false,
+      writableObjectMode: false
+    });
+    ws.on("message", function message(msg, isBinary) {
+      const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+      if (!duplex.push(data))
+        ws.pause();
+    });
+    ws.once("error", function error49(err) {
+      if (duplex.destroyed)
+        return;
+      terminateOnDestroy = false;
+      duplex.destroy(err);
+    });
+    ws.once("close", function close() {
+      if (duplex.destroyed)
+        return;
+      duplex.push(null);
+    });
+    duplex._destroy = function(err, callback) {
+      if (ws.readyState === ws.CLOSED) {
+        callback(err);
+        process.nextTick(emitClose, duplex);
+        return;
+      }
+      let called = false;
+      ws.once("error", function error49(err2) {
+        called = true;
+        callback(err2);
+      });
+      ws.once("close", function close() {
+        if (!called)
+          callback(err);
+        process.nextTick(emitClose, duplex);
+      });
+      if (terminateOnDestroy)
+        ws.terminate();
+    };
+    duplex._final = function(callback) {
+      if (ws.readyState === ws.CONNECTING) {
+        ws.once("open", function open() {
+          duplex._final(callback);
+        });
+        return;
+      }
+      if (ws._socket === null)
+        return;
+      if (ws._socket._writableState.finished) {
+        callback();
+        if (duplex._readableState.endEmitted)
+          duplex.destroy();
+      } else {
+        ws._socket.once("finish", function finish() {
+          callback();
+        });
+        ws.close();
+      }
+    };
+    duplex._read = function() {
+      if (ws.isPaused)
+        ws.resume();
+    };
+    duplex._write = function(chunk, encoding, callback) {
+      if (ws.readyState === ws.CONNECTING) {
+        ws.once("open", function open() {
+          duplex._write(chunk, encoding, callback);
+        });
+        return;
+      }
+      ws.send(chunk, callback);
+    };
+    duplex.on("end", duplexOnEnd);
+    duplex.on("error", duplexOnError);
+    return duplex;
+  }
+  module.exports = createWebSocketStream;
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/subprotocol.js
+var require_subprotocol = __commonJS((exports, module) => {
+  var { tokenChars } = require_validation();
+  function parse6(header) {
+    const protocols = new Set;
+    let start = -1;
+    let end = -1;
+    let i = 0;
+    for (i;i < header.length; i++) {
+      const code = header.charCodeAt(i);
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1)
+          start = i;
+      } else if (i !== 0 && (code === 32 || code === 9)) {
+        if (end === -1 && start !== -1)
+          end = i;
+      } else if (code === 44) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (end === -1)
+          end = i;
+        const protocol2 = header.slice(start, end);
+        if (protocols.has(protocol2)) {
+          throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
+        }
+        protocols.add(protocol2);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+    if (start === -1 || end !== -1) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    const protocol = header.slice(start, i);
+    if (protocols.has(protocol)) {
+      throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+    }
+    protocols.add(protocol);
+    return protocols;
+  }
+  module.exports = { parse: parse6 };
+});
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/lib/websocket-server.js
+var require_websocket_server = __commonJS((exports, module) => {
+  var EventEmitter4 = __require("events");
+  var http = __require("http");
+  var { Duplex } = __require("stream");
+  var { createHash } = __require("crypto");
+  var extension2 = require_extension();
+  var PerMessageDeflate = require_permessage_deflate();
+  var subprotocol2 = require_subprotocol();
+  var WebSocket = require_websocket();
+  var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants();
+  var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+  var RUNNING = 0;
+  var CLOSING = 1;
+  var CLOSED = 2;
+
+  class WebSocketServer extends EventEmitter4 {
+    constructor(options, callback) {
+      super();
+      options = {
+        allowSynchronousEvents: true,
+        autoPong: true,
+        maxPayload: 100 * 1024 * 1024,
+        skipUTF8Validation: false,
+        perMessageDeflate: false,
+        handleProtocols: null,
+        clientTracking: true,
+        closeTimeout: CLOSE_TIMEOUT,
+        verifyClient: null,
+        noServer: false,
+        backlog: null,
+        server: null,
+        host: null,
+        path: null,
+        port: null,
+        WebSocket,
+        ...options
+      };
+      if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
+        throw new TypeError('One and only one of the "port", "server", or "noServer" options ' + "must be specified");
+      }
+      if (options.port != null) {
+        this._server = http.createServer((req, res) => {
+          const body = http.STATUS_CODES[426];
+          res.writeHead(426, {
+            "Content-Length": body.length,
+            "Content-Type": "text/plain"
+          });
+          res.end(body);
+        });
+        this._server.listen(options.port, options.host, options.backlog, callback);
+      } else if (options.server) {
+        this._server = options.server;
+      }
+      if (this._server) {
+        const emitConnection = this.emit.bind(this, "connection");
+        this._removeListeners = addListeners(this._server, {
+          listening: this.emit.bind(this, "listening"),
+          error: this.emit.bind(this, "error"),
+          upgrade: (req, socket, head) => {
+            this.handleUpgrade(req, socket, head, emitConnection);
+          }
+        });
+      }
+      if (options.perMessageDeflate === true)
+        options.perMessageDeflate = {};
+      if (options.clientTracking) {
+        this.clients = new Set;
+        this._shouldEmitClose = false;
+      }
+      this.options = options;
+      this._state = RUNNING;
+    }
+    address() {
+      if (this.options.noServer) {
+        throw new Error('The server is operating in "noServer" mode');
+      }
+      if (!this._server)
+        return null;
+      return this._server.address();
+    }
+    close(cb) {
+      if (this._state === CLOSED) {
+        if (cb) {
+          this.once("close", () => {
+            cb(new Error("The server is not running"));
+          });
+        }
+        process.nextTick(emitClose, this);
+        return;
+      }
+      if (cb)
+        this.once("close", cb);
+      if (this._state === CLOSING)
+        return;
+      this._state = CLOSING;
+      if (this.options.noServer || this.options.server) {
+        if (this._server) {
+          this._removeListeners();
+          this._removeListeners = this._server = null;
+        }
+        if (this.clients) {
+          if (!this.clients.size) {
+            process.nextTick(emitClose, this);
+          } else {
+            this._shouldEmitClose = true;
+          }
+        } else {
+          process.nextTick(emitClose, this);
+        }
+      } else {
+        const server = this._server;
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+        server.close(() => {
+          emitClose(this);
+        });
+      }
+    }
+    shouldHandle(req) {
+      if (this.options.path) {
+        const index2 = req.url.indexOf("?");
+        const pathname = index2 !== -1 ? req.url.slice(0, index2) : req.url;
+        if (pathname !== this.options.path)
+          return false;
+      }
+      return true;
+    }
+    handleUpgrade(req, socket, head, cb) {
+      socket.on("error", socketOnError);
+      const key = req.headers["sec-websocket-key"];
+      const upgrade = req.headers.upgrade;
+      const version3 = +req.headers["sec-websocket-version"];
+      if (req.method !== "GET") {
+        const message = "Invalid HTTP method";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+        return;
+      }
+      if (upgrade === undefined || upgrade.toLowerCase() !== "websocket") {
+        const message = "Invalid Upgrade header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+      if (key === undefined || !keyRegex.test(key)) {
+        const message = "Missing or invalid Sec-WebSocket-Key header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+      if (version3 !== 13 && version3 !== 8) {
+        const message = "Missing or invalid Sec-WebSocket-Version header";
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+          "Sec-WebSocket-Version": "13, 8"
+        });
+        return;
+      }
+      if (!this.shouldHandle(req)) {
+        abortHandshake(socket, 400);
+        return;
+      }
+      const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
+      let protocols = new Set;
+      if (secWebSocketProtocol !== undefined) {
+        try {
+          protocols = subprotocol2.parse(secWebSocketProtocol);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Protocol header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+      }
+      const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
+      const extensions = {};
+      if (this.options.perMessageDeflate && secWebSocketExtensions !== undefined) {
+        const perMessageDeflate = new PerMessageDeflate(this.options.perMessageDeflate, true, this.options.maxPayload);
+        try {
+          const offers = extension2.parse(secWebSocketExtensions);
+          if (offers[PerMessageDeflate.extensionName]) {
+            perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+            extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+          }
+        } catch (err) {
+          const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+      }
+      if (this.options.verifyClient) {
+        const info = {
+          origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
+          secure: !!(req.socket.authorized || req.socket.encrypted),
+          req
+        };
+        if (this.options.verifyClient.length === 2) {
+          this.options.verifyClient(info, (verified, code, message, headers) => {
+            if (!verified) {
+              return abortHandshake(socket, code || 401, message, headers);
+            }
+            this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+          });
+          return;
+        }
+        if (!this.options.verifyClient(info))
+          return abortHandshake(socket, 401);
+      }
+      this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+    }
+    completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+      if (!socket.readable || !socket.writable)
+        return socket.destroy();
+      if (socket[kWebSocket]) {
+        throw new Error("server.handleUpgrade() was called more than once with the same " + "socket, possibly due to a misconfiguration");
+      }
+      if (this._state > RUNNING)
+        return abortHandshake(socket, 503);
+      const digest = createHash("sha1").update(key + GUID).digest("base64");
+      const headers = [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${digest}`
+      ];
+      const ws = new this.options.WebSocket(null, undefined, this.options);
+      if (protocols.size) {
+        const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
+        if (protocol) {
+          headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+          ws._protocol = protocol;
+        }
+      }
+      if (extensions[PerMessageDeflate.extensionName]) {
+        const params = extensions[PerMessageDeflate.extensionName].params;
+        const value = extension2.format({
+          [PerMessageDeflate.extensionName]: [params]
+        });
+        headers.push(`Sec-WebSocket-Extensions: ${value}`);
+        ws._extensions = extensions;
+      }
+      this.emit("headers", headers, req);
+      socket.write(headers.concat(`\r
+`).join(`\r
+`));
+      socket.removeListener("error", socketOnError);
+      ws.setSocket(socket, head, {
+        allowSynchronousEvents: this.options.allowSynchronousEvents,
+        maxPayload: this.options.maxPayload,
+        skipUTF8Validation: this.options.skipUTF8Validation
+      });
+      if (this.clients) {
+        this.clients.add(ws);
+        ws.on("close", () => {
+          this.clients.delete(ws);
+          if (this._shouldEmitClose && !this.clients.size) {
+            process.nextTick(emitClose, this);
+          }
+        });
+      }
+      cb(ws, req);
+    }
+  }
+  module.exports = WebSocketServer;
+  function addListeners(server, map3) {
+    for (const event of Object.keys(map3))
+      server.on(event, map3[event]);
+    return function removeListeners() {
+      for (const event of Object.keys(map3)) {
+        server.removeListener(event, map3[event]);
+      }
+    };
+  }
+  function emitClose(server) {
+    server._state = CLOSED;
+    server.emit("close");
+  }
+  function socketOnError() {
+    this.destroy();
+  }
+  function abortHandshake(socket, code, message, headers) {
+    message = message || http.STATUS_CODES[code];
+    headers = {
+      Connection: "close",
+      "Content-Type": "text/html",
+      "Content-Length": Buffer.byteLength(message),
+      ...headers
+    };
+    socket.once("finish", socket.destroy);
+    socket.end(`HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
+` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join(`\r
+`) + `\r
+\r
+` + message);
+  }
+  function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
+    if (server.listenerCount("wsClientError")) {
+      const err = new Error(message);
+      Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+      server.emit("wsClientError", err, socket, req);
+    } else {
+      abortHandshake(socket, code, message, headers);
+    }
+  }
+});
 
-// node_modules/.pnpm/@kevisual+router@0.0.64_typescript@5.9.3/node_modules/@kevisual/router/dist/router.js
+// node_modules/.pnpm/@kevisual+router@0.0.70/node_modules/@kevisual/router/dist/router.js
 import require$$1, { webcrypto } from "node:crypto";
 import require$$2 from "node:http";
 import require$$1$1 from "node:https";
@@ -292,6 +3421,44 @@ function requireEventemitter3() {
 }
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+function isPlainObject$1(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  const hasObjectPrototype = proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null;
+  if (!hasObjectPrototype) {
+    return false;
+  }
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+function merge$1(target, source) {
+  const sourceKeys = Object.keys(source);
+  for (let i = 0;i < sourceKeys.length; i++) {
+    const key = sourceKeys[i];
+    if (isUnsafeProperty(key)) {
+      continue;
+    }
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) {
+      target[key] = merge$1(targetValue, sourceValue);
+    } else if (Array.isArray(sourceValue)) {
+      target[key] = merge$1([], sourceValue);
+    } else if (isPlainObject$1(sourceValue)) {
+      target[key] = merge$1({}, sourceValue);
+    } else if (targetValue === undefined || sourceValue !== undefined) {
+      target[key] = sourceValue;
+    }
+  }
+  return target;
+}
+function isMergeableValue(value) {
+  return isPlainObject$1(value) || Array.isArray(value);
+}
 
 class MockProcess {
   emitter;
@@ -330,7 +3497,7 @@ class MockProcess {
     this.process = undefined;
   }
 }
-var listenProcess = async ({ app, mockProcess, params, timeout = 10 * 60 * 60 * 1000 }) => {
+var listenProcess = async ({ app, mockProcess, params = {}, timeout = 10 * 60 * 60 * 1000 }) => {
   const process2 = mockProcess || new MockProcess;
   let isEnd = false;
   const timer = setTimeout(() => {
@@ -343,23 +3510,25 @@ var listenProcess = async ({ app, mockProcess, params, timeout = 10 * 60 * 60 *
   }, timeout);
   const getParams = async () => {
     return new Promise((resolve) => {
-      process2.on((msg) => {
+      process2.on((params2) => {
         if (isEnd)
           return;
         isEnd = true;
         clearTimeout(timer);
-        resolve(msg);
+        resolve(params2 || {});
       });
     });
   };
   try {
-    const { payload = {}, ...rest } = await getParams();
-    const msg = { ...params, ...rest, payload: { ...params?.payload, ...payload } };
+    const _params = await getParams();
+    const mergeParams = merge$1(params, _params);
+    const msg = mergeParams?.message || {};
+    const ctx = mergeParams?.context || {};
     if (!msg.path && !msg.id) {
       const route = app.routes.find((r) => r.path !== "router");
       msg.id = route?.id;
     }
-    const result = await app.run(msg);
+    const result = await app.run(msg, ctx);
     const response = {
       success: true,
       data: result,
@@ -369,6 +3538,7 @@ var listenProcess = async ({ app, mockProcess, params, timeout = 10 * 60 * 60 *
       process2.exit?.(0);
     });
   } catch (error) {
+    console.error("Error in listenProcess:", error);
     process2.send?.({
       success: false,
       error: error.message
@@ -11348,7 +14518,7 @@ var allProcessors = {
   optional: optionalProcessor,
   lazy: lazyProcessor
 };
-function toJSONSchema(input, params) {
+function toJSONSchema$1(input, params) {
   if ("_idmap" in input) {
     const registry2 = input;
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
@@ -11715,7 +14885,7 @@ var index = /* @__PURE__ */ Object.freeze({
   safeParse: safeParse$1,
   safeParseAsync: safeParseAsync$1,
   toDotPath,
-  toJSONSchema,
+  toJSONSchema: toJSONSchema$1,
   treeifyError,
   util: util$1,
   version
@@ -13545,7 +16715,7 @@ function convertSchema(schema, ctx) {
   }
   return baseSchema;
 }
-function fromJSONSchema(schema, params) {
+function fromJSONSchema$1(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z$1.any() : z$1.never();
   }
@@ -13709,7 +16879,7 @@ var z = /* @__PURE__ */ Object.freeze({
   float32,
   float64,
   formatError,
-  fromJSONSchema,
+  fromJSONSchema: fromJSONSchema$1,
   function: _function,
   getErrorMap,
   globalRegistry,
@@ -13802,7 +16972,7 @@ var z = /* @__PURE__ */ Object.freeze({
   superRefine,
   symbol,
   templateLiteral,
-  toJSONSchema,
+  toJSONSchema: toJSONSchema$1,
   toLowerCase: _toLowerCase,
   toUpperCase: _toUpperCase,
   transform,
@@ -13936,8 +17106,8 @@ class Route {
     }
     return this;
   }
-  addTo(router) {
-    router.add(this);
+  addTo(router, opts) {
+    router.add(this, opts);
   }
   setData(data) {
     this.data = data;
@@ -13947,6 +17117,37 @@ class Route {
     throw new CustomError(...args);
   }
 }
+var toJSONSchema = (route) => {
+  const pickValues = pick$1(route, pickValue);
+  if (pickValues?.metadata?.args) {
+    const args = pickValues.metadata.args;
+    const keys = Object.keys(args);
+    const newArgs = {};
+    for (let key of keys) {
+      const item = args[key];
+      if (item && typeof item === "object" && typeof item.toJSONSchema === "function") {
+        newArgs[key] = item.toJSONSchema();
+      } else {
+        newArgs[key] = args[key];
+      }
+    }
+    pickValues.metadata.args = newArgs;
+  }
+  return pickValues;
+};
+var fromJSONSchema = (route) => {
+  const args = route?.metadata?.args;
+  if (!args)
+    return route;
+  const keys = Object.keys(args);
+  const newArgs = {};
+  for (let key of keys) {
+    const item = args[key];
+    newArgs[key] = fromJSONSchema$1(item);
+  }
+  route.metadata.args = newArgs;
+  return route;
+};
 
 class QueryRouter {
   appId = "";
@@ -13956,9 +17157,13 @@ class QueryRouter {
   constructor() {
     this.routes = [];
   }
-  add(route) {
+  add(route, opts) {
+    const overwrite = opts?.overwrite ?? true;
     const has = this.routes.findIndex((r) => r.path === route.path && r.key === route.key);
     if (has !== -1) {
+      if (!overwrite) {
+        return;
+      }
       this.routes.splice(has, 1);
     }
     this.routes.push(route);
@@ -14192,7 +17397,22 @@ class QueryRouter {
   }
   getList(filter) {
     return this.routes.filter(filter || (() => true)).map((r) => {
-      return pick$1(r, pickValue);
+      const pickValues = pick$1(r, pickValue);
+      if (pickValues?.metadata?.args) {
+        const args = pickValues.metadata.args;
+        const keys = Object.keys(args);
+        const newArgs = {};
+        for (let key of keys) {
+          const item = args[key];
+          if (item && typeof item === "object" && typeof item.toJSONSchema === "function") {
+            newArgs[key] = item.toJSONSchema();
+          } else {
+            newArgs[key] = args[key];
+          }
+        }
+        pickValues.metadata.args = newArgs;
+      }
+      return pickValues;
     });
   }
   getHandle(router, wrapperFn, ctx) {
@@ -14265,6 +17485,8 @@ class QueryRouter {
     }
     return listenProcess({ app: this, params, ...opts });
   }
+  toJSONSchema = toJSONSchema;
+  fromJSONSchema = fromJSONSchema;
 }
 
 class QueryRouterServer extends QueryRouter {
@@ -14282,8 +17504,8 @@ class QueryRouterServer extends QueryRouter {
   setHandle(wrapperFn, ctx) {
     this.handle = this.getHandle(this, wrapperFn, ctx);
   }
-  addRoute(route) {
-    this.add(route);
+  addRoute(route, opts) {
+    this.add(route, opts);
   }
   Route = Route;
   route(...args) {
@@ -18222,29 +21444,29 @@ class InitEnv {
 }
 InitEnv.init();
 
-// node_modules/.pnpm/@kevisual+use-config@1.0.28_dotenv@17.2.3/node_modules/@kevisual/use-config/dist/app.js
-import { createRequire } from "node:module";
+// node_modules/.pnpm/@kevisual+use-config@1.0.30_dotenv@17.2.3/node_modules/@kevisual/use-config/dist/app.js
+import { createRequire as createRequire2 } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
+var __create2 = Object.create;
+var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __toESM2 = (mod, isNodeMode, target) => {
+  target = mod != null ? __create2(__getProtoOf2(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
+  for (let key of __getOwnPropNames2(mod))
+    if (!__hasOwnProp2.call(to, key))
       __defProp2(to, key, {
         get: () => mod[key],
         enumerable: true
       });
   return to;
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-var require_package = __commonJS((exports, module) => {
+var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
+var require_package = __commonJS2((exports, module) => {
   module.exports = {
     name: "dotenv",
     version: "17.2.3",
@@ -18308,11 +21530,11 @@ var require_package = __commonJS((exports, module) => {
     }
   };
 });
-var require_main = __commonJS((exports, module) => {
-  var fs2 = __require("fs");
-  var path2 = __require("path");
-  var os = __require("os");
-  var crypto2 = __require("crypto");
+var require_main = __commonJS2((exports, module) => {
+  var fs2 = __require2("fs");
+  var path2 = __require2("path");
+  var os = __require2("os");
+  var crypto2 = __require2("crypto");
   var packageJson = require_package();
   var version2 = packageJson.version;
   var TIPS = [
@@ -18635,7 +21857,7 @@ var require_main = __commonJS((exports, module) => {
   exports.populate = DotenvModule.populate;
   module.exports = DotenvModule;
 });
-var import_dotenv = __toESM(require_main(), 1);
+var import_dotenv = __toESM2(require_main(), 1);
 var fileIsExist = (path2) => {
   try {
     fs.accessSync(path2, fs.constants.F_OK);
@@ -18725,7 +21947,7 @@ var useKey = (key, opts) => {
     v = process.env[key];
   }
   if (!v) {
-    return opts?.defaultValue || null;
+    return opts?.defaultValue || "";
   }
   if (opts?.isNumber && typeof v === "string") {
     return Number(v);
@@ -19289,6 +22511,7 @@ InitEnv2.init();
 // src/cnb-core.ts
 class CNBCore {
   baseURL = "https://api.cnb.cool";
+  hackURL = "https://cnb.cool";
   token;
   cookie;
   constructor(options) {
@@ -19302,6 +22525,10 @@ class CNBCore {
         this.cookie = options.cnb.cookie;
       }
     }
+    if (options?.cors?.baseUrl) {
+      this.baseURL = options.cors.baseUrl + "/" + this.baseURL;
+      this.hackURL = options.cors.baseUrl + "/" + this.hackURL;
+    }
   }
   async request({ url: url2, method = "GET", data, params, headers, body, useCookie, useOrigin }) {
     const defaultHeaders = {
@@ -19490,7 +22717,7 @@ class Repo extends CNBCore {
     return this.post({ url: url2, data: postData });
   }
   deleteRepo(name) {
-    const url2 = `https://cnb.cool/${name}`;
+    const url2 = `${this.hackURL}/${name}`;
     return this.delete({ url: url2, useCookie: true });
   }
   async createCommit(repo, data) {
@@ -19504,7 +22731,7 @@ class Repo extends CNBCore {
     if (!data.parent_commit_sha && preCommitSha) {
       data.parent_commit_sha = preCommitSha;
     }
-    const url2 = `https://cnb.cool/${repo}/-/git/commits`;
+    const url2 = `${this.hackURL}/${repo}/-/git/commits`;
     const postData = {
       ...data,
       base_branch: data.base_branch || "refs/heads/main",
@@ -19564,7 +22791,7 @@ class User extends CNBCore {
     super({ token: options.token, cookie: options.cookie });
   }
   getCurrentUser() {
-    const url2 = `https://cnb.cool/user`;
+    const url2 = `${this.hackURL}/user`;
     return this.get({
       url: url2,
       useCookie: true
@@ -19576,7 +22803,7 @@ class User extends CNBCore {
   }
   createAccessToken(data) {
     const scope = data?.scope || "mission-manage:rw,mission-delete:rw,group-delete:rw,group-manage:rw,group-resource:rw,account-engage:rw,account-email:r,account-profile:rw,registry-delete:rw,registry-manage:rw,registry-package-delete:rw,registry-package:rw,repo-security:r,repo-delete:rw,repo-manage:rw,repo-basic-info:r,repo-cnb-detail:rw,repo-cnb-history:r,repo-cnb-trigger:rw,repo-commit-status:rw,repo-contents:rw,repo-notes:rw,repo-issue:rw,repo-pr:rw,repo-code:rw";
-    const url2 = "https://cnb.cool/user/personal_access_tokens";
+    const url2 = `${this.hackURL}/user/personal_access_tokens`;
     return this.post({
       url: url2,
       useCookie: true,
@@ -19587,7 +22814,7 @@ class User extends CNBCore {
     });
   }
   getAccessTokens(params) {
-    const url2 = "https://cnb.cool/user/personal_access_tokens";
+    const url2 = `${this.hackURL}/user/personal_access_tokens`;
     return this.get({
       url: url2,
       useCookie: true,
@@ -19599,7 +22826,7 @@ class User extends CNBCore {
     });
   }
   deleteAccessToken(tokenId) {
-    const url2 = `https://cnb.cool/user/personal_access_tokens/${tokenId}`;
+    const url2 = `${this.hackURL}/user/personal_access_tokens/${tokenId}`;
     return this.delete({
       url: url2,
       useCookie: true
@@ -33348,7 +36575,7 @@ config3(en_default());
 // node_modules/.pnpm/zod@4.3.6/node_modules/zod/index.js
 var zod_default = exports_external;
 
-// node_modules/.pnpm/@opencode-ai+plugin@1.1.44/node_modules/@opencode-ai/plugin/dist/tool.js
+// node_modules/.pnpm/@opencode-ai+plugin@1.1.51/node_modules/@opencode-ai/plugin/dist/tool.js
 function tool2(input) {
   return input;
 }
@@ -33359,7 +36586,7 @@ app.route({
   path: "cnb",
   key: "user-check",
   description: "检查用户登录状态，参数checkToken,default true; checkCookie, default false",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33404,7 +36631,7 @@ app.route({
   path: "cnb",
   key: "list-repos",
   description: "列出我的代码仓库",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33445,7 +36672,7 @@ app.route({
   path: "cnb",
   key: "create-repo",
   description: "创建代码仓库, 参数name, visibility, description",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33482,7 +36709,7 @@ app.route({
   path: "cnb",
   key: "create-repo-file",
   description: "在代码仓库中创建文件, repoName, filePath, content, encoding",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33517,7 +36744,7 @@ app.route({
   path: "cnb",
   key: "delete-repo",
   description: "删除代码仓库, 参数name",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33543,7 +36770,7 @@ app.route({
   path: "cnb",
   key: "clean-closed-workspace",
   description: "批量删除已停止的cnb工作空间",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33571,9 +36798,48 @@ app.route({
   ctx.forward({ code: 200, message: "已关闭的工作空间删除完成", data: results });
 }).addTo(app);
 
-// src/workspace/keep-live.ts
-import WebSocket from "ws";
+// node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+import { webcrypto as crypto2 } from "node:crypto";
+
+// node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet2 = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER2 = 128;
+var pool2;
+var poolOffset2;
+function fillPool2(bytes) {
+  if (!pool2 || pool2.length < bytes) {
+    pool2 = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER2);
+    crypto2.getRandomValues(pool2);
+    poolOffset2 = 0;
+  } else if (poolOffset2 + bytes > pool2.length) {
+    crypto2.getRandomValues(pool2);
+    poolOffset2 = 0;
+  }
+  poolOffset2 += bytes;
+}
+function nanoid4(size = 21) {
+  fillPool2(size |= 0);
+  let id2 = "";
+  for (let i = poolOffset2 - size;i < poolOffset2; i++) {
+    id2 += urlAlphabet2[pool2[i] & 63];
+  }
+  return id2;
+}
+
+// agent/routes/workspace/keep.ts
+var import_dayjs = __toESM(require_dayjs_min(), 1);
+
+// node_modules/.pnpm/@kevisual+ws@8.19.0/node_modules/@kevisual/ws/wrapper.mjs
+var import_stream = __toESM(require_stream(), 1);
+var import_receiver = __toESM(require_receiver(), 1);
+var import_sender = __toESM(require_sender(), 1);
+var import_websocket = __toESM(require_websocket(), 1);
+var import_websocket_server = __toESM(require_websocket_server(), 1);
+var wrapper_default = import_websocket.default;
 
+// src/workspace/keep-live.ts
 class WSKeepAlive {
   ws = null;
   config;
@@ -33635,7 +36901,7 @@ class WSKeepAlive {
   connect() {
     const { wsUrl, cookie, debug } = this.config;
     this.log(`Connecting to ${wsUrl}...`);
-    this.ws = new WebSocket(wsUrl, {
+    this.ws = new wrapper_default(wsUrl, {
       headers: {
         Origin: this.url.origin,
         Cookie: cookie,
@@ -33678,7 +36944,7 @@ class WSKeepAlive {
   startPing() {
     this.stopPing();
     this.pingTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      if (this.ws && this.ws.readyState === wrapper_default.OPEN) {
         this.ws.ping();
         this.log("Sent ping");
       }
@@ -33724,7 +36990,7 @@ app.route({
   path: "cnb",
   key: "keep-workspace-alive",
   description: "保持工作空间存活技能,参数wsUrl:工作空间访问URL，cookie:访问工作空间所需的cookie",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: [],
     ...{
@@ -33743,9 +37009,9 @@ app.route({
   if (!cookie) {
     ctx.throw(400, "缺少访问工作空间所需的cookie参数");
   }
-  const existing = keepAliveMap.get(wsUrl);
+  const existing = Array.from(keepAliveMap.values()).find((info) => info.id && info.KeepAlive?.wsUrl === wsUrl);
   if (existing) {
-    ctx.body = { message: `工作空间 ${wsUrl} 的保持存活任务已在运行中` };
+    ctx.body = { message: `工作空间 ${wsUrl} 的保持存活任务已在运行中`, id: existing.id };
     return;
   }
   console.log(`启动保持工作空间 ${wsUrl} 存活的任务`);
@@ -33756,72 +37022,154 @@ app.route({
       console.log(`工作空间 ${wsUrl} 保持存活任务已连接`);
     },
     onMessage: (data) => {
-      const aliveInfo = keepAliveMap.get(wsUrl);
-      if (aliveInfo) {
-        aliveInfo.updatedTime = Date.now();
+      for (const info of keepAliveMap.values()) {
+        if (info.KeepAlive?.wsUrl === wsUrl) {
+          info.updatedTime = Date.now();
+          break;
+        }
       }
     },
     debug: true,
     onExit: (code) => {
       console.log(`工作空间 ${wsUrl} 保持存活任务已退出，退出码: ${code}`);
-      keepAliveMap.delete(wsUrl);
+      for (const [id3, info] of keepAliveMap.entries()) {
+        if (info.KeepAlive?.wsUrl === wsUrl) {
+          keepAliveMap.delete(id3);
+          break;
+        }
+      }
     }
   });
-  keepAliveMap.set(wsUrl, { startTime: Date.now(), updatedTime: Date.now(), KeepAlive: keep });
-  ctx.body = { message: `已启动保持工作空间 ${wsUrl} 存活的任务` };
+  const id2 = nanoid4(6).toLowerCase();
+  keepAliveMap.set(id2, { startTime: Date.now(), updatedTime: Date.now(), KeepAlive: keep, id: id2 });
+  ctx.body = { content: `已启动保持工作空间 ${wsUrl} 存活的任务`, id: id2 };
 }).addTo(app);
 app.route({
   path: "cnb",
   key: "list-keep-alive-tasks",
   description: "获取保持工作空间存活任务列表技能",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: []
   }
 }).define(async (ctx) => {
-  const list = Array.from(keepAliveMap.entries()).map(([wsUrl, info]) => ({
-    wsUrl,
-    startTime: info.startTime,
-    updatedTime: info.updatedTime
-  }));
+  const list = Array.from(keepAliveMap.entries()).map(([id2, info]) => {
+    const now = Date.now();
+    const duration4 = Math.floor((now - info.startTime) / 60000);
+    return {
+      id: id2,
+      wsUrl: info.KeepAlive?.wsUrl,
+      startTime: info.startTime,
+      startTimeStr: import_dayjs.default(info.startTime).format("YYYY-MM-DD HH:mm"),
+      updatedTime: info.updatedTime,
+      updatedTimeStr: import_dayjs.default(info.updatedTime).format("YYYY-MM-DD HH:mm"),
+      duration: duration4
+    };
+  });
   ctx.body = { list };
 }).addTo(app);
 app.route({
   path: "cnb",
   key: "stop-keep-workspace-alive",
-  description: "停止保持工作空间存活技能, 参数wsUrl:工作空间访问URL",
-  middleware: ["auth"],
+  description: "停止保持工作空间存活技能, 参数wsUrl:工作空间访问URL或者id",
+  middleware: ["admin-auth"],
   metadata: {
     tags: [],
     ...{
       args: {
-        wsUrl: tool.schema.string().describe("工作空间的访问URL")
+        wsUrl: tool.schema.string().optional().describe("工作空间的访问URL"),
+        id: tool.schema.string().optional().describe("保持存活任务的唯一标识符")
       }
     }
   }
 }).define(async (ctx) => {
   const wsUrl = ctx.query?.wsUrl;
-  if (!wsUrl) {
-    ctx.throw(400, "缺少工作空间访问URL参数");
+  const id2 = ctx.query?.id;
+  if (!wsUrl && !id2) {
+    ctx.throw(400, "缺少工作空间访问URL参数或唯一标识符");
+  }
+  let targetId;
+  let wsUrlFound;
+  if (id2) {
+    const info = keepAliveMap.get(id2);
+    if (info) {
+      targetId = id2;
+      wsUrlFound = info.KeepAlive?.wsUrl;
+    }
+  } else if (wsUrl) {
+    for (const [key, info] of keepAliveMap.entries()) {
+      if (info.KeepAlive?.wsUrl === wsUrl) {
+        targetId = key;
+        wsUrlFound = wsUrl;
+        break;
+      }
+    }
   }
-  const keepAlive = keepAliveMap.get(wsUrl);
-  if (keepAlive) {
+  if (targetId) {
+    const keepAlive = keepAliveMap.get(targetId);
     const endTime = Date.now();
     const duration4 = endTime - keepAlive.startTime;
     keepAlive?.KeepAlive?.disconnect();
-    keepAliveMap.delete(wsUrl);
-    ctx.body = { message: `已停止保持工作空间 ${wsUrl} 存活的任务，持续时间: ${duration4}ms` };
+    keepAliveMap.delete(targetId);
+    ctx.body = { content: `已停止保持工作空间 ${wsUrlFound} 存活的任务，持续时间: ${duration4}ms`, id: targetId };
   } else {
-    ctx.body = { message: `没有找到工作空间 ${wsUrl} 的保持存活任务` };
+    ctx.body = { content: `没有找到对应的工作空间保持存活任务` };
+  }
+}).addTo(app);
+app.route({
+  path: "cnb",
+  key: "reset-keep-workspace-alive",
+  description: "对存活的工作空间，startTime进行重置",
+  middleware: ["admin-auth"],
+  metadata: {
+    tags: []
+  }
+}).define(async (ctx) => {
+  const now = Date.now();
+  for (const info of keepAliveMap.values()) {
+    info.startTime = now;
+  }
+  ctx.body = { content: `已重置所有存活工作空间的开始时间` };
+}).addTo(app);
+app.route({
+  path: "cnb",
+  key: "clear-keep-workspace-alive",
+  description: "对存活的工作空间，超过5小时的进行清理",
+  middleware: ["admin-auth"],
+  metadata: {
+    tags: []
   }
+}).define(async (ctx) => {
+  const res = clearKeepAlive();
+  ctx.body = {
+    content: `已清理所有存活工作空间中超过5小时的任务` + (res.length ? `，清理项：${res.map((i) => i.wsUrl).join(", ")}` : ""),
+    list: res
+  };
 }).addTo(app);
+var clearKeepAlive = () => {
+  const now = Date.now();
+  let clearedArr = [];
+  for (const [id2, info] of keepAliveMap.entries()) {
+    if (now - info.startTime > FIVE_HOURS) {
+      console.log(`工作空间 ${info.KeepAlive?.wsUrl} 超过5小时，自动停止`);
+      info.KeepAlive?.disconnect?.();
+      keepAliveMap.delete(id2);
+      clearedArr.push({ id: id2, wsUrl: info.KeepAlive?.wsUrl });
+    }
+  }
+  return clearedArr;
+};
+var FIVE_HOURS = 5 * 60 * 60 * 1000;
+setInterval(() => {
+  clearKeepAlive();
+}, FIVE_HOURS);
 
 // agent/routes/workspace/index.ts
 app.route({
   path: "cnb",
   key: "start-workspace",
   description: "启动开发工作空间, 参数 repo",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33852,7 +37200,7 @@ app.route({
   path: "cnb",
   key: "list-workspace",
   description: "获取cnb开发工作空间列表，可选参数 status=running 获取运行中的环境",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33881,7 +37229,7 @@ app.route({
   path: "cnb",
   key: "get-workspace",
   description: "获取工作空间详情，通过 repo 和 sn 获取",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33910,7 +37258,7 @@ app.route({
   path: "cnb",
   key: "delete-workspace",
   description: "删除工作空间，通过 pipelineId 或 sn",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33947,7 +37295,7 @@ app.route({
   path: "cnb",
   key: "stop-workspace",
   description: "停止工作空间，通过 pipelineId 或 sn",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -33971,33 +37319,35 @@ app.route({
 }).addTo(app);
 
 // agent/routes/call/index.ts
-app.route({
-  path: "call",
-  key: "",
-  description: "调用",
-  middleware: ["auth"],
-  metadata: {
-    tags: ["opencode"],
-    ...createSkill({
-      skill: "call-app",
-      title: "调用app应用",
-      summary: "调用router的应用, 参数path, key, payload",
-      args: {
-        path: tool2.schema.string().describe("应用路径，例如 cnb"),
-        key: tool2.schema.string().optional().describe("应用key，例如 list-repos"),
-        payload: tool2.schema.object({}).optional().describe("调用参数")
-      }
-    })
-  }
-}).define(async (ctx) => {
-  const { path: path2, key } = ctx.query;
-  console.log("call app", ctx.query);
-  if (!path2) {
-    ctx.throw("路径path不能为空");
-  }
-  const res = await ctx.run({ path: path2, key, payload: ctx.query.payload || {} });
-  ctx.forward(res);
-}).addTo(app);
+if (!app.hasRoute("call")) {
+  app.route({
+    path: "call",
+    key: "",
+    description: "调用",
+    middleware: ["admin-auth"],
+    metadata: {
+      tags: ["opencode"],
+      ...createSkill({
+        skill: "call-app",
+        title: "调用app应用",
+        summary: "调用router的应用, 参数path, key, payload",
+        args: {
+          path: tool2.schema.string().describe("应用路径，例如 cnb"),
+          key: tool2.schema.string().optional().describe("应用key，例如 list-repos"),
+          payload: tool2.schema.object({}).optional().describe("调用参数")
+        }
+      })
+    }
+  }).define(async (ctx) => {
+    const { path: path2, key } = ctx.query;
+    console.log("call app", ctx.query);
+    if (!path2) {
+      ctx.throw("路径path不能为空");
+    }
+    const res = await ctx.run({ path: path2, key, payload: ctx.query.payload || {} });
+    ctx.forward(res);
+  }).addTo(app);
+}
 
 // src/common/cnb-env.ts
 var CNB_ENV = {
@@ -34024,7 +37374,7 @@ app.route({
   path: "cnb",
   key: "get-cnb-port-uri",
   description: "获取当前cnb工作空间的port代理uri",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -34049,7 +37399,7 @@ app.route({
   path: "cnb",
   key: "get-cnb-vscode-uri",
   description: "获取当前cnb工作空间的vscode代理uri, 包括多种访问方式, 如web、vscode、codebuddy、cursor、ssh",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -34110,7 +37460,7 @@ app.route({
   path: "cnb",
   key: "set-cnb-cookie",
   description: "设置当前cnb工作空间的cookie环境变量",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -34135,7 +37485,7 @@ app.route({
   path: "cnb",
   key: "get-cnb-cookie",
   description: "获取当前cnb工作空间的cookie环境变量",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -34150,17 +37500,17 @@ app.route({
 }).addTo(app);
 
 // node_modules/.pnpm/@kevisual+ai@0.0.24/node_modules/@kevisual/ai/dist/ai-provider-browser.js
-var __create2 = Object.create;
-var __getProtoOf2 = Object.getPrototypeOf;
+var __create3 = Object.create;
+var __getProtoOf3 = Object.getPrototypeOf;
 var __defProp3 = Object.defineProperty;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getOwnPropNames3 = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __toESM2 = (mod, isNodeMode, target) => {
-  target = mod != null ? __create2(__getProtoOf2(mod)) : {};
+var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+var __toESM3 = (mod, isNodeMode, target) => {
+  target = mod != null ? __create3(__getProtoOf3(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames2(mod))
-    if (!__hasOwnProp2.call(to, key))
+  for (let key of __getOwnPropNames3(mod))
+    if (!__hasOwnProp3.call(to, key))
       __defProp3(to, key, {
         get: () => mod[key],
         enumerable: true
@@ -34174,14 +37524,14 @@ var __toCommonJS = (from) => {
     return entry;
   entry = __defProp3({}, "__esModule", { value: true });
   if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames2(from).map((key) => !__hasOwnProp2.call(entry, key) && __defProp3(entry, key, {
+    __getOwnPropNames3(from).map((key) => !__hasOwnProp3.call(entry, key) && __defProp3(entry, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     }));
   __moduleCache.set(from, entry);
   return entry;
 };
-var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJS3 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export2 = (target, all) => {
   for (var name in all)
     __defProp3(target, name, {
@@ -36351,7 +39701,7 @@ var init_events = __esm(() => {
   Object.assign(EventEmitter4, { once: once2, getEventListeners, getMaxListeners: getMaxListeners2, setMaxListeners: setMaxListeners2, EventEmitter: EventEmitter4, usingDomains: false, captureRejectionSymbol, errorMonitor: kErrorMonitor, addAbortListener, init: EventEmitter4, listenerCount: listenerCount2 });
   events_default = EventEmitter4;
 });
-var require_stream = __commonJS2((exports, module) => {
+var require_stream2 = __commonJS3((exports, module) => {
   var __commonJS22 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
   var require_primordials = __commonJS22((exports2, module2) => {
 
@@ -40188,7 +43538,7 @@ var require_stream = __commonJS2((exports, module) => {
   });
   var require_promises = __commonJS22((exports2, module2) => {
     var { ArrayPrototypePop, Promise: Promise2 } = require_primordials(), { isIterable, isNodeStream, isWebStream } = require_utils(), { pipelineImpl: pl2 } = require_pipeline(), { finished } = require_end_of_stream();
-    require_stream2();
+    require_stream22();
     function pipeline(...streams) {
       return new Promise2((resolve, reject) => {
         let signal, end, lastArg = streams[streams.length - 1];
@@ -40206,7 +43556,7 @@ var require_stream = __commonJS2((exports, module) => {
     }
     module2.exports = { finished, pipeline };
   });
-  var require_stream2 = __commonJS22((exports2, module2) => {
+  var require_stream22 = __commonJS22((exports2, module2) => {
     var { Buffer: Buffer3 } = (init_buffer(), __toCommonJS(exports_buffer)), { ObjectDefineProperty, ObjectKeys, ReflectApply } = require_primordials(), { promisify: { custom: customPromisify } } = require_util(), { streamReturningOperators, promiseReturningOperators } = require_operators(), { codes: { ERR_ILLEGAL_CONSTRUCTOR } } = require_errors(), compose = require_compose(), { setDefaultHighWaterMark, getDefaultHighWaterMark } = require_state(), { pipeline } = require_pipeline(), { destroyer } = require_destroy(), eos = require_end_of_stream(), promises = require_promises(), utils = require_utils(), Stream = module2.exports = require_legacy().Stream;
     Stream.isDestroyed = utils.isDestroyed;
     Stream.isDisturbed = utils.isDisturbed;
@@ -40260,9 +43610,9 @@ var require_stream = __commonJS2((exports, module) => {
     };
   });
   var require_ours = __commonJS22((exports2, module2) => {
-    var Stream = require_stream();
+    var Stream = require_stream2();
     {
-      let CustomStream = require_stream2(), promises = require_promises(), originalDestroy = CustomStream.Readable.destroy;
+      let CustomStream = require_stream22(), promises = require_promises(), originalDestroy = CustomStream.Readable.destroy;
       module2.exports = CustomStream.Readable, module2.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer, module2.exports._isUint8Array = CustomStream._isUint8Array, module2.exports.isDisturbed = CustomStream.isDisturbed, module2.exports.isErrored = CustomStream.isErrored, module2.exports.isReadable = CustomStream.isReadable, module2.exports.Readable = CustomStream.Readable, module2.exports.Writable = CustomStream.Writable, module2.exports.Duplex = CustomStream.Duplex, module2.exports.Transform = CustomStream.Transform, module2.exports.PassThrough = CustomStream.PassThrough, module2.exports.addAbortSignal = CustomStream.addAbortSignal, module2.exports.finished = CustomStream.finished, module2.exports.destroy = CustomStream.destroy, module2.exports.destroy = originalDestroy, module2.exports.pipeline = CustomStream.pipeline, module2.exports.compose = CustomStream.compose, Object.defineProperty(CustomStream, "promises", { configurable: true, enumerable: true, get() {
         return promises;
       } }), module2.exports.Stream = CustomStream.Stream;
@@ -40445,7 +43795,7 @@ var require_buffer;
 var require_node;
 var require_base2;
 var require_der;
-var require_constants;
+var require_constants2;
 var require_der2;
 var require_pem;
 var require_decoders;
@@ -41412,27 +44762,27 @@ var init_crypto = __esm(() => {
       exports.pbkdf2Sync = nativePBKDF2Sync, exports.pbkdf2 = nativePBKDF2;
   });
   require_browserify_cipher = __commonJS22((exports) => {
-    var crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
-    exports.createCipher = exports.Cipher = crypto2.createCipher;
-    exports.createCipheriv = exports.Cipheriv = crypto2.createCipheriv;
-    exports.createDecipher = exports.Decipher = crypto2.createDecipher;
-    exports.createDecipheriv = exports.Decipheriv = crypto2.createDecipheriv;
-    exports.listCiphers = exports.getCiphers = crypto2.getCiphers;
+    var crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
+    exports.createCipher = exports.Cipher = crypto22.createCipher;
+    exports.createCipheriv = exports.Cipheriv = crypto22.createCipheriv;
+    exports.createDecipher = exports.Decipher = crypto22.createDecipher;
+    exports.createDecipheriv = exports.Decipheriv = crypto22.createDecipheriv;
+    exports.listCiphers = exports.getCiphers = crypto22.getCiphers;
   });
   require_diffie_hellman = __commonJS22((exports) => {
-    var crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
-    exports.DiffieHellmanGroup = crypto2.DiffieHellmanGroup;
-    exports.createDiffieHellmanGroup = crypto2.createDiffieHellmanGroup;
-    exports.getDiffieHellman = crypto2.getDiffieHellman;
-    exports.createDiffieHellman = crypto2.createDiffieHellman;
-    exports.DiffieHellman = crypto2.DiffieHellman;
+    var crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
+    exports.DiffieHellmanGroup = crypto22.DiffieHellmanGroup;
+    exports.createDiffieHellmanGroup = crypto22.createDiffieHellmanGroup;
+    exports.getDiffieHellman = crypto22.getDiffieHellman;
+    exports.createDiffieHellman = crypto22.createDiffieHellman;
+    exports.DiffieHellman = crypto22.DiffieHellman;
   });
   require_browserify_sign = __commonJS22((exports) => {
-    var crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
-    exports.createSign = crypto2.createSign;
-    exports.Sign = crypto2.Sign;
-    exports.createVerify = crypto2.createVerify;
-    exports.Verify = crypto2.Verify;
+    var crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
+    exports.createSign = crypto22.createSign;
+    exports.Sign = crypto22.Sign;
+    exports.createVerify = crypto22.createVerify;
+    exports.Verify = crypto22.Verify;
   });
   require_package2 = __commonJS22((exports, module) => {
     module.exports = { name: "elliptic", version: "6.6.1", description: "EC cryptography", main: "lib/elliptic.js", files: ["lib"], scripts: { lint: "eslint lib test", "lint:fix": "npm run lint -- --fix", unit: "istanbul test _mocha --reporter=spec test/index.js", test: "npm run lint && npm run unit", version: "grunt dist && git add dist/" }, repository: { type: "git", url: "git@github.com:indutny/elliptic" }, keywords: ["EC", "Elliptic", "curve", "Cryptography"], author: "Fedor Indutny <fedor@indutny.com>", license: "MIT", bugs: { url: "https://github.com/indutny/elliptic/issues" }, homepage: "https://github.com/indutny/elliptic", devDependencies: { brfs: "^2.0.2", coveralls: "^3.1.0", eslint: "^7.6.0", grunt: "^1.2.1", "grunt-browserify": "^5.3.0", "grunt-cli": "^1.3.2", "grunt-contrib-connect": "^3.0.0", "grunt-contrib-copy": "^1.0.0", "grunt-contrib-uglify": "^5.0.0", "grunt-mocha-istanbul": "^5.0.2", "grunt-saucelabs": "^9.0.1", istanbul: "^0.4.5", mocha: "^8.0.1" }, dependencies: { "bn.js": "^4.11.9", brorand: "^1.1.0", "hash.js": "^1.0.0", "hmac-drbg": "^1.0.1", inherits: "^2.0.4", "minimalistic-assert": "^1.0.1", "minimalistic-crypto-utils": "^1.0.1" } };
@@ -43011,13 +46361,13 @@ var init_crypto = __esm(() => {
         };
     } else
       try {
-        if (crypto2 = (init_crypto(), __toCommonJS(exports_crypto)), typeof crypto2.randomBytes !== "function")
+        if (crypto22 = (init_crypto(), __toCommonJS(exports_crypto)), typeof crypto22.randomBytes !== "function")
           throw Error("Not supported");
         Rand.prototype._rand = function(n) {
-          return crypto2.randomBytes(n);
+          return crypto22.randomBytes(n);
         };
       } catch (e) {}
-    var crypto2;
+    var crypto22;
   });
   require_base = __commonJS22((exports, module) => {
     var BN = require_bn(), utils = require_utils2(), getNAF = utils.getNAF, getJSF = utils.getJSF, assert3 = utils.assert;
@@ -48525,13 +51875,13 @@ var init_crypto = __esm(() => {
     base.Node = require_node();
   });
   require_der = __commonJS22((exports) => {
-    var constants23 = require_constants();
+    var constants23 = require_constants2();
     exports.tagClass = { 0: "universal", 1: "application", 2: "context", 3: "private" };
     exports.tagClassByName = constants23._reverse(exports.tagClass);
     exports.tag = { 0: "end", 1: "bool", 2: "int", 3: "bitstr", 4: "octstr", 5: "null_", 6: "objid", 7: "objDesc", 8: "external", 9: "real", 10: "enum", 11: "embed", 12: "utf8str", 13: "relativeOid", 16: "seq", 17: "set", 18: "numstr", 19: "printstr", 20: "t61str", 21: "videostr", 22: "ia5str", 23: "utctime", 24: "gentime", 25: "graphstr", 26: "iso646str", 27: "genstr", 28: "unistr", 29: "charstr", 30: "bmpstr" };
     exports.tagByName = constants23._reverse(exports.tag);
   });
-  require_constants = __commonJS22((exports) => {
+  require_constants2 = __commonJS22((exports) => {
     var constants23 = exports;
     constants23._reverse = function(map3) {
       var res = {};
@@ -48994,7 +52344,7 @@ var init_crypto = __esm(() => {
     asn1.bignum = require_bn3();
     asn1.define = require_api().define;
     asn1.base = require_base2();
-    asn1.constants = require_constants();
+    asn1.constants = require_constants2();
     asn1.decoders = require_decoders();
     asn1.encoders = require_encoders();
   });
@@ -49070,7 +52420,7 @@ var init_crypto = __esm(() => {
     module.exports = { "2.16.840.1.101.3.4.1.1": "aes-128-ecb", "2.16.840.1.101.3.4.1.2": "aes-128-cbc", "2.16.840.1.101.3.4.1.3": "aes-128-ofb", "2.16.840.1.101.3.4.1.4": "aes-128-cfb", "2.16.840.1.101.3.4.1.21": "aes-192-ecb", "2.16.840.1.101.3.4.1.22": "aes-192-cbc", "2.16.840.1.101.3.4.1.23": "aes-192-ofb", "2.16.840.1.101.3.4.1.24": "aes-192-cfb", "2.16.840.1.101.3.4.1.41": "aes-256-ecb", "2.16.840.1.101.3.4.1.42": "aes-256-cbc", "2.16.840.1.101.3.4.1.43": "aes-256-ofb", "2.16.840.1.101.3.4.1.44": "aes-256-cfb" };
   });
   require_hash_base = __commonJS22((exports, module) => {
-    var Buffer22 = require_safe_buffer().Buffer, Transform = require_stream().Transform, inherits2 = require_inherits();
+    var Buffer22 = require_safe_buffer().Buffer, Transform = require_stream2().Transform, inherits2 = require_inherits();
     function HashBase(blockSize) {
       Transform.call(this), this._block = Buffer22.allocUnsafe(blockSize), this._blockSize = blockSize, this._blockOffset = 0, this._length = [0, 0, 0, 0], this._finalized = false;
     }
@@ -49218,12 +52568,12 @@ var init_crypto = __esm(() => {
     module.exports = EVP_BytesToKey;
   });
   require_browserify_aes = __commonJS22((exports) => {
-    var crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
-    exports.createCipher = exports.Cipher = crypto2.createCipher;
-    exports.createCipheriv = exports.Cipheriv = crypto2.createCipheriv;
-    exports.createDecipher = exports.Decipher = crypto2.createDecipher;
-    exports.createDecipheriv = exports.Decipheriv = crypto2.createDecipheriv;
-    exports.listCiphers = exports.getCiphers = crypto2.getCiphers;
+    var crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
+    exports.createCipher = exports.Cipher = crypto22.createCipher;
+    exports.createCipheriv = exports.Cipheriv = crypto22.createCipheriv;
+    exports.createDecipher = exports.Decipher = crypto22.createDecipher;
+    exports.createDecipheriv = exports.Decipheriv = crypto22.createDecipheriv;
+    exports.listCiphers = exports.getCiphers = crypto22.getCiphers;
   });
   require_fixProc = __commonJS22((exports, module) => {
     var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r+/=]+)[\n\r]+/m, startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m, fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r+/=]+)-----END \1-----$/m, evp = require_evp_bytestokey(), ciphers = require_browserify_aes(), Buffer22 = require_safe_buffer().Buffer;
@@ -52338,22 +55688,22 @@ var init_crypto = __esm(() => {
     };
   });
   require_public_encrypt = __commonJS22((exports) => {
-    var crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
-    if (typeof crypto2.publicEncrypt !== "function")
-      crypto2 = require_browser2();
-    exports.publicEncrypt = crypto2.publicEncrypt;
-    exports.privateDecrypt = crypto2.privateDecrypt;
-    if (typeof crypto2.privateEncrypt !== "function")
+    var crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
+    if (typeof crypto22.publicEncrypt !== "function")
+      crypto22 = require_browser2();
+    exports.publicEncrypt = crypto22.publicEncrypt;
+    exports.privateDecrypt = crypto22.privateDecrypt;
+    if (typeof crypto22.privateEncrypt !== "function")
       exports.privateEncrypt = require_browser2().privateEncrypt;
     else
-      exports.privateEncrypt = crypto2.privateEncrypt;
-    if (typeof crypto2.publicDecrypt !== "function")
+      exports.privateEncrypt = crypto22.privateEncrypt;
+    if (typeof crypto22.publicDecrypt !== "function")
       exports.publicDecrypt = require_browser2().publicDecrypt;
     else
-      exports.publicDecrypt = crypto2.publicDecrypt;
+      exports.publicDecrypt = crypto22.publicDecrypt;
   });
   require_browser3 = __commonJS22((exports) => {
-    var safeBuffer = require_safe_buffer(), randombytes = require_randombytes(), Buffer22 = safeBuffer.Buffer, kBufferMaxLength = safeBuffer.kMaxLength, crypto2 = globalThis.crypto || globalThis.msCrypto, kMaxUint32 = Math.pow(2, 32) - 1;
+    var safeBuffer = require_safe_buffer(), randombytes = require_randombytes(), Buffer22 = safeBuffer.Buffer, kBufferMaxLength = safeBuffer.kMaxLength, crypto22 = globalThis.crypto || globalThis.msCrypto, kMaxUint32 = Math.pow(2, 32) - 1;
     function assertOffset(offset, length) {
       if (typeof offset !== "number" || offset !== offset)
         throw TypeError("offset must be a number");
@@ -52370,7 +55720,7 @@ var init_crypto = __esm(() => {
       if (size + offset > length || size > kBufferMaxLength)
         throw RangeError("buffer too small");
     }
-    crypto2 && crypto2.getRandomValues, exports.randomFill = randomFill, exports.randomFillSync = randomFillSync;
+    crypto22 && crypto22.getRandomValues, exports.randomFill = randomFill, exports.randomFillSync = randomFillSync;
     function randomFill(buf, offset, size, cb) {
       if (!Buffer22.isBuffer(buf) && !(buf instanceof globalThis.Uint8Array))
         throw TypeError('"buf" argument must be a Buffer or Uint8Array');
@@ -52407,9 +55757,9 @@ var init_crypto = __esm(() => {
     }
   });
   require_randomfill = __commonJS22((exports, module) => {
-    var crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
-    if (typeof crypto2.randomFill === "function" && typeof crypto2.randomFillSync === "function")
-      exports.randomFill = crypto2.randomFill, exports.randomFillSync = crypto2.randomFillSync;
+    var crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
+    if (typeof crypto22.randomFill === "function" && typeof crypto22.randomFillSync === "function")
+      exports.randomFill = crypto22.randomFill, exports.randomFillSync = crypto22.randomFillSync;
     else
       module.exports = require_browser3();
   });
@@ -52506,7 +55856,7 @@ https://github.com/browserify/crypto-browserify`);
   webcrypto2 = crypto;
   crypto_default = crypto;
 });
-var require_core = __commonJS2((exports, module) => {
+var require_core = __commonJS3((exports, module) => {
   (function(root, factory) {
     if (typeof exports === "object") {
       module.exports = exports = factory();
@@ -52517,37 +55867,37 @@ var require_core = __commonJS2((exports, module) => {
     }
   })(exports, function() {
     var CryptoJS = CryptoJS || function(Math2, undefined2) {
-      var crypto2;
+      var crypto22;
       if (typeof window !== "undefined" && window.crypto) {
-        crypto2 = window.crypto;
+        crypto22 = window.crypto;
       }
       if (typeof self !== "undefined" && self.crypto) {
-        crypto2 = self.crypto;
+        crypto22 = self.crypto;
       }
       if (typeof globalThis !== "undefined" && globalThis.crypto) {
-        crypto2 = globalThis.crypto;
+        crypto22 = globalThis.crypto;
       }
-      if (!crypto2 && typeof window !== "undefined" && window.msCrypto) {
-        crypto2 = window.msCrypto;
+      if (!crypto22 && typeof window !== "undefined" && window.msCrypto) {
+        crypto22 = window.msCrypto;
       }
-      if (!crypto2 && typeof global !== "undefined" && global.crypto) {
-        crypto2 = global.crypto;
+      if (!crypto22 && typeof global !== "undefined" && global.crypto) {
+        crypto22 = global.crypto;
       }
-      if (!crypto2 && true) {
+      if (!crypto22 && true) {
         try {
-          crypto2 = (init_crypto(), __toCommonJS(exports_crypto));
+          crypto22 = (init_crypto(), __toCommonJS(exports_crypto));
         } catch (err) {}
       }
       var cryptoSecureRandomInt = function() {
-        if (crypto2) {
-          if (typeof crypto2.getRandomValues === "function") {
+        if (crypto22) {
+          if (typeof crypto22.getRandomValues === "function") {
             try {
-              return crypto2.getRandomValues(new Uint32Array(1))[0];
+              return crypto22.getRandomValues(new Uint32Array(1))[0];
             } catch (err) {}
           }
-          if (typeof crypto2.randomBytes === "function") {
+          if (typeof crypto22.randomBytes === "function") {
             try {
-              return crypto2.randomBytes(4).readInt32LE();
+              return crypto22.randomBytes(4).readInt32LE();
             } catch (err) {}
           }
         }
@@ -52789,7 +56139,7 @@ var require_core = __commonJS2((exports, module) => {
     return CryptoJS;
   });
 });
-var require_enc_base64 = __commonJS2((exports, module) => {
+var require_enc_base64 = __commonJS3((exports, module) => {
   (function(root, factory) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core());
@@ -52867,7 +56217,7 @@ var require_enc_base64 = __commonJS2((exports, module) => {
     return CryptoJS.enc.Base64;
   });
 });
-var require_md52 = __commonJS2((exports, module) => {
+var require_md52 = __commonJS3((exports, module) => {
   (function(root, factory) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core());
@@ -53042,7 +56392,7 @@ var require_md52 = __commonJS2((exports, module) => {
     return CryptoJS.MD5;
   });
 });
-var require_sha1 = __commonJS2((exports, module) => {
+var require_sha1 = __commonJS3((exports, module) => {
   (function(root, factory) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core());
@@ -53129,7 +56479,7 @@ var require_sha1 = __commonJS2((exports, module) => {
     return CryptoJS.SHA1;
   });
 });
-var require_hmac2 = __commonJS2((exports, module) => {
+var require_hmac2 = __commonJS3((exports, module) => {
   (function(root, factory) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core());
@@ -53189,7 +56539,7 @@ var require_hmac2 = __commonJS2((exports, module) => {
     })();
   });
 });
-var require_evpkdf = __commonJS2((exports, module) => {
+var require_evpkdf = __commonJS3((exports, module) => {
   (function(root, factory, undef) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core(), require_sha1(), require_hmac2());
@@ -53246,7 +56596,7 @@ var require_evpkdf = __commonJS2((exports, module) => {
     return CryptoJS.EvpKDF;
   });
 });
-var require_cipher_core = __commonJS2((exports, module) => {
+var require_cipher_core = __commonJS3((exports, module) => {
   (function(root, factory, undef) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core(), require_evpkdf());
@@ -53542,7 +56892,7 @@ var require_cipher_core = __commonJS2((exports, module) => {
     }();
   });
 });
-var require_aes = __commonJS2((exports, module) => {
+var require_aes = __commonJS3((exports, module) => {
   (function(root, factory, undef) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core(), require_enc_base64(), require_md52(), require_evpkdf(), require_cipher_core());
@@ -53692,7 +57042,7 @@ var require_aes = __commonJS2((exports, module) => {
     return CryptoJS.AES;
   });
 });
-var require_enc_utf8 = __commonJS2((exports, module) => {
+var require_enc_utf8 = __commonJS3((exports, module) => {
   (function(root, factory) {
     if (typeof exports === "object") {
       module.exports = exports = factory(require_core());
@@ -53995,8 +57345,8 @@ class CNBChat extends BaseChat {
     };
   }
 }
-var import_aes = __toESM2(require_aes(), 1);
-var import_enc_utf8 = __toESM2(require_enc_utf8(), 1);
+var import_aes = __toESM3(require_aes(), 1);
+var import_enc_utf8 = __toESM3(require_enc_utf8(), 1);
 var CryptoJS = { AES: import_aes.default, enc: { Utf8: import_enc_utf8.default } };
 
 // agent/routes/knowledge/ai.ts
@@ -54004,7 +57354,7 @@ app.route({
   path: "cnb",
   key: "cnb-ai-chat",
   description: "调用cnb的知识库ai对话功能进行聊天",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -54106,7 +57456,7 @@ app.route({
   path: "cnb",
   key: "cnb-rag-query",
   description: "调用cnb的知识库RAG查询功能进行问答",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -54169,7 +57519,7 @@ app.route({
   path: "cnb",
   key: "list-issues",
   description: "查询 Issue 列表, 参数 repo, state, keyword, labels, page, page_size 等",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -54220,7 +57570,7 @@ app.route({
   path: "cnb",
   key: "create-issue",
   description: "创建 Issue, 参数 repo, title, body, assignees, labels, priority",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({
@@ -54260,7 +57610,7 @@ app.route({
   path: "cnb",
   key: "complete-issue",
   description: "完成 Issue, 参数 repo, issueNumber",
-  middleware: ["auth"],
+  middleware: ["admin-auth"],
   metadata: {
     tags: ["opencode"],
     ...createSkill({