koishi-plugin-chat-patch 5.5.0 → 5.6.0

package/lib/index.js

@@ -365,25 +365,93 @@ function isUsableGroupContact(item) {
   return true;
 }
 __name(isUsableGroupContact, "isUsableGroupContact");
+var sharedDatabases = /* @__PURE__ */ new Map();
+async function acquireSharedDatabase(dir) {
+  let shared = sharedDatabases.get(dir);
+  if (shared?.closing) {
+    await shared.closing.catch(() => void 0);
+    shared = sharedDatabases.get(dir);
+  }
+  if (!shared) {
+    shared = {
+      dir,
+      db: new import_level.Level(dir, { keyEncoding: "utf8", valueEncoding: "utf8" }),
+      refs: 0,
+      opened: false
+    };
+    sharedDatabases.set(dir, shared);
+  }
+  shared.refs += 1;
+  return shared;
+}
+__name(acquireSharedDatabase, "acquireSharedDatabase");
+async function releaseSharedDatabase(shared) {
+  shared.refs -= 1;
+  if (shared.refs > 0) return false;
+  if (shared.closing) {
+    await shared.closing;
+    return true;
+  }
+  if (!shared.opened) {
+    if (sharedDatabases.get(shared.dir) === shared) sharedDatabases.delete(shared.dir);
+    return true;
+  }
+  const closing = shared.db.close().catch(() => void 0).finally(() => {
+    shared.opened = false;
+    if (sharedDatabases.get(shared.dir) === shared) sharedDatabases.delete(shared.dir);
+  });
+  shared.closing = closing;
+  await closing;
+  return true;
+}
+__name(releaseSharedDatabase, "releaseSharedDatabase");
 var _ChatDatabase = class _ChatDatabase {
   constructor(ctx, config, logger) {
     this.ctx = ctx;
     this.config = config;
     this.logger = logger;
-    this.opened = false;
-    const dir = import_node_path.default.resolve(ctx.baseDir, "data", "chat-patch", "db");
-    this.db = new import_level.Level(dir, { keyEncoding: "utf8", valueEncoding: "utf8" });
+    this.dir = import_node_path.default.resolve(ctx.baseDir, "data", "chat-patch", "db");
+  }
+  get db() {
+    if (!this.shared) throw new Error("LevelDB is not initialized");
+    return this.shared.db;
   }
   async initialize() {
-    await this.db.open();
-    this.opened = true;
-    this.logger.logInfo("LevelDB 已打开:", this.db.location);
+    this.shared = await acquireSharedDatabase(this.dir);
+    try {
+      await this.ensureOpen();
+      this.logger.logInfo("LevelDB 已打开:", this.shared.db.location);
+    } catch (error) {
+      await this.releaseShared();
+      throw error;
+    }
   }
   async dispose() {
-    if (!this.opened) return;
-    await this.db.close();
-    this.opened = false;
-    this.logger.logInfo("LevelDB closed");
+    const closed = await this.releaseShared();
+    if (closed) this.logger.logInfo("LevelDB closed");
+  }
+  async ensureOpen() {
+    const shared = this.shared;
+    if (!shared || shared.opened) return;
+    if (shared.opening) {
+      await shared.opening;
+      return;
+    }
+    const opening = shared.db.open().then(() => {
+      shared.opened = true;
+    });
+    shared.opening = opening;
+    try {
+      await opening;
+    } finally {
+      shared.opening = void 0;
+    }
+  }
+  async releaseShared() {
+    const shared = this.shared;
+    this.shared = void 0;
+    if (shared) return releaseSharedDatabase(shared);
+    return false;
   }
   async clearAll() {
     await this.db.clear();
@@ -842,100 +910,129 @@ var ChatDatabase = _ChatDatabase;
 
 // src/recorder.ts
 var MESSAGE_TYPES = /* @__PURE__ */ new Set(["message", "message-created"]);
+function getObject(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+__name(getObject, "getObject");
+function getString2(value) {
+  return typeof value === "string" ? value : "";
+}
+__name(getString2, "getString");
+function getNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+__name(getNumber, "getNumber");
 function normalizeGroupId2(value) {
   return String(value);
 }
 __name(normalizeGroupId2, "normalizeGroupId");
+function isPrivateChannelType3(value) {
+  const num = Number(value);
+  if (Number.isFinite(num)) return num === 1;
+  const text = String(value ?? "").toLowerCase();
+  return text === "direct" || text === "private";
+}
+__name(isPrivateChannelType3, "isPrivateChannelType");
 var _Recorder = class _Recorder {
-  constructor(ctx, config, database, media, contactCache, logger) {
-    this.ctx = ctx;
+  constructor(config, database, media, contactCache, logger) {
     this.config = config;
     this.database = database;
     this.media = media;
     this.contactCache = contactCache;
     this.logger = logger;
   }
-  start() {
-    this.ctx.on("internal/session", (session) => {
-      if (session.type === "message-deleted") {
-        void this.handleMessageDeleted(session).catch((error) => {
-          this.logger.warn("处理消息撤回失败:", error);
-        });
-        return;
-      }
-      void this.handleSession(session);
-    });
+  // 后端直连 Satori 后，由 SatoriGateway 逐条送入原始事件
+  async handleEvent(body) {
+    const type = getString2(body.type);
+    const login = getObject(body.login);
+    const platform = getString2(body.platform) || getString2(login.platform);
+    if (this.isBlocked(platform)) return false;
+    if (type === "message-deleted") {
+      await this.handleMessageDeleted(body);
+      return true;
+    }
+    if (!MESSAGE_TYPES.has(type)) return false;
+    await this.handleMessageCreated(body);
+    return true;
   }
   isBlocked(platform) {
     return (this.config.blockedPlatforms ?? []).some((item) => {
       return item.exactMatch ? platform === item.platformName : platform.includes(item.platformName);
     });
   }
-  async handleSession(session) {
-    const platform = session.platform || "unknown";
-    if (!MESSAGE_TYPES.has(session.type)) return;
-    if (this.isBlocked(platform)) return;
-    const event = session.toJSON();
-    const message = event.message;
+  async handleMessageCreated(body) {
+    const login = getObject(body.login);
+    const loginUser = getObject(login.user);
+    const platform = getString2(body.platform) || getString2(login.platform);
+    const selfId = getString2(body.self_id) || getString2(body.selfId) || getString2(loginUser.id);
+    const message = getObject(body.message);
+    const channel = getObject(body.channel);
+    const guild = getObject(body.guild);
+    const user = getObject(body.user);
+    const sn = getNumber(body.sn);
+    const timestamp = getNumber(body.timestamp) || Date.now();
     const record = {
-      id: message?.id || `local-${event.sn}`,
-      sequence: event.sn,
-      type: session.type,
+      id: getString2(message.id) || `satori-${sn}`,
+      sequence: sn,
+      type: getString2(body.type),
       platform,
-      selfId: session.selfId,
-      channelId: session.channelId,
-      guildId: session.guildId,
-      userId: session.userId,
-      timestamp: session.timestamp,
-      timestampMs: session.timestamp,
+      selfId,
+      channelId: getString2(channel.id) || void 0,
+      guildId: getString2(guild.id) || void 0,
+      userId: getString2(user.id) || void 0,
+      timestamp,
+      timestampMs: timestamp,
       receivedAt: Date.now(),
-      content: session.content || message?.content,
-      elements: message?.elements,
-      raw: event
+      content: getString2(message.content) || getString2(message.raw_message) || void 0,
+      elements: Array.isArray(message.elements) ? message.elements : void 0,
+      raw: body
     };
     try {
       await this.database.appendMessage(record);
     } catch (error) {
       this.logger.warn("写入历史消息失败:", error);
     }
-    void this.cacheMessageContacts(event).catch((error) => {
+    void this.cacheMessageContacts(body).catch((error) => {
       this.logger.warn("缓存消息联系人失败:", error);
     });
-    void this.cacheMessageMedia(event).catch((error) => {
+    void this.cacheMessageMedia(message, getString2(channel.id)).catch((error) => {
       this.logger.warn("异步缓存消息媒体失败:", error);
     });
   }
-  async handleMessageDeleted(session) {
-    const platform = session.platform || "unknown";
-    if (this.isBlocked(platform)) return;
-    const event = session.toJSON();
-    const rawMessage = typeof event.message === "object" && event.message !== null ? event.message : {};
-    const messageId = session.messageId || String(rawMessage.id ?? "");
-    const channelId = String(
-      event.channel?.id || event.guild?.id || session.channelId || ""
-    );
+  async handleMessageDeleted(body) {
+    const login = getObject(body.login);
+    const loginUser = getObject(login.user);
+    const platform = getString2(body.platform) || getString2(login.platform);
+    const selfId = getString2(body.self_id) || getString2(body.selfId) || getString2(loginUser.id);
+    const message = getObject(body.message);
+    const channel = getObject(body.channel);
+    const guild = getObject(body.guild);
+    const messageId = getString2(message.id);
+    const channelId = getString2(channel.id) || getString2(guild.id);
     if (!messageId || !channelId) return;
     const patch = { revoked: true, revokedAt: Date.now() };
-    await this.database.updateMessageRevoked(platform, session.selfId, channelId, messageId, patch);
-    await this.database.updateSelfMessageByMessageId(platform, session.selfId, channelId, messageId, patch);
-  }
-  async cacheMessageContacts(event) {
-    const platform = event.platform || "";
-    const selfId = event.selfId || "";
-    const user = event.user;
-    const guild = event.guild;
-    const channel = event.channel;
-    const member = event.member;
-    const userId = user?.id || "";
-    const guildId = guild?.id || "";
-    const channelId = channel?.id || "";
-    const channelType = String(channel?.type ?? "");
-    const isPrivateChannel = channelType === "1" || ["direct", "private"].includes(channelType.toLowerCase());
+    await this.database.updateMessageRevoked(platform, selfId, channelId, messageId, patch);
+    await this.database.updateSelfMessageByMessageId(platform, selfId, channelId, messageId, patch);
+  }
+  async cacheMessageContacts(body) {
+    const login = getObject(body.login);
+    const loginUser = getObject(login.user);
+    const platform = getString2(body.platform) || getString2(login.platform);
+    const selfId = getString2(body.self_id) || getString2(body.selfId) || getString2(loginUser.id);
+    const user = getObject(body.user);
+    const guild = getObject(body.guild);
+    const channel = getObject(body.channel);
+    const member = getObject(body.member);
+    const userId = getString2(user.id);
+    const guildId = getString2(guild.id);
+    const channelId = getString2(channel.id);
+    const isPrivateChannel = isPrivateChannelType3(channel.type);
     const groupId = guildId || (isPrivateChannel ? "" : normalizeGroupId2(channelId)) || "";
-    const userName = user?.name || user?.nick || member?.nick || member?.name || "";
-    const userAvatar = user?.avatar || member?.avatar || "";
-    const groupName = guild?.name || channel?.name || "";
-    const groupAvatar = guild?.avatar || "";
+    const userName = getString2(user.name) || getString2(user.nick) || getString2(member.nick) || getString2(member.name);
+    const userAvatar = getString2(user.avatar) || getString2(member.avatar);
+    const groupName = getString2(guild.name) || getString2(channel.name);
+    const groupAvatar = getString2(guild.avatar);
     if (groupId) {
       const groupItem = await this.contactCache.getGroup(
         platform,
@@ -945,7 +1042,7 @@ var _Recorder = class _Recorder {
         channelId || groupId,
         groupName,
         groupAvatar,
-        channel?.type
+        channel.type
       );
       if (userId) {
         const userItem = await this.contactCache.getUser(
@@ -969,9 +1066,9 @@ var _Recorder = class _Recorder {
               id: userId,
               user_id: userId,
               nickname: userName || userItem?.name,
-              card: member?.nick || member?.name || "",
+              card: member.nick || member.name || "",
               avatar: userItem?.avatar || userAvatar || void 0,
-              role: member?.title || ""
+              role: member.title || ""
             }
           }
         );
@@ -989,16 +1086,1255 @@ var _Recorder = class _Recorder {
       );
     }
   }
-  async cacheMessageMedia(event) {
-    const channelId = String(
-      event.channel?.id || event.guild?.id || ""
-    );
-    await this.media.cacheMessageMedia(event.message, channelId);
+  async cacheMessageMedia(message, channelId) {
+    await this.media.cacheMessageMedia(message, channelId);
   }
 };
 __name(_Recorder, "Recorder");
 var Recorder = _Recorder;
 
+// ../../node_modules/cosmokit/lib/index.mjs
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+function noop() {
+}
+__name(noop, "noop");
+__name2(noop, "noop");
+function isNullable(value) {
+  return value === null || value === void 0;
+}
+__name(isNullable, "isNullable");
+__name2(isNullable, "isNullable");
+function isNonNullable(value) {
+  return !isNullable(value);
+}
+__name(isNonNullable, "isNonNullable");
+__name2(isNonNullable, "isNonNullable");
+function isPlainObject(data) {
+  return data && typeof data === "object" && !Array.isArray(data);
+}
+__name(isPlainObject, "isPlainObject");
+__name2(isPlainObject, "isPlainObject");
+function filterKeys(object, filter2) {
+  return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter2(key, value)));
+}
+__name(filterKeys, "filterKeys");
+__name2(filterKeys, "filterKeys");
+function mapValues(object, transform) {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+__name(mapValues, "mapValues");
+__name2(mapValues, "mapValues");
+function pick(source, keys, forced) {
+  if (!keys) return { ...source };
+  const result = {};
+  for (const key of keys) {
+    if (forced || source[key] !== void 0) result[key] = source[key];
+  }
+  return result;
+}
+__name(pick, "pick");
+__name2(pick, "pick");
+function omit(source, keys) {
+  if (!keys) return { ...source };
+  const result = { ...source };
+  for (const key of keys) {
+    Reflect.deleteProperty(result, key);
+  }
+  return result;
+}
+__name(omit, "omit");
+__name2(omit, "omit");
+function defineProperty(object, key, value) {
+  return Object.defineProperty(object, key, { writable: true, value, enumerable: false });
+}
+__name(defineProperty, "defineProperty");
+__name2(defineProperty, "defineProperty");
+function contain(array1, array2) {
+  return array2.every((item) => array1.includes(item));
+}
+__name(contain, "contain");
+__name2(contain, "contain");
+function intersection(array1, array2) {
+  return array1.filter((item) => array2.includes(item));
+}
+__name(intersection, "intersection");
+__name2(intersection, "intersection");
+function difference(array1, array2) {
+  return array1.filter((item) => !array2.includes(item));
+}
+__name(difference, "difference");
+__name2(difference, "difference");
+function union(array1, array2) {
+  return Array.from(/* @__PURE__ */ new Set([...array1, ...array2]));
+}
+__name(union, "union");
+__name2(union, "union");
+function deduplicate(array) {
+  return [...new Set(array)];
+}
+__name(deduplicate, "deduplicate");
+__name2(deduplicate, "deduplicate");
+function remove(list, item) {
+  const index = list?.indexOf(item);
+  if (index >= 0) {
+    list.splice(index, 1);
+    return true;
+  } else {
+    return false;
+  }
+}
+__name(remove, "remove");
+__name2(remove, "remove");
+function makeArray(source) {
+  return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+}
+__name(makeArray, "makeArray");
+__name2(makeArray, "makeArray");
+function is(type, value) {
+  if (arguments.length === 1) return (value2) => is(type, value2);
+  return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+__name(is, "is");
+__name2(is, "is");
+function isArrayBufferLike(value) {
+  return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+__name(isArrayBufferLike, "isArrayBufferLike");
+__name2(isArrayBufferLike, "isArrayBufferLike");
+function isArrayBufferSource(value) {
+  return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+__name(isArrayBufferSource, "isArrayBufferSource");
+__name2(isArrayBufferSource, "isArrayBufferSource");
+var Binary;
+((Binary2) => {
+  Binary2.is = isArrayBufferLike;
+  Binary2.isSource = isArrayBufferSource;
+  function fromSource(source) {
+    if (ArrayBuffer.isView(source)) {
+      return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+    } else {
+      return source;
+    }
+  }
+  __name(fromSource, "fromSource");
+  Binary2.fromSource = fromSource;
+  __name2(fromSource, "fromSource");
+  function toBase64(source) {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(source).toString("base64");
+    }
+    let binary = "";
+    const bytes = new Uint8Array(source);
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  __name(toBase64, "toBase64");
+  Binary2.toBase64 = toBase64;
+  __name2(toBase64, "toBase64");
+  function fromBase64(source) {
+    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+    return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+  }
+  __name(fromBase64, "fromBase64");
+  Binary2.fromBase64 = fromBase64;
+  __name2(fromBase64, "fromBase64");
+  function toHex(source) {
+    if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+    return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  __name(toHex, "toHex");
+  Binary2.toHex = toHex;
+  __name2(toHex, "toHex");
+  function fromHex(source) {
+    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+    const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+    const buffer = [];
+    for (let i = 0; i < hex.length; i += 2) {
+      buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+    }
+    return Uint8Array.from(buffer).buffer;
+  }
+  __name(fromHex, "fromHex");
+  Binary2.fromHex = fromHex;
+  __name2(fromHex, "fromHex");
+})(Binary || (Binary = {}));
+var base64ToArrayBuffer = Binary.fromBase64;
+var arrayBufferToBase64 = Binary.toBase64;
+var hexToArrayBuffer = Binary.fromHex;
+var arrayBufferToHex = Binary.toHex;
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+  if (!source || typeof source !== "object") return source;
+  if (is("Date", source)) return new Date(source.valueOf());
+  if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+  if (isArrayBufferLike(source)) return source.slice(0);
+  if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+  const cached = refs.get(source);
+  if (cached) return cached;
+  if (Array.isArray(source)) {
+    const result2 = [];
+    refs.set(source, result2);
+    source.forEach((value, index) => {
+      result2[index] = Reflect.apply(clone, null, [value, refs]);
+    });
+    return result2;
+  }
+  const result = Object.create(Object.getPrototypeOf(source));
+  refs.set(source, result);
+  for (const key of Reflect.ownKeys(source)) {
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+    if ("value" in descriptor) {
+      descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+    }
+    Reflect.defineProperty(result, key, descriptor);
+  }
+  return result;
+}
+__name(clone, "clone");
+__name2(clone, "clone");
+function deepEqual(a, b, strict) {
+  if (a === b) return true;
+  if (!strict && isNullable(a) && isNullable(b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (!a || !b) return false;
+  function check(test, then) {
+    return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+  }
+  __name(check, "check");
+  __name2(check, "check");
+  return check(Array.isArray, (a2, b2) => a2.length === b2.length && a2.every((item, index) => deepEqual(item, b2[index]))) ?? check(is("Date"), (a2, b2) => a2.valueOf() === b2.valueOf()) ?? check(is("RegExp"), (a2, b2) => a2.source === b2.source && a2.flags === b2.flags) ?? check(isArrayBufferLike, (a2, b2) => {
+    if (a2.byteLength !== b2.byteLength) return false;
+    const viewA = new Uint8Array(a2);
+    const viewB = new Uint8Array(b2);
+    for (let i = 0; i < viewA.length; i++) {
+      if (viewA[i] !== viewB[i]) return false;
+    }
+    return true;
+  }) ?? Object.keys({ ...a, ...b }).every((key) => deepEqual(a[key], b[key], strict));
+}
+__name(deepEqual, "deepEqual");
+__name2(deepEqual, "deepEqual");
+function capitalize(source) {
+  return source.charAt(0).toUpperCase() + source.slice(1);
+}
+__name(capitalize, "capitalize");
+__name2(capitalize, "capitalize");
+function uncapitalize(source) {
+  return source.charAt(0).toLowerCase() + source.slice(1);
+}
+__name(uncapitalize, "uncapitalize");
+__name2(uncapitalize, "uncapitalize");
+function camelCase(source) {
+  return source.replace(/[_-][a-z]/g, (str) => str.slice(1).toUpperCase());
+}
+__name(camelCase, "camelCase");
+__name2(camelCase, "camelCase");
+function tokenize(source, delimiters, delimiter) {
+  const output = [];
+  let state = 0;
+  for (let i = 0; i < source.length; i++) {
+    const code = source.charCodeAt(i);
+    if (code >= 65 && code <= 90) {
+      if (state === 1) {
+        const next = source.charCodeAt(i + 1);
+        if (next >= 97 && next <= 122) {
+          output.push(delimiter);
+        }
+        output.push(code + 32);
+      } else {
+        if (state !== 0) {
+          output.push(delimiter);
+        }
+        output.push(code + 32);
+      }
+      state = 1;
+    } else if (code >= 97 && code <= 122) {
+      output.push(code);
+      state = 2;
+    } else if (delimiters.includes(code)) {
+      if (state !== 0) {
+        output.push(delimiter);
+      }
+      state = 0;
+    } else {
+      output.push(code);
+    }
+  }
+  return String.fromCharCode(...output);
+}
+__name(tokenize, "tokenize");
+__name2(tokenize, "tokenize");
+function paramCase(source) {
+  return tokenize(source, [45, 95], 45);
+}
+__name(paramCase, "paramCase");
+__name2(paramCase, "paramCase");
+function snakeCase(source) {
+  return tokenize(source, [45, 95], 95);
+}
+__name(snakeCase, "snakeCase");
+__name2(snakeCase, "snakeCase");
+var camelize = camelCase;
+var hyphenate = paramCase;
+function formatProperty(key) {
+  if (typeof key !== "string") return `[${key.toString()}]`;
+  return /^[a-z_$][\w$]*$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+}
+__name(formatProperty, "formatProperty");
+__name2(formatProperty, "formatProperty");
+function trimSlash(source) {
+  return source.replace(/\/$/, "");
+}
+__name(trimSlash, "trimSlash");
+__name2(trimSlash, "trimSlash");
+function sanitize(source) {
+  if (!source.startsWith("/")) source = "/" + source;
+  return trimSlash(source);
+}
+__name(sanitize, "sanitize");
+__name2(sanitize, "sanitize");
+var Time;
+((Time2) => {
+  Time2.millisecond = 1;
+  Time2.second = 1e3;
+  Time2.minute = Time2.second * 60;
+  Time2.hour = Time2.minute * 60;
+  Time2.day = Time2.hour * 24;
+  Time2.week = Time2.day * 7;
+  let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  function setTimezoneOffset(offset) {
+    timezoneOffset = offset;
+  }
+  __name(setTimezoneOffset, "setTimezoneOffset");
+  Time2.setTimezoneOffset = setTimezoneOffset;
+  __name2(setTimezoneOffset, "setTimezoneOffset");
+  function getTimezoneOffset() {
+    return timezoneOffset;
+  }
+  __name(getTimezoneOffset, "getTimezoneOffset");
+  Time2.getTimezoneOffset = getTimezoneOffset;
+  __name2(getTimezoneOffset, "getTimezoneOffset");
+  function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+    if (typeof date === "number") date = new Date(date);
+    if (offset === void 0) offset = timezoneOffset;
+    return Math.floor((date.valueOf() / Time2.minute - offset) / 1440);
+  }
+  __name(getDateNumber, "getDateNumber");
+  Time2.getDateNumber = getDateNumber;
+  __name2(getDateNumber, "getDateNumber");
+  function fromDateNumber(value, offset) {
+    const date = new Date(value * Time2.day);
+    if (offset === void 0) offset = timezoneOffset;
+    return new Date(+date + offset * Time2.minute);
+  }
+  __name(fromDateNumber, "fromDateNumber");
+  Time2.fromDateNumber = fromDateNumber;
+  __name2(fromDateNumber, "fromDateNumber");
+  const numeric = /\d+(?:\.\d+)?/.source;
+  const timeRegExp = new RegExp(`^${[
+    "w(?:eek(?:s)?)?",
+    "d(?:ay(?:s)?)?",
+    "h(?:our(?:s)?)?",
+    "m(?:in(?:ute)?(?:s)?)?",
+    "s(?:ec(?:ond)?(?:s)?)?"
+  ].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+  function parseTime(source) {
+    const capture = timeRegExp.exec(source);
+    if (!capture) return 0;
+    return (parseFloat(capture[1]) * Time2.week || 0) + (parseFloat(capture[2]) * Time2.day || 0) + (parseFloat(capture[3]) * Time2.hour || 0) + (parseFloat(capture[4]) * Time2.minute || 0) + (parseFloat(capture[5]) * Time2.second || 0);
+  }
+  __name(parseTime, "parseTime");
+  Time2.parseTime = parseTime;
+  __name2(parseTime, "parseTime");
+  function parseDate(date) {
+    const parsed = parseTime(date);
+    if (parsed) {
+      date = Date.now() + parsed;
+    } else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+    } else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
+      date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+    }
+    return date ? new Date(date) : /* @__PURE__ */ new Date();
+  }
+  __name(parseDate, "parseDate");
+  Time2.parseDate = parseDate;
+  __name2(parseDate, "parseDate");
+  function format(ms) {
+    const abs = Math.abs(ms);
+    if (abs >= Time2.day - Time2.hour / 2) {
+      return Math.round(ms / Time2.day) + "d";
+    } else if (abs >= Time2.hour - Time2.minute / 2) {
+      return Math.round(ms / Time2.hour) + "h";
+    } else if (abs >= Time2.minute - Time2.second / 2) {
+      return Math.round(ms / Time2.minute) + "m";
+    } else if (abs >= Time2.second) {
+      return Math.round(ms / Time2.second) + "s";
+    }
+    return ms + "ms";
+  }
+  __name(format, "format");
+  Time2.format = format;
+  __name2(format, "format");
+  function toDigits(source, length = 2) {
+    return source.toString().padStart(length, "0");
+  }
+  __name(toDigits, "toDigits");
+  Time2.toDigits = toDigits;
+  __name2(toDigits, "toDigits");
+  function template(template2, time = /* @__PURE__ */ new Date()) {
+    return template2.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+  }
+  __name(template, "template");
+  Time2.template = template;
+  __name2(template, "template");
+})(Time || (Time = {}));
+
+// ../../node_modules/@satorijs/element/lib/index.mjs
+var __defProp3 = Object.defineProperty;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __name3 = /* @__PURE__ */ __name((target, value) => __defProp3(target, "name", { value, configurable: true }), "__name");
+var __commonJS = /* @__PURE__ */ __name((cb, mod) => /* @__PURE__ */ __name(function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+}, "__require"), "__commonJS");
+var require_index = __commonJS({
+  "src/index.ts"(exports2, module2) {
+    var _a;
+    var kElement = Symbol.for("satori.element");
+    var ElementConstructor = (_a = class {
+      get data() {
+        return this.attrs;
+      }
+      getTagName() {
+        if (this.type === "component") {
+          return this.attrs.is?.name ?? "component";
+        } else {
+          return this.type;
+        }
+      }
+      toAttrString() {
+        return Object.entries(this.attrs).map(([key, value]) => {
+          if (isNullable(value)) return "";
+          key = hyphenate(key);
+          if (value === true) return ` ${key}`;
+          if (value === false) return ` no-${key}`;
+          return ` ${key}="${Element.escape("" + value, true)}"`;
+        }).join("");
+      }
+      toString(strip = false) {
+        if (this.type === "text" && "content" in this.attrs) {
+          return strip ? this.attrs.content : Element.escape(this.attrs.content);
+        }
+        const inner = this.children.map((child) => child.toString(strip)).join("");
+        if (strip) return inner;
+        const attrs = this.toAttrString();
+        const tag = this.getTagName();
+        if (!this.children.length) return `<${tag}${attrs}/>`;
+        return `<${tag}${attrs}>${inner}</${tag}>`;
+      }
+    }, __name(_a, "ElementConstructor"), __name3(_a, "ElementConstructor"), _a);
+    defineProperty(ElementConstructor, "name", "Element");
+    defineProperty(ElementConstructor.prototype, kElement, true);
+    function Element(type, ...args) {
+      const el = Object.create(ElementConstructor.prototype);
+      const attrs = {}, children = [];
+      if (args[0] && typeof args[0] === "object" && !Element.isElement(args[0]) && !Array.isArray(args[0])) {
+        const props = args.shift();
+        for (const [key, value] of Object.entries(props)) {
+          if (isNullable(value)) continue;
+          if (key === "children") {
+            args.push(...makeArray(value));
+          } else {
+            attrs[camelize(key)] = value;
+          }
+        }
+      }
+      for (const child of args) {
+        children.push(...Element.toElementArray(child));
+      }
+      if (typeof type === "function") {
+        attrs.is = type;
+        type = "component";
+      }
+      return Object.assign(el, { type, attrs, children });
+    }
+    __name(Element, "Element");
+    __name3(Element, "Element");
+    var evaluate = new Function("expr", "context", `
+  try {
+    with (context) {
+      return eval(expr)
+    }
+  } catch {}
+`);
+    ((Element2) => {
+      Element2.jsx = Element2;
+      Element2.jsxs = Element2;
+      Element2.jsxDEV = Element2;
+      Element2.Fragment = "template";
+      function isElement(source) {
+        return source && typeof source === "object" && source[kElement];
+      }
+      __name(isElement, "isElement");
+      Element2.isElement = isElement;
+      __name3(isElement, "isElement");
+      function toElement(content) {
+        if (typeof content === "string" || typeof content === "number" || typeof content === "boolean") {
+          content = "" + content;
+          if (content) return Element2("text", { content });
+        } else if (isElement(content)) {
+          return content;
+        } else if (!isNullable(content)) {
+          throw new TypeError(`Invalid content: ${content}`);
+        }
+      }
+      __name(toElement, "toElement");
+      Element2.toElement = toElement;
+      __name3(toElement, "toElement");
+      function toElementArray(content) {
+        if (Array.isArray(content)) {
+          return content.map(toElement).filter(isNonNullable);
+        } else {
+          return [toElement(content)].filter(isNonNullable);
+        }
+      }
+      __name(toElementArray, "toElementArray");
+      Element2.toElementArray = toElementArray;
+      __name3(toElementArray, "toElementArray");
+      function normalize(source, context) {
+        return typeof source === "string" ? parse(source, context) : toElementArray(source);
+      }
+      __name(normalize, "normalize");
+      Element2.normalize = normalize;
+      __name3(normalize, "normalize");
+      function escape(source, inline = false) {
+        const result = (source ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        return inline ? result.replace(/"/g, "&quot;") : result;
+      }
+      __name(escape, "escape");
+      Element2.escape = escape;
+      __name3(escape, "escape");
+      function unescape(source) {
+        return source.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#(\d+);/g, (_, code) => code === "38" ? _ : String.fromCharCode(+code)).replace(/&#x([0-9a-f]+);/gi, (_, code) => code === "26" ? _ : String.fromCharCode(parseInt(code, 16))).replace(/&(amp|#38|#x26);/g, "&");
+      }
+      __name(unescape, "unescape");
+      Element2.unescape = unescape;
+      __name3(unescape, "unescape");
+      function from(source, options = {}) {
+        const elements = parse(source);
+        if (options.caret) {
+          if (options.type && elements[0]?.type !== options.type) return;
+          return elements[0];
+        }
+        return select(elements, options.type || "*")[0];
+      }
+      __name(from, "from");
+      Element2.from = from;
+      __name3(from, "from");
+      const combRegExp = / *([ >+~]) */g;
+      function parseSelector(input) {
+        return input.split(",").map((query) => {
+          const selectors = [];
+          query = query.trim();
+          let combCap, combinator = " ";
+          while (combCap = combRegExp.exec(query)) {
+            selectors.push({ type: query.slice(0, combCap.index), combinator });
+            combinator = combCap[1];
+            query = query.slice(combCap.index + combCap[0].length);
+          }
+          selectors.push({ type: query, combinator });
+          return selectors;
+        });
+      }
+      __name(parseSelector, "parseSelector");
+      Element2.parseSelector = parseSelector;
+      __name3(parseSelector, "parseSelector");
+      function select(source, query) {
+        if (!source || !query) return [];
+        if (typeof source === "string") source = parse(source);
+        if (typeof query === "string") query = parseSelector(query);
+        if (!query.length) return [];
+        let adjacent = [];
+        const results = [];
+        for (const [index, element] of source.entries()) {
+          const inner = [];
+          const local = [...query, ...adjacent];
+          adjacent = [];
+          let matched = false;
+          for (const group of local) {
+            const { type, combinator } = group[0];
+            if (type === element.type || type === "*") {
+              if (group.length === 1) {
+                matched = true;
+              } else if ([" ", ">"].includes(group[1].combinator)) {
+                inner.push(group.slice(1));
+              } else if (group[1].combinator === "+") {
+                adjacent.push(group.slice(1));
+              } else {
+                query.push(group.slice(1));
+              }
+            }
+            if (combinator === " ") {
+              inner.push(group);
+            }
+          }
+          if (matched) results.push(source[index]);
+          results.push(...select(element.children, inner));
+        }
+        return results;
+      }
+      __name(select, "select");
+      Element2.select = select;
+      __name3(select, "select");
+      function interpolate(expr, context) {
+        expr = expr.trim();
+        if (!/^[\w.]+$/.test(expr)) {
+          return evaluate(expr, context) ?? "";
+        }
+        let value = context;
+        for (const part of expr.split(".")) {
+          value = value[part];
+          if (isNullable(value)) return "";
+        }
+        return value ?? "";
+      }
+      __name(interpolate, "interpolate");
+      Element2.interpolate = interpolate;
+      __name3(interpolate, "interpolate");
+      const tagRegExp1 = /(?<comment><!--[\s\S]*?-->)|(?<tag><(\/?)([^!\s>/]*)([^>]*?)\s*(\/?)>)/;
+      const tagRegExp2 = /(?<comment><!--[\s\S]*?-->)|(?<tag><(\/?)([^!\s>/]*)([^>]*?)\s*(\/?)>)|(?<curly>\{(?<derivative>[@:/#][^\s}]*)?[\s\S]*?\})/;
+      const attrRegExp1 = /([^\s=]+)(?:="(?<value1>[^"]*)"|='(?<value2>[^']*)')?/g;
+      const attrRegExp2 = /([^\s=]+)(?:="(?<value1>[^"]*)"|='(?<value2>[^']*)'|=\{(?<curly>[^}]+)\})?/g;
+      let Position;
+      ((Position2) => {
+        Position2[Position2["OPEN"] = 0] = "OPEN";
+        Position2[Position2["CLOSE"] = 1] = "CLOSE";
+        Position2[Position2["EMPTY"] = 2] = "EMPTY";
+        Position2[Position2["CONTINUE"] = 3] = "CONTINUE";
+      })(Position || (Position = {}));
+      function parse(source, context) {
+        const tokens = [];
+        function pushText(content) {
+          if (content) tokens.push(content);
+        }
+        __name(pushText, "pushText");
+        __name3(pushText, "pushText");
+        const tagRegExp = context ? tagRegExp2 : tagRegExp1;
+        let tagCap;
+        let trimStart = true;
+        while (tagCap = tagRegExp.exec(source)) {
+          const { curly, comment, derivative } = tagCap.groups;
+          const trimEnd = !curly;
+          parseContent(source.slice(0, tagCap.index), trimStart, trimEnd);
+          trimStart = trimEnd;
+          source = source.slice(tagCap.index + tagCap[0].length);
+          const [_, , , close, type, extra, empty] = tagCap;
+          if (comment) continue;
+          if (curly) {
+            let name2 = "", position = 2;
+            if (derivative) {
+              name2 = derivative.slice(1);
+              position = {
+                "@": 2,
+                "#": 0,
+                "/": 1,
+                ":": 3
+                /* CONTINUE */
+              }[derivative[0]];
+            }
+            tokens.push({
+              type: "curly",
+              name: name2,
+              position,
+              source: curly,
+              extra: curly.slice(1 + (derivative ?? "").length, -1)
+            });
+            continue;
+          }
+          tokens.push({
+            type: "angle",
+            source: _,
+            name: type || Element2.Fragment,
+            position: close ? 1 : empty ? 2 : 0,
+            extra
+          });
+        }
+        parseContent(source, trimStart, true);
+        function parseContent(source2, trimStart2, trimEnd) {
+          source2 = unescape(source2);
+          if (trimStart2) source2 = source2.replace(/^\s*\n\s*/, "");
+          if (trimEnd) source2 = source2.replace(/\s*\n\s*$/, "");
+          pushText(source2);
+        }
+        __name(parseContent, "parseContent");
+        __name3(parseContent, "parseContent");
+        return parseTokens(foldTokens(tokens), context);
+      }
+      __name(parse, "parse");
+      Element2.parse = parse;
+      __name3(parse, "parse");
+      function foldTokens(tokens) {
+        const stack = [[{
+          type: "angle",
+          name: Element2.Fragment,
+          position: 0,
+          source: "",
+          extra: "",
+          children: { default: [] }
+        }, "default"]];
+        function pushToken(...tokens2) {
+          const [token, slot] = stack[0];
+          token.children[slot].push(...tokens2);
+        }
+        __name(pushToken, "pushToken");
+        __name3(pushToken, "pushToken");
+        for (const token of tokens) {
+          if (typeof token === "string") {
+            pushToken(token);
+            continue;
+          }
+          const { name: name2, position } = token;
+          if (position === 1) {
+            if (stack[0][0].name === name2) {
+              stack.shift();
+            }
+          } else if (position === 3) {
+            stack[0][0].children[name2] = [];
+            stack[0][1] = name2;
+          } else if (position === 0) {
+            pushToken(token);
+            token.children = { default: [] };
+            stack.unshift([token, "default"]);
+          } else {
+            pushToken(token);
+          }
+        }
+        return stack[stack.length - 1][0].children.default;
+      }
+      __name(foldTokens, "foldTokens");
+      __name3(foldTokens, "foldTokens");
+      function parseTokens(tokens, context) {
+        const result = [];
+        for (const token of tokens) {
+          if (typeof token === "string") {
+            result.push(Element2("text", { content: token }));
+          } else if (token.type === "angle") {
+            const attrs = {};
+            const attrRegExp = context ? attrRegExp2 : attrRegExp1;
+            let attrCap;
+            while (attrCap = attrRegExp.exec(token.extra)) {
+              const [, key, v1, v2 = v1, v3] = attrCap;
+              if (v3) {
+                attrs[key] = interpolate(v3, context);
+              } else if (!isNullable(v2)) {
+                attrs[key] = unescape(v2);
+              } else if (key.startsWith("no-")) {
+                attrs[key.slice(3)] = false;
+              } else {
+                attrs[key] = true;
+              }
+            }
+            result.push(Element2(token.name, attrs, token.children && parseTokens(token.children.default, context)));
+          } else if (!token.name) {
+            result.push(...toElementArray(interpolate(token.extra, context)));
+          } else if (token.name === "if") {
+            if (evaluate(token.extra, context)) {
+              result.push(...parseTokens(token.children.default, context));
+            } else {
+              result.push(...parseTokens(token.children.else || [], context));
+            }
+          } else if (token.name === "each") {
+            const [expr, ident] = token.extra.split(/\s+as\s+/);
+            const items = interpolate(expr, context);
+            if (!items || !items[Symbol.iterator]) continue;
+            for (const item of items) {
+              result.push(...parseTokens(token.children.default, { ...context, [ident]: item }));
+            }
+          }
+        }
+        return result;
+      }
+      __name(parseTokens, "parseTokens");
+      __name3(parseTokens, "parseTokens");
+      function visit(element, rules, session) {
+        const { type, attrs, children } = element;
+        if (typeof rules === "function") {
+          return rules(element, session);
+        } else {
+          let result = rules[typeof type === "string" ? type : ""] ?? rules.default ?? true;
+          if (typeof result === "function") {
+            result = result(attrs, children, session);
+          }
+          return result;
+        }
+      }
+      __name(visit, "visit");
+      __name3(visit, "visit");
+      function transform(source, rules, session) {
+        const elements = typeof source === "string" ? parse(source) : source;
+        const output = [];
+        elements.forEach((element) => {
+          const { type, attrs, children } = element;
+          const result = visit(element, rules, session);
+          if (result === true) {
+            output.push(Element2(type, attrs, transform(children, rules, session)));
+          } else if (result !== false) {
+            output.push(...toElementArray(result));
+          }
+        });
+        return typeof source === "string" ? output.join("") : output;
+      }
+      __name(transform, "transform");
+      Element2.transform = transform;
+      __name3(transform, "transform");
+      async function transformAsync(source, rules, session) {
+        const elements = typeof source === "string" ? parse(source) : source;
+        const children = (await Promise.all(elements.map(async (element) => {
+          const { type, attrs, children: children2 } = element;
+          const result = await visit(element, rules, session);
+          if (result === true) {
+            return [Element2(type, attrs, await transformAsync(children2, rules, session))];
+          } else if (result !== false) {
+            return toElementArray(result);
+          } else {
+            return [];
+          }
+        }))).flat(1);
+        return typeof source === "string" ? children.join("") : children;
+      }
+      __name(transformAsync, "transformAsync");
+      Element2.transformAsync = transformAsync;
+      __name3(transformAsync, "transformAsync");
+      function createFactory(type, ...keys) {
+        return (...args) => {
+          const element = Element2(type);
+          keys.forEach((key, index) => {
+            if (!isNullable(args[index])) {
+              element.attrs[key] = args[index];
+            }
+          });
+          if (args[keys.length]) {
+            Object.assign(element.attrs, args[keys.length]);
+          }
+          return element;
+        };
+      }
+      __name(createFactory, "createFactory");
+      __name3(createFactory, "createFactory");
+      Element2.warn = /* @__PURE__ */ __name3(() => {
+      }, "warn");
+      function createAssetFactory(type) {
+        return (src, ...args) => {
+          let prefix = "base64://";
+          if (typeof args[0] === "string") {
+            prefix = `data:${args.shift()};base64,`;
+          }
+          if (is("Buffer", src)) {
+            src = prefix + src.toString("base64");
+          } else if (is("ArrayBuffer", src)) {
+            src = prefix + Binary.toBase64(src);
+          } else if (ArrayBuffer.isView(src)) {
+            src = prefix + Binary.toBase64(src.buffer);
+          }
+          if (src.startsWith("base64://")) {
+            (0, Element2.warn)(`protocol "base64:" is deprecated and will be removed in the future, please use "data:" instead`);
+          }
+          return Element2(type, { ...args[0], src });
+        };
+      }
+      __name(createAssetFactory, "createAssetFactory");
+      __name3(createAssetFactory, "createAssetFactory");
+      Element2.text = createFactory("text", "content");
+      Element2.at = createFactory("at", "id");
+      Element2.sharp = createFactory("sharp", "id");
+      Element2.quote = createFactory("quote", "id");
+      Element2.image = createAssetFactory("img");
+      Element2.img = createAssetFactory("img");
+      Element2.video = createAssetFactory("video");
+      Element2.audio = createAssetFactory("audio");
+      Element2.file = createAssetFactory("file");
+      function i18n(path5, children) {
+        return Element2("i18n", typeof path5 === "string" ? { path: path5 } : path5, children);
+      }
+      __name(i18n, "i18n");
+      Element2.i18n = i18n;
+      __name3(i18n, "i18n");
+    })(Element || (Element = {}));
+    module2.exports = Element;
+  }
+});
+var lib_default = require_index();
+
+// ../../node_modules/@satorijs/protocol/lib/index.mjs
+var __defProp4 = Object.defineProperty;
+var __name4 = /* @__PURE__ */ __name((target, value) => __defProp4(target, "name", { value, configurable: true }), "__name");
+function Field(name2) {
+  return { name: name2 };
+}
+__name(Field, "Field");
+__name4(Field, "Field");
+function Method(name2, fields, isForm = false) {
+  return { name: name2, fields: fields.map(Field), isForm };
+}
+__name(Method, "Method");
+__name4(Method, "Method");
+var Methods = {
+  "channel.get": Method("getChannel", ["channel_id", "guild_id"]),
+  "channel.list": Method("getChannelList", ["guild_id", "next"]),
+  "channel.create": Method("createChannel", ["guild_id", "data"]),
+  "channel.update": Method("updateChannel", ["channel_id", "data"]),
+  "channel.delete": Method("deleteChannel", ["channel_id"]),
+  "channel.mute": Method("muteChannel", ["channel_id", "guild_id", "enable"]),
+  "message.create": Method("createMessage", ["channel_id", "content", "referrer"]),
+  "message.update": Method("editMessage", ["channel_id", "message_id", "content"]),
+  "message.delete": Method("deleteMessage", ["channel_id", "message_id"]),
+  "message.get": Method("getMessage", ["channel_id", "message_id"]),
+  "message.list": Method("getMessageList", ["channel_id", "next", "direction", "limit", "order"]),
+  "reaction.create": Method("createReaction", ["channel_id", "message_id", "emoji"]),
+  "reaction.delete": Method("deleteReaction", ["channel_id", "message_id", "emoji", "user_id"]),
+  "reaction.clear": Method("clearReaction", ["channel_id", "message_id", "emoji"]),
+  "reaction.list": Method("getReactionList", ["channel_id", "message_id", "emoji", "next"]),
+  "upload.create": Method("createUpload", [], true),
+  "guild.get": Method("getGuild", ["guild_id"]),
+  "guild.list": Method("getGuildList", ["next"]),
+  "guild.member.get": Method("getGuildMember", ["guild_id", "user_id"]),
+  "guild.member.list": Method("getGuildMemberList", ["guild_id", "next"]),
+  "guild.member.kick": Method("kickGuildMember", ["guild_id", "user_id", "permanent"]),
+  "guild.member.mute": Method("muteGuildMember", ["guild_id", "user_id", "duration", "reason"]),
+  "guild.member.role.set": Method("setGuildMemberRole", ["guild_id", "user_id", "role_id"]),
+  "guild.member.role.unset": Method("unsetGuildMemberRole", ["guild_id", "user_id", "role_id"]),
+  "guild.member.role.list": Method("getGuildMemberRoleList", ["guild_id", "user_id", "next"]),
+  "guild.role.list": Method("getGuildRoleList", ["guild_id", "next"]),
+  "guild.role.create": Method("createGuildRole", ["guild_id", "data"]),
+  "guild.role.update": Method("updateGuildRole", ["guild_id", "role_id", "data"]),
+  "guild.role.delete": Method("deleteGuildRole", ["guild_id", "role_id"]),
+  "login.get": Method("getLogin", []),
+  "user.get": Method("getUser", ["user_id"]),
+  "user.channel.create": Method("createDirectChannel", ["user_id", "guild_id"]),
+  "friend.list": Method("getFriendList", ["next"]),
+  "friend.delete": Method("deleteFriend", ["user_id"]),
+  "friend.approve": Method("handleFriendRequest", ["message_id", "approve", "comment"]),
+  "guild.approve": Method("handleGuildRequest", ["message_id", "approve", "comment"]),
+  "guild.member.approve": Method("handleGuildMemberRequest", ["message_id", "approve", "comment"])
+};
+var Channel;
+((Channel2) => {
+  let Type;
+  ((Type2) => {
+    Type2[Type2["TEXT"] = 0] = "TEXT";
+    Type2[Type2["DIRECT"] = 1] = "DIRECT";
+    Type2[Type2["CATEGORY"] = 2] = "CATEGORY";
+    Type2[Type2["VOICE"] = 3] = "VOICE";
+  })(Type = Channel2.Type || (Channel2.Type = {}));
+})(Channel || (Channel = {}));
+function Resource(attrs = [], children = [], content) {
+  return { attrs, children, content };
+}
+__name(Resource, "Resource");
+__name4(Resource, "Resource");
+((Resource2) => {
+  const Definitions = {
+    user: Resource2(["id", "name", "nick", "avatar", "isBot"]),
+    member: Resource2(["name", "nick", "avatar"]),
+    channel: Resource2(["id", "type", "name"]),
+    guild: Resource2(["id", "name", "avatar"]),
+    quote: Resource2(["id"], ["quote", "user", "member", "channel"], "content")
+  };
+  function encode(type, data) {
+    const resource = Definitions[type];
+    const element = lib_default(type, pick(data, resource.attrs));
+    for (const key of resource.children) {
+      if (isNullable(data[key])) continue;
+      element.children.push(encode(key, data[key]));
+    }
+    if (resource.content && !isNullable(data[resource.content])) {
+      element.children.push(...lib_default.parse(data[resource.content]));
+    }
+    return element;
+  }
+  __name(encode, "encode");
+  Resource2.encode = encode;
+  __name4(encode, "encode");
+  function decode(element) {
+    const data = element.attrs;
+    const resource = Definitions[element.type];
+    for (const key of resource.children) {
+      const index = element.children.findIndex((el) => el.type === key);
+      if (index === -1) continue;
+      const [child] = element.children.splice(index, 1);
+      data[key] = decode(child);
+    }
+    if (resource.content && element.children.length) {
+      data[resource.content] = element.children.join("");
+    }
+    return data;
+  }
+  __name(decode, "decode");
+  Resource2.decode = decode;
+  __name4(decode, "decode");
+})(Resource || (Resource = {}));
+function transformKey(source, callback) {
+  if (!source || typeof source !== "object") return source;
+  if (Array.isArray(source)) return source.map((value) => transformKey(value, callback));
+  return Object.fromEntries(Object.entries(source).map(([key, value]) => {
+    if (key.startsWith("_") || key === "referrer") return [key, value];
+    return [callback(key), transformKey(value, callback)];
+  }));
+}
+__name(transformKey, "transformKey");
+__name4(transformKey, "transformKey");
+var Opcode = /* @__PURE__ */ ((Opcode2) => {
+  Opcode2[Opcode2["EVENT"] = 0] = "EVENT";
+  Opcode2[Opcode2["PING"] = 1] = "PING";
+  Opcode2[Opcode2["PONG"] = 2] = "PONG";
+  Opcode2[Opcode2["IDENTIFY"] = 3] = "IDENTIFY";
+  Opcode2[Opcode2["READY"] = 4] = "READY";
+  Opcode2[Opcode2["META"] = 5] = "META";
+  return Opcode2;
+})(Opcode || {});
+var WebSocket;
+((WebSocket2) => {
+  WebSocket2.CONNECTING = 0;
+  WebSocket2.OPEN = 1;
+  WebSocket2.CLOSING = 2;
+  WebSocket2.CLOSED = 3;
+})(WebSocket || (WebSocket = {}));
+
+// src/satori.ts
+function resolveSatoriEndpoint(ctx) {
+  const url = ctx.satori?.server?.url ?? "/satori";
+  const clean = url.startsWith("undefined") ? url.slice(9) : url;
+  if (/^https?:\/\//i.test(clean)) return clean;
+  const base = ctx.server?.selfUrl ?? ctx.server?.config?.selfUrl ?? "";
+  return `${base}${clean.startsWith("/") ? clean : `/${clean}`}`;
+}
+__name(resolveSatoriEndpoint, "resolveSatoriEndpoint");
+function toSatoriEventUrl(endpoint) {
+  const url = new URL(endpoint);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/v1/events`;
+  url.search = "";
+  return url.href;
+}
+__name(toSatoriEventUrl, "toSatoriEventUrl");
+
+// src/gateway.ts
+var WS_OPEN = 1;
+var RECONNECT_MAX_DELAY = 3e4;
+function getObject2(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+__name(getObject2, "getObject");
+function getString3(value) {
+  return typeof value === "string" ? value : "";
+}
+__name(getString3, "getString");
+function getNumber2(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+__name(getNumber2, "getNumber");
+var _SatoriGateway = class _SatoriGateway {
+  constructor(ctx, config, database, recorder, logger, onPayload) {
+    this.ctx = ctx;
+    this.config = config;
+    this.database = database;
+    this.recorder = recorder;
+    this.logger = logger;
+    this.onPayload = onPayload;
+    this.stopped = true;
+    this.retry = 0;
+    this.sequence = 0;
+    this.logins = [];
+    this.online = false;
+  }
+  async start() {
+    this.stopped = false;
+    this.retry = 0;
+    this.sequence = await this.loadSequence();
+    this.connect();
+  }
+  dispose() {
+    this.stopped = true;
+    this.pingDispose?.();
+    this.reconnectDispose?.();
+    this.socket?.close();
+    this.socket = void 0;
+    this.setOnline(false);
+  }
+  getLogins() {
+    return this.logins.map((item) => ({ ...item }));
+  }
+  async loadSequence() {
+    const value = await this.database.getMeta("satori:sn");
+    return getNumber2(value);
+  }
+  connect() {
+    if (this.stopped) return;
+    let socket;
+    try {
+      socket = this.ctx.http.ws(toSatoriEventUrl(resolveSatoriEndpoint(this.ctx)));
+    } catch (error) {
+      this.logger.warn("Satori 连接创建失败:", error);
+      this.scheduleReconnect();
+      return;
+    }
+    this.socket = socket;
+    socket.addEventListener("open", () => {
+      if (this.socket !== socket) {
+        socket.close();
+        return;
+      }
+      this.retry = 0;
+      this.setOnline(true);
+      socket.send(JSON.stringify({
+        op: Opcode.IDENTIFY,
+        body: {
+          token: this.token,
+          sn: this.sequence || void 0
+        }
+      }));
+      if (!this.pingDispose) {
+        this.pingDispose = this.ctx.setInterval(() => {
+          if (this.socket?.readyState === WS_OPEN) {
+            this.socket.send(JSON.stringify({ op: Opcode.PING, body: {} }));
+          }
+        }, 1e4);
+      }
+    });
+    socket.addEventListener("message", (event) => {
+      void this.handleMessage(event.data).catch((error) => {
+        this.logger.warn("Satori 事件处理失败:", error);
+      });
+    });
+    socket.addEventListener("close", () => {
+      if (this.socket === socket) this.socket = void 0;
+      this.pingDispose?.();
+      this.pingDispose = void 0;
+      this.setOnline(false);
+      this.scheduleReconnect();
+    });
+    socket.addEventListener("error", () => {
+      socket.close();
+    });
+  }
+  get token() {
+    return getString3(this.ctx.satori?.server?.config?.token);
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.reconnectDispose) return;
+    const delay = Math.min(RECONNECT_MAX_DELAY, 1e3 * 2 ** this.retry);
+    this.retry += 1;
+    this.logger.logInfo("Satori 将在", delay, "ms 后重连");
+    this.reconnectDispose = this.ctx.setTimeout(() => {
+      this.reconnectDispose = void 0;
+      this.connect();
+    }, delay);
+  }
+  async handleMessage(data) {
+    let payload;
+    try {
+      payload = JSON.parse(String(data));
+    } catch {
+      this.logger.warn("Satori 消息解析失败");
+      return;
+    }
+    if (payload.op === Opcode.READY) {
+      const body2 = getObject2(payload.body);
+      this.logins = this.normalizeLogins(body2.logins);
+      this.onPayload({ kind: "ready", logins: this.getLogins() });
+      return;
+    }
+    if (payload.op !== Opcode.EVENT) return;
+    const body = getObject2(payload.body);
+    const sn = getNumber2(body.sn);
+    if (sn) {
+      this.sequence = sn;
+      void this.database.setMeta("satori:sn", sn).catch((error) => {
+        this.logger.warn("Satori sequence 保存失败:", error);
+      });
+    }
+    const type = getString3(body.type);
+    if (type === "login-added" || type === "login-updated") {
+      const next = this.normalizeLogins([body.login]);
+      if (next.length) {
+        this.logins = this.logins.filter((item) => {
+          return !(item.platform === next[0].platform && item.selfId === next[0].selfId);
+        });
+        this.logins.push(next[0]);
+        this.onPayload({ kind: "ready", logins: this.getLogins() });
+      }
+      return;
+    }
+    if (type === "login-removed") {
+      const login2 = getObject2(body.login);
+      const loginUser2 = getObject2(login2.user);
+      const platform2 = getString3(body.platform) || getString3(login2.platform);
+      const selfId2 = getString3(body.self_id) || getString3(body.selfId) || getString3(loginUser2.id);
+      this.logins = this.logins.filter((item) => {
+        return !(item.platform === platform2 && item.selfId === selfId2);
+      });
+      this.onPayload({ kind: "ready", logins: this.getLogins() });
+      return;
+    }
+    const login = getObject2(body.login);
+    const loginUser = getObject2(login.user);
+    const platform = getString3(body.platform) || getString3(login.platform);
+    const selfId = getString3(body.self_id) || getString3(body.selfId) || getString3(loginUser.id);
+    const event = {
+      type: getString3(body.type),
+      platform,
+      selfId,
+      timestamp: getNumber2(body.timestamp) || Date.now(),
+      sn,
+      body
+    };
+    if (this.isBlocked(platform)) return;
+    try {
+      await this.recorder.handleEvent(body);
+    } catch (error) {
+      this.logger.warn("Satori 消息写入失败:", error);
+    }
+    this.onPayload({ kind: "event", event });
+  }
+  normalizeLogins(value) {
+    if (!Array.isArray(value)) return [];
+    const result = [];
+    for (const item of value) {
+      const login = getObject2(item);
+      const user = getObject2(login.user);
+      const platform = getString3(login.platform) || getString3(user.platform);
+      const selfId = getString3(login.self_id) || getString3(login.selfId) || getString3(user.id);
+      if (!platform || !selfId || this.isBlocked(platform)) continue;
+      result.push({
+        platform,
+        selfId,
+        name: getString3(user.name) || getString3(user.nick) || getString3(user.nickname) || selfId,
+        avatar: getString3(user.avatar) || void 0,
+        status: getNumber2(login.status),
+        features: Array.isArray(login.features) ? login.features.map(String) : []
+      });
+    }
+    return result;
+  }
+  isBlocked(platform) {
+    return (this.config.blockedPlatforms ?? []).some((item) => {
+      return item.exactMatch ? platform === item.platformName : platform.includes(item.platformName);
+    });
+  }
+  setOnline(online) {
+    if (this.online === online) return;
+    this.online = online;
+    this.onPayload({ kind: "status", online });
+  }
+};
+__name(_SatoriGateway, "SatoriGateway");
+var SatoriGateway = _SatoriGateway;
+
 // src/media.ts
 var import_node_crypto2 = require("node:crypto");
 var import_node_fs = require("node:fs");
@@ -1357,26 +2693,26 @@ var KOISHI_STATUS_I18N_FALLBACK = {
   "commands.status.messages.status.2": "连接中",
   "commands.status.messages.status.3": "异常"
 };
-function getString2(value) {
+function getString4(value) {
   return typeof value === "string" ? value : "";
 }
-__name(getString2, "getString");
+__name(getString4, "getString");
 function getMessageId(value) {
-  const raw = getObject(value).id ?? getObject(value).message_id;
+  const raw = getObject3(value).id ?? getObject3(value).message_id;
   return raw == null ? "" : String(raw);
 }
 __name(getMessageId, "getMessageId");
-function getNumber(value) {
+function getNumber3(value) {
   const num = Number(value);
   return Number.isFinite(num) ? num : 0;
 }
-__name(getNumber, "getNumber");
-function getObject(value) {
+__name(getNumber3, "getNumber");
+function getObject3(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
-__name(getObject, "getObject");
+__name(getObject3, "getObject");
 function toSatoriElement(value) {
-  const raw = getObject(value);
+  const raw = getObject3(value);
   const rawAttrs = raw.attrs ?? raw.data;
   const attrs = typeof rawAttrs === "object" && rawAttrs !== null ? rawAttrs : {};
   const children = Array.isArray(raw.children) ? raw.children.map(toSatoriElement) : [];
@@ -1396,37 +2732,37 @@ function toSegments(elements, resolveI18n) {
   for (const raw of elements) {
     const element = toSatoriElement(raw);
     const attrs = element.attrs ?? {};
-    const type = getString2(element.type);
+    const type = getString4(element.type);
     if (type === "text") {
-      result.push({ type: "text", text: getString2(attrs.content) || getString2(attrs.text) });
+      result.push({ type: "text", text: getString4(attrs.content) || getString4(attrs.text) });
     } else if (type === "at") {
-      const id = getString2(attrs.id) || getString2(attrs.qq);
-      const name2 = getString2(attrs.name) || (attrs.type === "all" ? "所有人" : id);
+      const id = getString4(attrs.id) || getString4(attrs.qq);
+      const name2 = getString4(attrs.name) || (attrs.type === "all" ? "所有人" : id);
       result.push({ type: "at", qq: id, text: name2.startsWith("@") ? name2 : `@${name2}` });
     } else if (type === "img" || type === "image") {
-      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
-      result.push({ type: "image", file: src, url: src, summary: getString2(attrs.title) });
+      const src = getString4(attrs.src) || getString4(attrs.url) || getString4(attrs.file);
+      result.push({ type: "image", file: src, url: src, summary: getString4(attrs.title) });
     } else if (type === "audio" || type === "record") {
-      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
+      const src = getString4(attrs.src) || getString4(attrs.url) || getString4(attrs.file);
       result.push({ type: "record", file: src, url: src });
     } else if (type === "video") {
-      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
+      const src = getString4(attrs.src) || getString4(attrs.url) || getString4(attrs.file);
       result.push({ type: "video", file: src, url: src });
     } else if (type === "file") {
-      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
-      result.push({ type: "file", file: src, url: src, name: getString2(attrs.name) });
+      const src = getString4(attrs.src) || getString4(attrs.url) || getString4(attrs.file);
+      result.push({ type: "file", file: src, url: src, name: getString4(attrs.name) });
     } else if (type === "quote") {
-      result.push({ type: "reply", id: getString2(attrs.id) });
+      result.push({ type: "reply", id: getString4(attrs.id) });
     } else if (type === "json") {
-      result.push({ type: "json", data: getString2(attrs.data) || getString2(attrs.content) });
+      result.push({ type: "json", data: getString4(attrs.data) || getString4(attrs.content) });
     } else if (type === "xml") {
-      result.push({ type: "xml", data: getString2(attrs.data) || getString2(attrs.content) });
+      result.push({ type: "xml", data: getString4(attrs.data) || getString4(attrs.content) });
     } else if (type === "markdown") {
-      result.push({ type: "markdown", content: getString2(attrs.content) });
+      result.push({ type: "markdown", content: getString4(attrs.content) });
     } else if (isForwardContainer(element)) {
       result.push({
         type: "forward",
-        id: getString2(attrs.id),
+        id: getString4(attrs.id),
         content: toForwardNodes(element.children ?? [], resolveI18n) ?? []
       });
     } else if (type === "p") {
@@ -1435,7 +2771,7 @@ function toSegments(elements, resolveI18n) {
     } else if (type === "br") {
       result.push({ type: "text", text: "\n" });
     } else if (type === "i18n") {
-      const path5 = getString2(attrs.path);
+      const path5 = getString4(attrs.path);
       const resolved = resolveI18n ? resolveI18n(attrs) : "";
       result.push({ type: "text", text: resolved || `[${path5 || "i18n"}]` });
     } else if (element.children?.length) {
@@ -1466,12 +2802,12 @@ function toForwardNodes(elements, resolveI18n) {
       const authorAttrs = author?.attrs ?? {};
       const content = children.filter((item) => item.type !== "author");
       nodes.push({
-        message_id: getString2(attrs.id),
-        time: getNumber(authorAttrs.time) || getNumber(attrs.time),
+        message_id: getString4(attrs.id),
+        time: getNumber3(authorAttrs.time) || getNumber3(attrs.time),
         sender: {
-          user_id: getString2(authorAttrs.id),
-          nickname: getString2(authorAttrs.name),
-          avatar: getString2(authorAttrs.avatar)
+          user_id: getString4(authorAttrs.id),
+          nickname: getString4(authorAttrs.name),
+          avatar: getString4(authorAttrs.avatar)
         },
         message: toSegments(content, resolveI18n)
       });
@@ -1486,7 +2822,7 @@ function detectKind(elements) {
   while (stack.length) {
     const element = stack.pop();
     if (!element) continue;
-    const type = getString2(element.type);
+    const type = getString4(element.type);
     if (isForwardContainer(element)) return "forward";
     if (type === "img" || type === "image" || type === "mface") return "image";
     if (type === "audio" || type === "record") return "voice";
@@ -1503,7 +2839,7 @@ function forwardId(elements) {
     const element = stack.pop();
     if (!element) continue;
     if (isForwardContainer(element)) {
-      const id = getString2(element.attrs?.id);
+      const id = getString4(element.attrs?.id);
       if (id) return id;
     }
     stack.push(...element.children ?? []);
@@ -1656,10 +2992,10 @@ var _SelfMessageRecorder = class _SelfMessageRecorder {
     if (session.type !== "send") return;
     const platform = session.platform || "";
     const selfId = session.selfId || "";
-    const event = getObject(session.event);
-    const eventChannel = getObject(event.channel);
-    const eventMessage = getObject(event.message);
-    const channelId = session.channelId || getString2(eventChannel.id);
+    const event = getObject3(session.event);
+    const eventChannel = getObject3(event.channel);
+    const eventMessage = getObject3(event.message);
+    const channelId = session.channelId || getString4(eventChannel.id);
     if (this.isBlocked(platform) || !platform || !selfId || !channelId) return;
     const messageId = session.messageId || getMessageId(eventMessage);
     if (messageId) {
@@ -1691,7 +3027,7 @@ var _SelfMessageRecorder = class _SelfMessageRecorder {
     });
   }
   resolveI18nElement(attrs) {
-    const path5 = getString2(attrs.path);
+    const path5 = getString4(attrs.path);
     if (!path5 || !this.ctx.i18n) return `[${path5 || "i18n"}]`;
     try {
       const locales = this.ctx.i18n.fallback([]);
@@ -1737,9 +3073,9 @@ var _SelfMessageRecorder = class _SelfMessageRecorder {
   normalizeElements(content) {
     try {
       const normalized = typeof content === "string" ? content : Array.isArray(content) ? content.map((raw) => {
-        const item = getObject(raw);
+        const item = getObject3(raw);
         if (typeof item.data === "object" && item.data !== null && item.attrs === void 0) {
-          return (0, import_koishi.h)(getString2(item.type), item.data);
+          return (0, import_koishi.h)(getString4(item.type), item.data);
         }
         return raw;
       }) : content;
@@ -1754,24 +3090,17 @@ __name(_SelfMessageRecorder, "SelfMessageRecorder");
 var SelfMessageRecorder = _SelfMessageRecorder;
 
 // src/bootstrap.ts
-function resolveEndpoint(ctx, config) {
-  const url = ctx.satori?.server?.url ?? "/satori";
-  const clean = url.startsWith("undefined") ? url.slice(9) : url;
-  if (/^https?:\/\//i.test(clean)) return clean;
-  const base = ctx.server?.selfUrl ?? ctx.server?.config?.selfUrl ?? "";
-  return `${base}${clean.startsWith("/") ? clean : `/${clean}`}`;
-}
-__name(resolveEndpoint, "resolveEndpoint");
-function registerBootstrap(ctx, config, database, logger) {
+function registerBootstrap(ctx, config, database, logger, getLogins) {
   ctx.console.addListener("chat-patch/bootstrap", () => {
     logger.logInfo("返回 Satori bootstrap:", {
-      endpoint: resolveEndpoint(ctx, config),
+      endpoint: resolveSatoriEndpoint(ctx),
       basePath: config.basePath
     });
     return {
-      endpoint: resolveEndpoint(ctx, config),
+      endpoint: resolveSatoriEndpoint(ctx),
       token: ctx.satori?.server?.config?.token ?? "",
       basePath: config.basePath,
+      logins: getLogins(),
       blockedPlatforms: config.blockedPlatforms ?? []
     };
   }, { authority: 4 });
@@ -2449,7 +3778,7 @@ var name = "chat-patch";
 var reusable = false;
 var filter = false;
 var inject = {
-  required: ["console", "server", "satori.server"]
+  required: ["console", "server", "http", "satori.server"]
 };
 var usage = `
 ---
@@ -2466,17 +3795,25 @@ async function apply(ctx, config) {
   const contactCache = new ContactCacheService(ctx, database, pluginLogger);
   const media = new MediaManager(ctx, config, database, pluginLogger);
   media.start();
-  const recorder = new Recorder(ctx, config, database, media, contactCache, pluginLogger);
-  recorder.start();
+  const recorder = new Recorder(config, database, media, contactCache, pluginLogger);
+  const gateway = new SatoriGateway(ctx, config, database, recorder, pluginLogger, (payload) => {
+    void ctx.console.broadcast("chat-patch/event", payload).catch((error) => {
+      pluginLogger.warn("推送前端事件失败:", error);
+    });
+  });
   const selfMessages = new SelfMessageRecorder(ctx, config, database, media, pluginLogger);
   selfMessages.start();
-  registerBootstrap(ctx, config, database, pluginLogger);
+  void gateway.start().catch((error) => {
+    pluginLogger.warn("Satori 网关启动失败:", error);
+  });
+  registerBootstrap(ctx, config, database, pluginLogger, () => gateway.getLogins());
   registerWeb(ctx, config, database, contactCache, media, pluginLogger);
   ctx.console.addEntry({
     dev: import_node_path4.default.resolve(__dirname, "../client/index.ts"),
     prod: import_node_path4.default.resolve(__dirname, "../dist")
   });
   ctx.on("dispose", async () => {
+    gateway.dispose();
     selfMessages.dispose();
     media.dispose();
     await database.dispose();