koishi-plugin-rocom 1.0.1

package/lib/index.js

@@ -0,0 +1,3746 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi11 = require("koishi");
+var import_node_path5 = __toESM(require("node:path"));
+
+// src/client.ts
+var import_koishi = require("koishi");
+var logger = new import_koishi.Logger("rocom-client");
+var RocomClient = class {
+  static {
+    __name(this, "RocomClient");
+  }
+  baseUrl;
+  apiKey;
+  timeout;
+  lastError = "接口异常";
+  constructor(baseUrl, apiKey, timeout = 15e3) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+    this.timeout = timeout;
+  }
+  sanitizeUid(uid) {
+    if (!uid) return "";
+    return uid.trim().replace(/[^a-zA-Z0-9_\- \u4e00-\u9fa5]/g, "").trim();
+  }
+  wegameHeaders(fwToken = "", userIdentifier = "", clientType = "", clientId = "") {
+    const headers = {};
+    if (this.apiKey) headers["X-API-Key"] = this.apiKey;
+    if (fwToken) headers["X-Framework-Token"] = fwToken;
+    if (userIdentifier) headers["X-User-Identifier"] = this.sanitizeUid(userIdentifier);
+    if (clientType) headers["X-Client-Type"] = clientType;
+    if (clientId) headers["X-Client-ID"] = clientId;
+    return headers;
+  }
+  rocomHeaders(fwToken, userIdentifier = "") {
+    const headers = { "X-Framework-Token": fwToken };
+    if (this.apiKey) headers["X-API-Key"] = this.apiKey;
+    if (userIdentifier) headers["X-User-Identifier"] = this.sanitizeUid(userIdentifier);
+    return headers;
+  }
+  formatHttpError(e) {
+    const err = e;
+    const response = err?.response;
+    if (response) {
+      const body = response.data;
+      const bodyMessage = body && typeof body === "object" ? body.message || body.msg || body.error || JSON.stringify(body) : body;
+      const prefix = response.status ? `HTTP ${response.status}` : "HTTP error";
+      return bodyMessage ? `${prefix}: ${bodyMessage}` : `${prefix}: ${response.statusText || err?.message || "unknown"}`;
+    }
+    return err?.message || String(e);
+  }
+  isSensitiveLogKey(key) {
+    return /api[-_]?key|authorization|cookie|framework[-_]?token|password|secret|ticket|token/i.test(key);
+  }
+  maskSensitiveValue(value) {
+    if (typeof value !== "string") return value;
+    if (!value) return value;
+    if (value.length <= 8) return "***";
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+  }
+  sanitizeForLog(value, key = "") {
+    if (this.isSensitiveLogKey(key)) return this.maskSensitiveValue(value);
+    if (!value || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map((item) => this.sanitizeForLog(item));
+    const result = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+      result[entryKey] = this.sanitizeForLog(entryValue, entryKey);
+    }
+    return result;
+  }
+  headersForLog(headers) {
+    if (!headers || typeof headers !== "object") return headers;
+    const iterableHeaders = headers;
+    if (typeof iterableHeaders.forEach === "function") {
+      const result = {};
+      iterableHeaders.forEach((value, key) => {
+        result[key] = this.sanitizeForLog(value, key);
+      });
+      return result;
+    }
+    return this.sanitizeForLog(headers);
+  }
+  stringifyForLog(value) {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+  logRequestFailureDetails(method, path6, headers, params, body, errorOrResponse) {
+    const err = errorOrResponse;
+    const response = err?.response;
+    const details = {
+      request: {
+        method,
+        url: `${this.baseUrl}${path6}`,
+        path: path6,
+        params: this.sanitizeForLog(params),
+        body: this.sanitizeForLog(body),
+        headers: this.sanitizeForLog(headers),
+        timeout: this.timeout
+      },
+      response: response ? {
+        status: response.status,
+        statusText: response.statusText,
+        headers: this.headersForLog(response.headers),
+        body: this.sanitizeForLog(response.data)
+      } : void 0,
+      apiResponse: response ? void 0 : this.sanitizeForLog(errorOrResponse),
+      error: response || err?.message || err?.stack ? {
+        name: err?.name,
+        message: err?.message,
+        code: err?.code,
+        stack: err?.stack
+      } : void 0
+    };
+    console.warn(`[rocom-client] ${method} ${path6} detailed failure
+${this.stringifyForLog(details)}`);
+  }
+  async get(ctx, path6, headers, params, options) {
+    try {
+      const resp = await ctx.http.get(`${this.baseUrl}${path6}`, {
+        headers,
+        params,
+        timeout: this.timeout
+      });
+      if (resp?.code !== 0) {
+        this.setLastError(resp?.message || "接口返回异常");
+        logger.warn(path6 + " error: " + (resp?.message || "unknown"));
+        if (!options?.silentFailureDetails) {
+          this.logRequestFailureDetails("GET", path6, headers, params, void 0, resp);
+        }
+        return null;
+      }
+      return resp?.data ?? {};
+    } catch (e) {
+      const message = this.formatHttpError(e);
+      this.setLastError(message);
+      if (!options?.silentFailureDetails) {
+        this.logRequestFailureDetails("GET", path6, headers, params, void 0, e);
+      }
+      const err = e;
+      if (err?.response) {
+        logger.warn("GET " + path6 + " failed: " + message);
+      } else {
+        logger.error("GET " + path6 + " failed: " + message);
+      }
+      return null;
+    }
+  }
+  async post(ctx, path6, headers, json, params) {
+    try {
+      const resp = await ctx.http.post(`${this.baseUrl}${path6}`, json, {
+        headers,
+        params,
+        timeout: this.timeout
+      });
+      if (resp?.code !== 0) {
+        this.setLastError(resp?.message || "接口返回异常");
+        logger.warn(path6 + " error: " + (resp?.message || "unknown"));
+        this.logRequestFailureDetails("POST", path6, headers, params, json, resp);
+        return null;
+      }
+      return resp?.data ?? {};
+    } catch (e) {
+      const message = this.formatHttpError(e);
+      this.setLastError(message);
+      this.logRequestFailureDetails("POST", path6, headers, params, json, e);
+      const err = e;
+      if (err?.response) {
+        logger.warn("POST " + path6 + " failed: " + message);
+      } else {
+        logger.error("POST " + path6 + " failed: " + message);
+      }
+      return null;
+    }
+  }
+  async delete(ctx, path6, headers) {
+    try {
+      const resp = await ctx.http("DELETE", `${this.baseUrl}${path6}`, { headers, timeout: this.timeout });
+      if (resp?.code !== 0) {
+        this.setLastError(resp?.message || "接口返回异常");
+        logger.warn(path6 + " error: " + (resp?.message || "unknown"));
+        this.logRequestFailureDetails("DELETE", path6, headers, void 0, void 0, resp);
+        return null;
+      }
+      return resp?.data ?? {};
+    } catch (e) {
+      const message = this.formatHttpError(e);
+      this.setLastError(message);
+      this.logRequestFailureDetails("DELETE", path6, headers, void 0, void 0, e);
+      const err = e;
+      if (err?.response) {
+        logger.warn("DELETE " + path6 + " failed: " + message);
+      } else {
+        logger.error("DELETE " + path6 + " failed: " + message);
+      }
+      return null;
+    }
+  }
+  // Login and binding APIs.
+  async requestWithStatus(ctx, method, path6, headers, options = {}) {
+    const acceptedStatuses = options.acceptedStatuses || [200];
+    try {
+      const response = await ctx.http(method, `${this.baseUrl}${path6}`, {
+        headers,
+        params: options.params,
+        data: options.json,
+        timeout: this.timeout,
+        validateStatus: /* @__PURE__ */ __name(() => true, "validateStatus")
+      });
+      const status = Number(response?.status ?? response?.statusCode ?? 200);
+      const body = response?.data !== void 0 ? response.data : response;
+      if (body?.code !== void 0 && body.code !== 0) {
+        this.setLastError(body.message || body.msg || "接口返回异常");
+        this.logRequestFailureDetails(method, path6, headers, options.params, options.json, body);
+        return { status: null, data: null };
+      }
+      const data = body?.code !== void 0 ? body.data ?? {} : body ?? {};
+      if (!acceptedStatuses.includes(status)) {
+        this.setLastError(`HTTP ${status}`);
+        this.logRequestFailureDetails(method, path6, headers, options.params, options.json, response);
+      }
+      return { status, data };
+    } catch (e) {
+      const message = this.formatHttpError(e);
+      this.setLastError(message);
+      this.logRequestFailureDetails(method, path6, headers, options.params, options.json, e);
+      return { status: null, data: null };
+    }
+  }
+  async getIngameTask(ctx, taskId) {
+    return this.requestWithStatus(
+      ctx,
+      "GET",
+      `/api/v1/games/rocom/ingame/tasks/${taskId}`,
+      this.wegameHeaders(),
+      { acceptedStatuses: [200, 202] }
+    );
+  }
+  async qqQrLogin(ctx, userIdentifier) {
+    const params = { client_type: "bot", client_id: "koishi", provider: "rocom" };
+    if (userIdentifier) params.user_identifier = this.sanitizeUid(userIdentifier);
+    return this.get(ctx, "/api/v1/login/wegame/qr", this.wegameHeaders("", userIdentifier, "bot", "koishi"), params);
+  }
+  async qqQrStatus(ctx, fwToken, userIdentifier) {
+    const params = {};
+    if (userIdentifier) params.user_identifier = this.sanitizeUid(userIdentifier);
+    return this.get(ctx, "/api/v1/login/wegame/status", this.wegameHeaders(fwToken, userIdentifier, "bot", "koishi"), params);
+  }
+  async wechatQrLogin(ctx, userIdentifier) {
+    const params = { client_type: "bot", client_id: "koishi", provider: "rocom" };
+    if (userIdentifier) params.user_identifier = this.sanitizeUid(userIdentifier);
+    return this.get(ctx, "/api/v1/login/wegame/wechat/qr", this.wegameHeaders("", userIdentifier, "bot", "koishi"), params);
+  }
+  async wechatQrStatus(ctx, fwToken, userIdentifier) {
+    const params = {};
+    if (userIdentifier) params.user_identifier = this.sanitizeUid(userIdentifier);
+    return this.get(ctx, "/api/v1/login/wegame/wechat/status", this.wegameHeaders(fwToken, userIdentifier, "bot", "koishi"), params);
+  }
+  async importToken(ctx, tgpId, tgpTicket, userIdentifier) {
+    const body = { tgp_id: tgpId, tgp_ticket: tgpTicket, provider: "rocom", client_type: "bot", client_id: "koishi" };
+    if (userIdentifier) body.user_identifier = this.sanitizeUid(userIdentifier);
+    return this.post(ctx, "/api/v1/login/wegame/token", this.wegameHeaders("", userIdentifier, "bot", "koishi"), body);
+  }
+  async createBinding(ctx, fwToken, userIdentifier) {
+    const payload = { framework_token: fwToken, user_identifier: this.sanitizeUid(userIdentifier), client_type: "bot", client_id: "koishi" };
+    return this.post(ctx, "/api/v1/user/bindings", this.wegameHeaders("", userIdentifier, "bot", "koishi"), payload);
+  }
+  async refreshBinding(ctx, bindingId, userIdentifier) {
+    return this.post(ctx, `/api/v1/user/bindings/${bindingId}/refresh`, this.wegameHeaders("", userIdentifier), {});
+  }
+  async deleteBinding(ctx, bindingId, userIdentifier) {
+    const res = await this.delete(ctx, `/api/v1/user/bindings/${bindingId}`, this.wegameHeaders("", userIdentifier));
+    return res !== null;
+  }
+  // 洛克王国游戏数据接口
+  async getRole(ctx, fwToken, accountType, userIdentifier = "") {
+    const params = {};
+    if (accountType) params.account_type = accountType;
+    return this.get(ctx, "/api/v1/games/rocom/profile/role", this.rocomHeaders(fwToken, userIdentifier), params);
+  }
+  async getEvaluation(ctx, fwToken, userIdentifier = "") {
+    return this.get(
+      ctx,
+      "/api/v1/games/rocom/profile/evaluation",
+      this.rocomHeaders(fwToken, userIdentifier),
+      void 0,
+      { silentFailureDetails: true }
+    );
+  }
+  getLastError(defaultMessage = "接口异常") {
+    return this.lastError || defaultMessage;
+  }
+  setLastError(message) {
+    this.lastError = message || "接口异常";
+  }
+  async getPetSummary(ctx, fwToken, userIdentifier = "") {
+    return this.get(ctx, "/api/v1/games/rocom/profile/pet-summary", this.rocomHeaders(fwToken, userIdentifier));
+  }
+  async getCollection(ctx, fwToken, userIdentifier = "") {
+    return this.get(ctx, "/api/v1/games/rocom/profile/collection", this.rocomHeaders(fwToken, userIdentifier));
+  }
+  async getBattleOverview(ctx, fwToken, userIdentifier = "") {
+    return this.get(ctx, "/api/v1/games/rocom/profile/battle-overview", this.rocomHeaders(fwToken, userIdentifier));
+  }
+  async getBattleList(ctx, fwToken, pageSize = 4, afterTime = "", userIdentifier = "") {
+    const params = { page_size: pageSize };
+    if (afterTime) params.after_time = afterTime;
+    return this.get(ctx, "/api/v1/games/rocom/battle/list", this.rocomHeaders(fwToken, userIdentifier), params);
+  }
+  isIngamePlayerPayload(data) {
+    if (!data || typeof data !== "object") return false;
+    return Boolean(
+      Array.isArray(data.rows) || Array.isArray(data.notes) || data.title || data.nickname || data.uid
+    );
+  }
+  async ingamePlayerSearch(ctx, uid) {
+    const sanitizedUid = this.sanitizeUid(uid);
+    if (!sanitizedUid) {
+      this.setLastError("UID 涓嶈兘涓虹┖");
+      return null;
+    }
+    const path6 = "/api/v1/games/rocom/ingame/player/search";
+    const headers = this.wegameHeaders();
+    const payload = { uid: sanitizedUid, wait_ms: 5e3 };
+    let { status, data } = await this.requestWithStatus(ctx, "POST", path6, headers, {
+      json: payload,
+      acceptedStatuses: [200, 202]
+    });
+    if (status === 200 && data && this.isIngamePlayerPayload(data)) return data;
+    if (status === null) {
+      const fallback = await this.requestWithStatus(ctx, "GET", path6, headers, {
+        params: payload,
+        acceptedStatuses: [200, 202]
+      });
+      status = fallback.status;
+      data = fallback.data;
+      if (status === 200 && data && this.isIngamePlayerPayload(data)) return data;
+    }
+    if (!data) return null;
+    if (this.isIngamePlayerPayload(data)) return data;
+    const taskId = data.task_id || data.taskId || data.taskID;
+    if (!taskId) {
+      if (status === 202) this.setLastError("玩家搜索任务已入队，但未返回 task_id");
+      return data;
+    }
+    for (let i = 0; i < 8; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const task = await this.getIngameTask(ctx, taskId);
+      if (task.status === 200) return task.data;
+      if (task.status === null) return null;
+    }
+    this.setLastError("Player search task is still queued, please retry later (task_id: " + taskId + ")");
+    return null;
+  }
+  async getPets(ctx, fwToken, petSubset = 0, pageNo = 1, pageSize = 10, userIdentifier = "") {
+    const params = { pet_subset: petSubset, page_no: pageNo, page_size: pageSize };
+    return this.get(ctx, "/api/v1/games/rocom/battle/pets", this.rocomHeaders(fwToken, userIdentifier), params);
+  }
+  async getLineupList(ctx, fwToken, pageNo = 1, category = "", userIdentifier = "") {
+    const params = { page_no: pageNo };
+    if (category) params.category = category;
+    return this.get(ctx, "/api/v1/games/rocom/lineup/list", this.rocomHeaders(fwToken, userIdentifier), params);
+  }
+  async getExchangePosters(ctx, fwToken, pageNo = 1, userIdentifier = "") {
+    const params = { page_no: Math.max(pageNo, 1), refresh: "false" };
+    return this.get(ctx, "/api/v1/games/rocom/exchange/posters", this.wegameHeaders(fwToken, userIdentifier), params);
+  }
+  async getMerchantInfo(ctx, refresh = false) {
+    return this.get(ctx, "/api/v1/games/rocom/merchant/info", this.wegameHeaders(), { refresh: refresh ? "true" : "false" });
+  }
+  async queryPetSize(ctx, diameter, weight) {
+    return this.get(ctx, "/api/v1/games/rocom/pet/size-query", this.wegameHeaders(), { diameter, weight });
+  }
+  async ingameHomeInfo(ctx, uid, waitMs = 5e3) {
+    const sanitizedUid = this.sanitizeUid(uid);
+    if (!sanitizedUid) {
+      this.setLastError("UID 涓嶈兘涓虹┖");
+      return null;
+    }
+    const path6 = "/api/v1/games/rocom/ingame/home/info";
+    const headers = this.wegameHeaders();
+    const payload = { uid: sanitizedUid, wait_ms: waitMs };
+    let { status, data } = await this.requestWithStatus(ctx, "POST", path6, headers, {
+      json: payload,
+      acceptedStatuses: [200, 202]
+    });
+    if (status === 200 && data && !(data.task_id || data.taskId || data.taskID)) return data;
+    if (status === null) {
+      const fallback = await this.requestWithStatus(ctx, "GET", path6, headers, {
+        params: payload,
+        acceptedStatuses: [200, 202]
+      });
+      status = fallback.status;
+      data = fallback.data;
+      if (status === 200 && data && !(data.task_id || data.taskId || data.taskID)) return data;
+    }
+    const taskId = data?.task_id || data?.taskId || data?.taskID;
+    if (!taskId) {
+      if (status === 202) this.setLastError("家园查询任务已入队，但未返回 task_id");
+      return null;
+    }
+    for (let i = 0; i < 10; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const task = await this.getIngameTask(ctx, taskId);
+      if (task.status === 200) return task.data;
+      if (task.status === null) return null;
+    }
+    this.setLastError(`Home query task is still queued, please retry later (task_id: ${taskId})`);
+    return null;
+  }
+  async ingameMerchantInfo(ctx, shopId) {
+    const params = { shop_id: shopId };
+    const data = await this.get(
+      ctx,
+      "/api/v1/games/rocom/ingame/merchant/info",
+      this.wegameHeaders(),
+      params,
+      { silentFailureDetails: true }
+    );
+    if (data) return data;
+    return this.post(ctx, "/api/v1/games/rocom/ingame/merchant/info", this.wegameHeaders(), params);
+  }
+  async getFriendship(ctx, fwToken, userIds, userIdentifier = "") {
+    return this.get(
+      ctx,
+      "/api/v1/games/rocom/social/friendship",
+      this.rocomHeaders(fwToken, userIdentifier),
+      { user_ids: userIds }
+    );
+  }
+  async getStudentState(ctx, fwToken, accountType, userIdentifier = "") {
+    const params = {};
+    if (accountType !== void 0) params.account_type = accountType;
+    return this.get(ctx, "/api/v1/games/rocom/activity/student-state", this.rocomHeaders(fwToken, userIdentifier), params);
+  }
+  async getStudentPerks(ctx, fwToken, area, accountType, userIdentifier = "") {
+    const params = {};
+    if (area !== void 0) params.area = area;
+    if (accountType !== void 0) params.account_type = accountType;
+    return this.get(ctx, "/api/v1/games/rocom/activity/perks", this.rocomHeaders(fwToken, userIdentifier), params);
+  }
+  async searchWikiPet(ctx, query, limit = 10) {
+    return this.get(ctx, "/api/v1/games/rocom/wiki/pet", this.wegameHeaders(), { q: query, limit });
+  }
+  async searchWikiSkill(ctx, query, limit = 10) {
+    return this.get(ctx, "/api/v1/games/rocom/wiki/skill", this.wegameHeaders(), { q: query, limit });
+  }
+};
+
+// src/user.ts
+var import_koishi2 = require("koishi");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var logger2 = new import_koishi2.Logger("rocom-user");
+var JsonStore = class {
+  static {
+    __name(this, "JsonStore");
+  }
+  filePath;
+  data;
+  constructor(dataDir, filename, defaultData) {
+    if (!import_node_fs.default.existsSync(dataDir)) import_node_fs.default.mkdirSync(dataDir, { recursive: true });
+    this.filePath = import_node_path.default.join(dataDir, filename);
+    this.data = this.load(defaultData);
+  }
+  load(defaultData) {
+    if (import_node_fs.default.existsSync(this.filePath)) {
+      try {
+        return JSON.parse(import_node_fs.default.readFileSync(this.filePath, "utf-8"));
+      } catch (e) {
+        logger2.error(`加载 ${this.filePath} 失败: ${e}`);
+      }
+    }
+    return JSON.parse(JSON.stringify(defaultData));
+  }
+  save() {
+    try {
+      const tmp = this.filePath + ".tmp";
+      import_node_fs.default.writeFileSync(tmp, JSON.stringify(this.data, null, 2), "utf-8");
+      import_node_fs.default.renameSync(tmp, this.filePath);
+    } catch (e) {
+      logger2.error(`保存 ${this.filePath} 失败: ${e}`);
+    }
+  }
+  get() {
+    return this.data;
+  }
+  set(data) {
+    this.data = data;
+    this.save();
+  }
+};
+var UserManager = class {
+  static {
+    __name(this, "UserManager");
+  }
+  store;
+  constructor(dataDir) {
+    this.store = new JsonStore(dataDir, "rocom_bindings.json", {});
+  }
+  getUserBindings(userId) {
+    return [...this.store.get()[userId] || []];
+  }
+  getPrimaryBinding(userId) {
+    const bindings = this.getUserBindings(userId);
+    return bindings.find((b) => b.is_primary) || bindings[0] || null;
+  }
+  saveUserBindings(userId, bindings) {
+    const seen = /* @__PURE__ */ new Set();
+    const cleaned = bindings.map((binding) => {
+      const { framework_token: _frameworkToken, ...rest } = binding;
+      return rest;
+    }).filter((binding) => {
+      const id = binding.binding_id || binding.role_id;
+      if (seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    });
+    if (cleaned.length > 0 && !cleaned.some((b) => b.is_primary)) {
+      cleaned[0].is_primary = true;
+    }
+    const data = this.store.get();
+    data[userId] = cleaned;
+    this.store.set(data);
+  }
+  addBinding(userId, binding) {
+    const existing = this.getUserBindings(userId);
+    existing.forEach((b) => b.is_primary = false);
+    binding.is_primary = true;
+    existing.push(binding);
+    this.saveUserBindings(userId, existing);
+  }
+  deleteUserBinding(userId, index) {
+    const bindings = this.getUserBindings(userId);
+    if (index < 1 || index > bindings.length) return null;
+    const removed = bindings.splice(index - 1, 1)[0];
+    this.saveUserBindings(userId, bindings);
+    return removed;
+  }
+  switchPrimary(userId, index) {
+    const bindings = this.getUserBindings(userId);
+    if (index < 1 || index > bindings.length) return false;
+    bindings.forEach((b, i) => b.is_primary = i + 1 === index);
+    this.saveUserBindings(userId, bindings);
+    return true;
+  }
+  removeBindingById(userId, bindingId) {
+    const data = this.store.get();
+    const bindings = data[userId] || [];
+    const filtered = bindings.filter((b) => b.binding_id !== bindingId);
+    if (filtered.length < bindings.length) {
+      data[userId] = filtered;
+      this.store.set(data);
+      return true;
+    }
+    return false;
+  }
+  getAllUsersBindings() {
+    return JSON.parse(JSON.stringify(this.store.get()));
+  }
+};
+var MerchantSubscriptionManager = class {
+  static {
+    __name(this, "MerchantSubscriptionManager");
+  }
+  store;
+  constructor(dataDir) {
+    this.store = new JsonStore(dataDir, "rocom_merchant_subscriptions.json", {});
+  }
+  upsert(key, sub) {
+    const data = this.store.get();
+    data[key] = { ...sub };
+    this.store.set(data);
+  }
+  get(key) {
+    return this.store.get()[key] || null;
+  }
+  delete(key) {
+    const data = this.store.get();
+    if (!(key in data)) return false;
+    delete data[key];
+    this.store.set(data);
+    return true;
+  }
+  getAll() {
+    return JSON.parse(JSON.stringify(this.store.get()));
+  }
+};
+var HomeSubscriptionManager = class {
+  static {
+    __name(this, "HomeSubscriptionManager");
+  }
+  store;
+  constructor(dataDir) {
+    this.store = new JsonStore(dataDir, "rocom_home_subscriptions.json", {});
+  }
+  upsert(key, sub) {
+    const data = this.store.get();
+    data[key] = { ...sub };
+    this.store.set(data);
+  }
+  deleteMatching(target, kind = "", uid = "") {
+    const data = this.store.get();
+    let deleted = 0;
+    for (const [key, sub] of Object.entries(data)) {
+      const sameTarget = sub.platform === target.platform && (sub.channel_id || "") === (target.channelId || "") && (sub.user_id || "") === (target.userId || "");
+      if (!sameTarget) continue;
+      if (kind && sub.kind !== kind) continue;
+      if (uid && sub.uid !== uid) continue;
+      delete data[key];
+      deleted++;
+    }
+    if (deleted) this.store.set(data);
+    return deleted;
+  }
+  getAll() {
+    return JSON.parse(JSON.stringify(this.store.get()));
+  }
+};
+
+// src/egg-service.ts
+var import_koishi3 = require("koishi");
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+var logger3 = new import_koishi3.Logger("rocom-egg");
+var EGG_GROUP_META = {
+  1: { label: "未发现", desc: "不能和任何精灵生蛋" },
+  2: { label: "怪兽", desc: "像怪兽一样的动物" },
+  3: { label: "两栖", desc: "两栖动物和水边生活的多栖动物" },
+  4: { label: "虫", desc: "看起来像虫子的精灵" },
+  5: { label: "飞行", desc: "会飞的精灵" },
+  6: { label: "陆上", desc: "生活在陆地上的精灵" },
+  7: { label: "妖精", desc: "可爱的小动物" },
+  8: { label: "植物", desc: "看起来像植物的精灵" },
+  9: { label: "人型", desc: "看起来像人的精灵" },
+  10: { label: "软体", desc: "看起来软软的精灵" },
+  11: { label: "矿物", desc: "身体由矿物组成的精灵" },
+  12: { label: "不定形", desc: "没有固定形态的精灵" },
+  13: { label: "鱼", desc: "看起来像鱼的精灵" },
+  14: { label: "龙", desc: "看起来像龙的精灵" },
+  15: { label: "机械", desc: "身体由机械组成的精灵" }
+};
+function getEggGroupLabel(id) {
+  return EGG_GROUP_META[id]?.label || `蛋组${id}`;
+}
+__name(getEggGroupLabel, "getEggGroupLabel");
+function formatEggGroups(ids) {
+  if (!ids?.length) return "暂无蛋组数据";
+  return ids.map(getEggGroupLabel).join(" / ");
+}
+__name(formatEggGroups, "formatEggGroups");
+function petName(p) {
+  return p?.localized?.zh?.name || p?.name || "???";
+}
+__name(petName, "petName");
+function petType(p) {
+  const parts = [];
+  const mt = p?.main_type?.localized?.zh;
+  if (mt) parts.push(mt);
+  const st = p?.sub_type?.localized?.zh;
+  if (st) parts.push(st);
+  return parts.join(" / ") || "未知";
+}
+__name(petType, "petType");
+function fmtDur(s) {
+  if (!s || s <= 0) return "暂无数据";
+  if (s % 86400 === 0) return `${s / 86400} 天`;
+  const h3 = s / 3600;
+  return h3 === Math.floor(h3) ? `${h3} 小时` : `${h3.toFixed(1)} 小时`;
+}
+__name(fmtDur, "fmtDur");
+function wt(v) {
+  return v != null ? Math.round(v / 1e3 * 10) / 10 : null;
+}
+__name(wt, "wt");
+function ht(v) {
+  return v != null ? Math.round(v) / 100 : null;
+}
+__name(ht, "ht");
+function fmtRange(lo, hi, u) {
+  if (lo == null && hi == null) return "暂无数据";
+  if (lo != null && hi != null) return lo === hi ? `${lo}${u}` : `${lo}-${hi}${u}`;
+  return `${lo ?? hi}${u}`;
+}
+__name(fmtRange, "fmtRange");
+function num(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+__name(num, "num");
+function formatNumber(value, digits = 2) {
+  const parsed = num(value);
+  if (parsed == null) return "";
+  return String(Number(parsed.toFixed(digits)));
+}
+__name(formatNumber, "formatNumber");
+function assetPetId(petId) {
+  const n = Number(petId);
+  if (isNaN(n)) return null;
+  return n >= 3e3 ? n : n + 3e3;
+}
+__name(assetPetId, "assetPetId");
+function petIconUrl(petId) {
+  const aid = assetPetId(petId);
+  return aid ? `https://game.gtimg.cn/images/rocom/rocodata/jingling/${aid}/icon.png` : "";
+}
+__name(petIconUrl, "petIconUrl");
+function petImageUrl(petId) {
+  const aid = assetPetId(petId);
+  return aid ? `https://game.gtimg.cn/images/rocom/rocodata/jingling/${aid}/image.png` : "";
+}
+__name(petImageUrl, "petImageUrl");
+var EggService = class {
+  static {
+    __name(this, "EggService");
+  }
+  pets = [];
+  byId = /* @__PURE__ */ new Map();
+  byZh = /* @__PURE__ */ new Map();
+  byEn = /* @__PURE__ */ new Map();
+  constructor(dataDir) {
+    this.load(dataDir);
+  }
+  load(dataDir) {
+    const filePath = import_node_path2.default.join(dataDir, "Pets.json");
+    if (!import_node_fs2.default.existsSync(filePath)) {
+      logger3.error(`Pets.json 不存在: ${filePath}`);
+      return;
+    }
+    try {
+      const raw = JSON.parse(import_node_fs2.default.readFileSync(filePath, "utf-8"));
+      this.pets = Array.isArray(raw) ? raw : [];
+      for (const p of this.pets) {
+        this.byId.set(p.id, p);
+        const zh = p.localized?.zh?.name;
+        if (zh) this.byZh.set(zh, p);
+        const en = p.name?.toLowerCase();
+        if (en) this.byEn.set(en, p);
+      }
+      logger3.info(`加载 ${this.pets.length} 只精灵`);
+    } catch (e) {
+      logger3.error(`加载 Pets.json 失败: ${e}`);
+    }
+  }
+  getEggGroups(pet) {
+    return pet?.breeding_profile?.egg_groups || [];
+  }
+  search(keyword) {
+    const kw = keyword.trim();
+    if (!kw) return { matchType: "not_found" };
+    if (this.byZh.has(kw)) return { matchType: "exact", pet: this.byZh.get(kw) };
+    const pid = Number(kw);
+    if (!isNaN(pid) && this.byId.has(pid)) return { matchType: "exact", pet: this.byId.get(pid) };
+    if (this.byEn.has(kw.toLowerCase())) return { matchType: "exact", pet: this.byEn.get(kw.toLowerCase()) };
+    const kwLower = kw.toLowerCase();
+    const hits = this.pets.filter((p) => {
+      const zh = p.localized?.zh?.name || "";
+      const en = p.name || "";
+      return zh.toLowerCase().includes(kwLower) || en.toLowerCase().includes(kwLower);
+    });
+    if (hits.length === 1) return { matchType: "fuzzy", pet: hits[0] };
+    if (hits.length > 1) return { matchType: "multi", candidates: hits.slice(0, 20) };
+    return { matchType: "not_found" };
+  }
+  searchBySize(height, weight) {
+    const perfect = [], range = [];
+    for (const p of this.pets) {
+      const br = p.breeding || {};
+      let hMatch = null, wMatch = null;
+      if (height != null) {
+        const hLo = br.height_low, hHi = br.height_high;
+        if (hLo != null && hHi != null) {
+          if (hLo <= height && height <= hHi) hMatch = "perfect";
+          else if (hLo * 0.85 <= height && height <= hHi * 1.15) hMatch = "range";
+          else hMatch = "none";
+        } else hMatch = "none";
+      }
+      if (weight != null) {
+        const wLo = br.weight_low, wHi = br.weight_high;
+        if (wLo != null && wHi != null) {
+          const wKgLo = wLo / 1e3, wKgHi = wHi / 1e3;
+          if (wKgLo <= weight && weight <= wKgHi) wMatch = "perfect";
+          else if (wKgLo * 0.85 <= weight && weight <= wKgHi * 1.15) wMatch = "range";
+          else wMatch = "none";
+        } else wMatch = "none";
+      }
+      if (height != null && weight != null) {
+        if (hMatch === "perfect" && wMatch === "perfect") perfect.push(p);
+        else if (hMatch !== "none" && wMatch !== "none") range.push(p);
+      } else if (height != null) {
+        if (hMatch === "perfect") perfect.push(p);
+        else if (hMatch === "range") range.push(p);
+      } else if (weight != null) {
+        if (wMatch === "perfect") perfect.push(p);
+        else if (wMatch === "range") range.push(p);
+      }
+    }
+    return { perfect: perfect.slice(0, 20), range: range.slice(0, 20) };
+  }
+  formatMatchSummary(probability, matchCount) {
+    const parts = [];
+    if (probability != null) parts.push(`匹配率 ${formatNumber(probability)}%`);
+    if (matchCount != null) parts.push(`命中次数 ${formatNumber(matchCount, 0)}`);
+    return parts.join(" / ");
+  }
+  calcLocalMatchInfo(queryHeight, queryWeight, heightMin, heightMax, weightMin, weightMax) {
+    const scores = [];
+    if (queryHeight != null) {
+      const score = this.rangeMatchScore(ht(queryHeight), heightMin, heightMax);
+      if (score != null) scores.push(score);
+    }
+    if (queryWeight != null) {
+      const score = this.rangeMatchScore(queryWeight, weightMin, weightMax);
+      if (score != null) scores.push(score);
+    }
+    if (!scores.length) return { probability: null, matchCount: null };
+    return {
+      probability: scores.reduce((sum, score) => sum + score, 0) / scores.length,
+      matchCount: scores.length
+    };
+  }
+  rangeMatchScore(value, low, high) {
+    const valueNum = num(value);
+    const lowNum = num(low);
+    const highNum = num(high);
+    if (valueNum == null || lowNum == null || highNum == null) return null;
+    if (lowNum <= valueNum && valueNum <= highNum) return 100;
+    let tolerance;
+    let distance;
+    if (valueNum < lowNum) {
+      tolerance = Math.max(lowNum * 0.15, 1e-4);
+      distance = lowNum - valueNum;
+    } else {
+      tolerance = Math.max(highNum * 0.15, 1e-4);
+      distance = valueNum - highNum;
+    }
+    if (distance > tolerance) return 0;
+    return Math.max(0, 100 * (1 - distance / tolerance));
+  }
+  formatPetCard(pet, queryHeight, queryWeight) {
+    const br = pet?.breeding || {};
+    const eggGroups = this.getEggGroups(pet);
+    const heightMin = ht(br.height_low);
+    const heightMax = ht(br.height_high);
+    const weightMin = wt(br.weight_low);
+    const weightMax = wt(br.weight_high);
+    const { probability, matchCount } = this.calcLocalMatchInfo(
+      queryHeight,
+      queryWeight,
+      heightMin,
+      heightMax,
+      weightMin,
+      weightMax
+    );
+    return {
+      id: pet?.id,
+      name: petName(pet),
+      icon: petIconUrl(pet?.id),
+      image: petImageUrl(pet?.id),
+      type_label: petType(pet),
+      egg_group_ids: eggGroups,
+      egg_groups_label: formatEggGroups(eggGroups),
+      height_min: heightMin,
+      height_max: heightMax,
+      height_label: fmtRange(heightMin, heightMax, "m"),
+      weight_min: weightMin,
+      weight_max: weightMax,
+      weight_label: fmtRange(weightMin, weightMax, "kg"),
+      probability,
+      match_count: matchCount,
+      match_info_label: this.formatMatchSummary(probability, matchCount)
+    };
+  }
+  formatSizeApiCard(item) {
+    const probability = num(item?.probability);
+    const matchCount = num(item?.matchCount);
+    const heightMin = num(item?.diameterMin);
+    const heightMax = num(item?.diameterMax);
+    const weightMin = num(item?.weightMin);
+    const weightMax = num(item?.weightMax);
+    return {
+      id: item?.petId || "-",
+      name: item?.pet || "未知精灵",
+      icon: item?.petIcon || petIconUrl(item?.petId),
+      image: item?.petImage || petImageUrl(item?.petId),
+      type_label: "后端未提供",
+      egg_group_ids: [],
+      egg_groups_label: "后端未提供",
+      height_min: heightMin,
+      height_max: heightMax,
+      height_label: fmtRange(heightMin, heightMax, "m"),
+      weight_min: weightMin,
+      weight_max: weightMax,
+      weight_label: fmtRange(weightMin, weightMax, "kg"),
+      probability,
+      match_count: matchCount,
+      match_info_label: this.formatMatchSummary(probability, matchCount)
+    };
+  }
+  mergeCardsByName(perfect, ranged) {
+    const perfectMap = /* @__PURE__ */ new Map();
+    const rangedMap = /* @__PURE__ */ new Map();
+    const keyOf = /* @__PURE__ */ __name((item) => String(item?.name || item?.id || "").replace(/\s+/g, ""), "keyOf");
+    const add = /* @__PURE__ */ __name((target, item) => {
+      const key = keyOf(item);
+      if (!key) return;
+      target.set(key, target.has(key) ? this.mergeSizeCard(target.get(key), item) : item);
+    }, "add");
+    for (const item of perfect) add(perfectMap, item);
+    for (const item of ranged) {
+      const key = keyOf(item);
+      if (key && perfectMap.has(key)) {
+        perfectMap.set(key, this.mergeSizeCard(perfectMap.get(key), item));
+      } else {
+        add(rangedMap, item);
+      }
+    }
+    return [[...perfectMap.values()], [...rangedMap.values()]];
+  }
+  mergeSizeCard(left, right) {
+    const unique = /* @__PURE__ */ __name((values) => [...new Set(values.filter((value) => value != null && value !== "").map((value) => String(value)))], "unique");
+    const ids = unique([...String(left?.id || "").split("/"), ...String(right?.id || "").split("/")].map((value) => value.trim().replace(/^#/, "")));
+    const eggGroupIds = unique([...left?.egg_group_ids || [], ...right?.egg_group_ids || []]).map(Number);
+    const probabilityValues = [num(left?.probability), num(right?.probability)].filter((value) => value != null);
+    const matchCountValues = [num(left?.match_count), num(right?.match_count)].filter((value) => value != null);
+    const heightMin = this.minValue(left?.height_min, right?.height_min);
+    const heightMax = this.maxValue(left?.height_max, right?.height_max);
+    const weightMin = this.minValue(left?.weight_min, right?.weight_min);
+    const weightMax = this.maxValue(left?.weight_max, right?.weight_max);
+    const probability = probabilityValues.length ? probabilityValues.reduce((sum, value) => sum + value, 0) : null;
+    const matchCount = matchCountValues.length ? matchCountValues.reduce((sum, value) => sum + value, 0) : null;
+    return {
+      ...left,
+      id: ids.join("/"),
+      egg_group_ids: eggGroupIds,
+      egg_groups_label: eggGroupIds.length ? formatEggGroups(eggGroupIds) : unique([left?.egg_groups_label, right?.egg_groups_label]).join(" / ") || left?.egg_groups_label,
+      probability,
+      match_count: matchCount,
+      match_info_label: this.formatMatchSummary(probability, matchCount),
+      height_min: heightMin,
+      height_max: heightMax,
+      height_label: fmtRange(heightMin, heightMax, "m"),
+      weight_min: weightMin,
+      weight_max: weightMax,
+      weight_label: fmtRange(weightMin, weightMax, "kg")
+    };
+  }
+  minValue(...values) {
+    const numbers = values.map(num).filter((value) => value != null);
+    return numbers.length ? Math.min(...numbers) : null;
+  }
+  maxValue(...values) {
+    const numbers = values.map(num).filter((value) => value != null);
+    return numbers.length ? Math.max(...numbers) : null;
+  }
+  getCompatiblePets(pet) {
+    const groups = new Set(this.getEggGroups(pet));
+    if (!groups.size || groups.has(1)) return [];
+    return this.pets.filter((o) => {
+      if (o.id === pet.id) return false;
+      const og = new Set(this.getEggGroups(o));
+      if (!og.size || og.has(1)) return false;
+      for (const g of groups) if (og.has(g)) return true;
+      return false;
+    });
+  }
+  getBreedingParents(pet) {
+    const eggGroups = new Set(this.getEggGroups(pet));
+    if (!eggGroups.size || eggGroups.has(1)) return [];
+    return this.pets.filter((o) => {
+      if (o.id === pet.id) return false;
+      const og = new Set(this.getEggGroups(o));
+      if (!og.size || og.has(1)) return false;
+      for (const g of eggGroups) if (og.has(g)) return true;
+      return false;
+    });
+  }
+  evaluatePair(a, b) {
+    const ga = new Set(this.getEggGroups(a)), gb = new Set(this.getEggGroups(b));
+    const shared = [...ga].filter((g) => gb.has(g)).sort();
+    const reasons = [];
+    if (!ga.size) reasons.push(`${petName(a)} 暂无蛋组数据`);
+    if (!gb.size) reasons.push(`${petName(b)} 暂无蛋组数据`);
+    if (ga.has(1)) reasons.push(`${petName(a)} 属于「未发现」蛋组`);
+    if (gb.has(1)) reasons.push(`${petName(b)} 属于「未发现」蛋组`);
+    if (!shared.length && !reasons.length) reasons.push("蛋组不相同，无法配种");
+    const br = a.breeding || {};
+    return {
+      compatible: !reasons.length && shared.length > 0,
+      reasons,
+      shared_egg_groups: shared,
+      shared_egg_group_labels: shared.map(getEggGroupLabel),
+      hatch_label: fmtDur(br.hatch_data),
+      weight_label: fmtRange(wt(br.weight_low), wt(br.weight_high), "kg"),
+      height_label: fmtRange(br.height_low, br.height_high, "cm")
+    };
+  }
+  // ─── 文本构建 ───
+  buildSizeSearchText(height, weight, results, heightDisplay) {
+    const cond = [];
+    if (height != null) cond.push(`身高=${heightDisplay || fmtRange(ht(height), ht(height), "m")}`);
+    if (weight != null) cond.push(`体重=${weight}kg`);
+    const condStr = cond.join(" + ");
+    if (!results || !results.perfect.length && !results.range.length) return `❌ 未找到符合 ${condStr} 的精灵。`;
+    const lines = [];
+    if (results.perfect.length) {
+      lines.push(`✅ 完美匹配 ${condStr} 的精灵（共 ${results.perfect.length} 只）：`);
+      results.perfect.slice(0, 10).forEach((p, i) => {
+        const br = p.breeding || {};
+        lines.push(`  ${i + 1}. ${petName(p)} (#${p.id}) — ${fmtRange(ht(br.height_low), ht(br.height_high), "m")} / ${fmtRange(wt(br.weight_low), wt(br.weight_high), "kg")} · ${formatEggGroups(this.getEggGroups(p))}`);
+      });
+    }
+    if (results.range.length) {
+      if (lines.length) lines.push("");
+      lines.push(`🔍 范围匹配 ${condStr} 的精灵（共 ${results.range.length} 只，容差±15%）：`);
+      results.range.slice(0, 10).forEach((p, i) => {
+        const br = p.breeding || {};
+        lines.push(`  ${i + 1}. ${petName(p)} (#${p.id}) — ${fmtRange(ht(br.height_low), ht(br.height_high), "m")} / ${fmtRange(wt(br.weight_low), wt(br.weight_high), "kg")} · ${formatEggGroups(this.getEggGroups(p))}`);
+      });
+    }
+    return lines.join("\n");
+  }
+  buildSizeSearchTextFromApi(height, weight, results, heightDisplay) {
+    const cond = [];
+    if (height != null) cond.push(`身高=${heightDisplay || fmtRange(ht(height), ht(height), "m")}`);
+    if (weight != null) cond.push(`体重=${weight}kg`);
+    const condStr = cond.join(" + ") || "当前条件";
+    const exact = results?.exactResults || [];
+    const candidates = results?.candidates || [];
+    if (!exact.length && !candidates.length) return `❌ 未找到符合 ${condStr} 的精灵。`;
+    const lines = [];
+    if (exact.length) {
+      lines.push(`✅ 完美匹配 ${condStr} 的精灵（共 ${exact.length} 只）：`);
+      exact.slice(0, 10).forEach((item, i) => {
+        const card = this.formatSizeApiCard(item);
+        lines.push(`  ${i + 1}. ${card.name} (#${card.id}) — ${card.height_label} / ${card.weight_label}`);
+      });
+    }
+    if (candidates.length) {
+      if (lines.length) lines.push("");
+      lines.push(`🔍 范围匹配 ${condStr} 的精灵（共 ${candidates.length} 只）：`);
+      candidates.slice(0, 10).forEach((item, i) => {
+        const card = this.formatSizeApiCard(item);
+        lines.push(`  ${i + 1}. ${card.name} (#${card.id}) — ${card.height_label} / ${card.weight_label}`);
+      });
+    }
+    return lines.join("\n");
+  }
+  buildSearchText(pet) {
+    const egs = this.getEggGroups(pet);
+    const compat = this.getCompatiblePets(pet);
+    const lines = [
+      `🥚 ${petName(pet)} (#${pet.id})`,
+      `属性：${petType(pet)}`,
+      `蛋组：${formatEggGroups(egs)}`,
+      `可配种精灵数：${compat.length}`
+    ];
+    if (egs.includes(1)) lines.push("⚠️ 该精灵属于「未发现」蛋组，无法配种。");
+    return lines.join("\n");
+  }
+  buildCandidatesText(keyword, candidates) {
+    const lines = [`🔍 「${keyword}」匹配到 ${candidates.length} 只精灵，请精确输入：`];
+    candidates.slice(0, 10).forEach((p, i) => {
+      lines.push(`  ${i + 1}. ${petName(p)} (#${p.id}) — ${petType(p)} · ${formatEggGroups(this.getEggGroups(p))}`);
+    });
+    if (candidates.length > 10) lines.push(`  ... 还有 ${candidates.length - 10} 个结果`);
+    return lines.join("\n");
+  }
+  buildWantPetText(pet) {
+    const zh = petName(pet);
+    const egs = this.getEggGroups(pet);
+    const lines = [`🥚 想要孵出「${zh}」：`, `蛋组：${formatEggGroups(egs)}`];
+    if (egs.includes(1)) {
+      lines.push("⚠️ 该精灵属于「未发现」蛋组，无法通过配种获得。");
+      return lines.join("\n");
+    }
+    lines.push(`
+📌 母体必须是「${zh}」（孵蛋结果跟随母体）`);
+    const fathers = this.getBreedingParents(pet);
+    if (fathers.length) {
+      lines.push(`
+🔗 可选父体（共 ${fathers.length} 只）：`);
+      fathers.slice(0, 15).forEach((f, i) => {
+        lines.push(`  ${i + 1}. ${petName(f)} — ${formatEggGroups(this.getEggGroups(f))}`);
+      });
+      if (fathers.length > 15) lines.push(`  ... 还有 ${fathers.length - 15} 只`);
+    } else {
+      lines.push("\n❌ 未找到可配种的父体精灵。");
+    }
+    return lines.join("\n");
+  }
+  buildPairText(a, b) {
+    const ev = this.evaluatePair(a, b);
+    const ma = petName(a), fa = petName(b);
+    if (ev.compatible) {
+      return `✅ 父体 ${fa} × 母体 ${ma} 可以配种！
+共享蛋组：${ev.shared_egg_group_labels.join(" / ")}
+孵出结果：${ma}（跟随母体）
+孵化时长：${ev.hatch_label}`;
+    }
+    return `❌ ${fa} × ${ma} 无法配种。
+原因：${ev.reasons.join("；")}`;
+  }
+  // ─── 渲染数据构建 ───
+  buildSearchData(pet) {
+    const egs = this.getEggGroups(pet);
+    const compat = this.getCompatiblePets(pet);
+    const gmap = {};
+    for (const gid of egs) if (gid !== 1) gmap[gid] = [];
+    for (const c of compat) {
+      for (const gid of egs) {
+        if (gid !== 1 && this.getEggGroups(c).includes(gid)) {
+          gmap[gid] = gmap[gid] || [];
+          gmap[gid].push(c);
+        }
+      }
+    }
+    const sections = egs.map((gid) => {
+      const meta = EGG_GROUP_META[gid];
+      const members = gmap[gid] || [];
+      return {
+        id: gid,
+        label: meta?.label || `蛋组${gid}`,
+        desc: meta?.desc || "",
+        count: members.length,
+        members: members.slice(0, 30).map((m) => ({
+          name: petName(m),
+          id: m.id,
+          type_label: petType(m),
+          egg_groups_label: formatEggGroups(this.getEggGroups(m))
+        })),
+        has_more: members.length > 30,
+        total: members.length
+      };
+    });
+    const br = pet.breeding || {};
+    const bp = pet.breeding_profile || {};
+    const eggDetails = this.buildEggDetails(br);
+    return {
+      pet_name: petName(pet),
+      pet_id: pet.id,
+      pet_icon: petIconUrl(pet.id),
+      pet_image: petImageUrl(pet.id),
+      type_label: petType(pet),
+      egg_groups_label: formatEggGroups(egs),
+      egg_groups: egs,
+      egg_group_labels: Object.fromEntries(egs.map((gid) => [gid, getEggGroupLabel(gid)])),
+      male_rate: bp.male_rate ?? null,
+      female_rate: bp.female_rate ?? null,
+      hatch_label: fmtDur(br.hatch_data),
+      weight_label: fmtRange(wt(br.weight_low), wt(br.weight_high), "kg"),
+      height_label: fmtRange(br.height_low, br.height_high, "cm"),
+      total_compatible: compat.length,
+      is_undiscovered: egs.includes(1),
+      egg_group_sections: sections,
+      total_stats: ["base_hp", "base_phy_atk", "base_mag_atk", "base_phy_def", "base_mag_def", "base_spd"].reduce((sum, k) => sum + (pet[k] || 0), 0),
+      egg_details: eggDetails,
+      commandHint: "洛克查蛋 <名称> | 洛克查蛋 身高25 体重1.5 | 洛克配种 <父> <母>",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+  }
+  buildPairData(a, b) {
+    const ev = this.evaluatePair(a, b);
+    const makePetCard = /* @__PURE__ */ __name((p) => ({
+      name: petName(p),
+      id: p.id,
+      type_label: petType(p),
+      egg_groups_label: formatEggGroups(this.getEggGroups(p))
+    }), "makePetCard");
+    return {
+      mother: makePetCard(a),
+      father: makePetCard(b),
+      ...ev,
+      commandHint: "默认前父后母，孵蛋结果跟随母体 | 洛克配种 <精灵名> 查怎么孵",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+  }
+  buildWantPetData(pet) {
+    const fathers = this.getBreedingParents(pet);
+    const bp = pet.breeding_profile || {};
+    const eggGroups = this.getEggGroups(pet);
+    return {
+      target: this.formatPetCard(pet),
+      egg_groups_label: formatEggGroups(eggGroups),
+      female_rate: bp.female_rate ?? null,
+      male_rate: bp.male_rate ?? null,
+      is_undiscovered: eggGroups.includes(1),
+      fathers: fathers.slice(0, 30).map((p) => this.formatPetCard(p)),
+      father_count: fathers.length,
+      commandHint: "洛克配种 <父体> <母体> 查看详细结果",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+  }
+  buildCandidatesRenderData(keyword, candidates) {
+    return {
+      keyword,
+      count: candidates.length,
+      candidates: candidates.map((p) => this.formatPetCard(p)),
+      commandHint: "请使用更精确的名称重新查询",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+  }
+  buildSizeSearchData(height, weight, results, heightDisplay) {
+    const conditions = [];
+    if (height != null) conditions.push(`身高 ${heightDisplay || fmtRange(ht(height), ht(height), "m")}`);
+    if (weight != null) conditions.push(`体重 ${weight} kg`);
+    const [perfect, ranged] = this.mergeCardsByName(
+      (results?.perfect || []).map((p) => this.formatPetCard(p, height, weight)),
+      (results?.range || []).map((p) => this.formatPetCard(p, height, weight))
+    );
+    return {
+      query_label: conditions.join(" / ") || "尺寸反查",
+      perfect_matches: perfect,
+      range_matches: ranged,
+      total_count: perfect.length + ranged.length,
+      has_results: !!(perfect.length || ranged.length),
+      commandHint: "洛克查蛋 <精灵名> | 洛克查蛋 身高25 体重1.5",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+  }
+  buildSizeSearchDataFromApi(height, weight, results, heightDisplay) {
+    const conditions = [];
+    if (height != null) conditions.push(`身高 ${heightDisplay || fmtRange(ht(height), ht(height), "m")}`);
+    if (weight != null) conditions.push(`体重 ${weight} kg`);
+    const [perfect, ranged] = this.mergeCardsByName(
+      (results?.exactResults || []).map((item) => this.formatSizeApiCard(item)),
+      (results?.candidates || []).map((item) => this.formatSizeApiCard(item))
+    );
+    const searchMode = results?.searchMode || "";
+    const queryLabel = `${conditions.join(" / ") || "尺寸反查"}${searchMode ? ` · 模式 ${searchMode}` : ""}`;
+    return {
+      query_label: queryLabel,
+      perfect_matches: perfect,
+      range_matches: ranged,
+      total_count: perfect.length + ranged.length,
+      has_results: !!(perfect.length || ranged.length),
+      commandHint: "洛克查蛋 <精灵名> | 洛克查蛋 0.18m 1.5kg | 洛克查蛋 0.18",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+  }
+  buildEggDetails(breeding) {
+    if (!breeding) return { has_data: false };
+    const baseProb = breeding.egg_base_glass_prob_array;
+    const addProb = breeding.egg_add_glass_prob_array;
+    const preciousMap = {
+      1: "迪莫蛋",
+      2: "星辰蛋",
+      3: "彩虹蛋",
+      4: "梦幻蛋",
+      5: "传说蛋",
+      6: "神秘蛋",
+      7: "特殊蛋"
+    };
+    const variants = (breeding.variants || []).map((v) => ({
+      id: v.id,
+      name: v.name || "",
+      hatch_label: fmtDur(v.hatch_data),
+      weight_label: fmtRange(wt(v.weight_low), wt(v.weight_high), "kg"),
+      height_label: fmtRange(v.height_low, v.height_high, "cm"),
+      precious_egg_type: v.precious_egg_type,
+      precious_egg_label: preciousMap[v.precious_egg_type] || "普通蛋",
+      base_prob_str: v.egg_base_glass_prob_array?.length === 2 ? `${v.egg_base_glass_prob_array[0]}/${v.egg_base_glass_prob_array[1]}` : "暂无"
+    }));
+    return {
+      has_data: true,
+      base_prob_str: baseProb?.length === 2 ? `${baseProb[0]}/${baseProb[1]}` : "暂无数据",
+      base_prob_pct: baseProb?.length === 2 ? baseProb[0] / baseProb[1] * 100 : null,
+      add_prob_str: addProb?.length === 2 ? `${addProb[0]}/${addProb[1]}` : "暂无数据",
+      add_prob_pct: addProb?.length === 2 ? addProb[0] / addProb[1] * 100 : null,
+      is_contact_add_glass: breeding.is_contact_add_glass_prob,
+      is_contact_add_shining: breeding.is_contact_add_shining_prob,
+      precious_egg_type: breeding.precious_egg_type,
+      precious_egg_label: preciousMap[breeding.precious_egg_type] || "普通蛋",
+      variants,
+      variant_count: variants.length
+    };
+  }
+};
+
+// src/render.ts
+var import_koishi4 = require("koishi");
+var template = __toESM(require("art-template"));
+var import_node_fs3 = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path3 = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var logger4 = new import_koishi4.Logger("rocom-render");
+var TEMPLATE_CAPTURE_PADDING = {
+  package: { left: 0, right: 0, top: 0, bottom: 0 }
+};
+function toDirectoryFileUrl(dirPath) {
+  const href = (0, import_node_url.pathToFileURL)(dirPath).href;
+  return href.endsWith("/") ? href : `${href}/`;
+}
+__name(toDirectoryFileUrl, "toDirectoryFileUrl");
+function normalizeTemplateResourcePaths(content) {
+  return content.replace(/\{\{(_res_path|pluResPath)\}\}render\//g, "{{$1}}render-templates/");
+}
+__name(normalizeTemplateResourcePaths, "normalizeTemplateResourcePaths");
+var Renderer = class {
+  constructor(resPath) {
+    this.resPath = resPath;
+  }
+  static {
+    __name(this, "Renderer");
+  }
+  resourceUrl(relativePath) {
+    return (0, import_node_url.pathToFileURL)(import_node_path3.default.join(this.getResourceRoot(), relativePath)).href;
+  }
+  getResourceRoot() {
+    const builtRoot = import_node_path3.default.join(this.resPath, "lib");
+    if (import_node_fs3.default.existsSync(import_node_path3.default.join(builtRoot, "render-templates"))) return builtRoot;
+    return import_node_path3.default.join(this.resPath, "src");
+  }
+  getTemplateRoot() {
+    return import_node_path3.default.join(this.getResourceRoot(), "render-templates");
+  }
+  getTemplatePath(templateName) {
+    const directHtmlPath = import_node_path3.default.join(this.getTemplateRoot(), `${templateName}.html`);
+    if (import_node_fs3.default.existsSync(directHtmlPath)) return directHtmlPath;
+    return import_node_path3.default.join(this.getTemplateRoot(), templateName, "index.html");
+  }
+  getStylePath(templateName) {
+    return import_node_path3.default.join(this.getTemplateRoot(), templateName, "style.css");
+  }
+  async renderHtml(ctx, templateName, data) {
+    try {
+      const templatePath = this.getTemplatePath(templateName);
+      if (!import_node_fs3.default.existsSync(templatePath)) {
+        logger4.error(`template file missing: ${templatePath}`);
+        return null;
+      }
+      const templateContent = import_node_fs3.default.readFileSync(templatePath, "utf-8");
+      const normalizedTemplateContent = normalizeTemplateResourcePaths(templateContent);
+      const resPathUrl = toDirectoryFileUrl(this.getResourceRoot());
+      const renderData = { ...data, _res_path: resPathUrl, pluResPath: resPathUrl };
+      const html = template.render(normalizedTemplateContent, renderData);
+      if (!ctx.puppeteer?.page) {
+        logger4.error("puppeteer service is unavailable");
+        return null;
+      }
+      const page = await ctx.puppeteer.page();
+      const tempDir = import_node_fs3.default.mkdtempSync(import_node_path3.default.join(import_node_os.default.tmpdir(), "rocom-render-"));
+      const tempHtmlPath = import_node_path3.default.join(tempDir, `${templateName.replace(/[\\/]/g, "_")}.html`);
+      try {
+        await page.setCacheEnabled(false);
+        import_node_fs3.default.writeFileSync(tempHtmlPath, html, "utf-8");
+        await page.setViewport({ width: 1280, height: 768, deviceScaleFactor: 2 });
+        try {
+          await page.goto((0, import_node_url.pathToFileURL)(tempHtmlPath).href, {
+            waitUntil: "networkidle0",
+            timeout: 15e3
+          });
+        } catch (err) {
+          logger4.warn(`page.goto failed for ${templateName}: ${err}`);
+        }
+        try {
+          await page.evaluate(async () => {
+            const images = Array.from(document.images);
+            await Promise.all(images.map((img) => {
+              if (img.complete) return Promise.resolve();
+              return new Promise((resolve) => {
+                img.onload = () => resolve();
+                img.onerror = () => resolve();
+              });
+            }));
+            const fonts = document.fonts;
+            if (fonts?.ready) {
+              await fonts.ready;
+            }
+          });
+        } catch (err) {
+          logger4.warn(`asset wait failed for ${templateName}: ${err}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        const selectors = [
+          ".exchange-page",
+          ".record-page",
+          ".package-cont",
+          ".searcheggs-cont",
+          ".bwiki-shell",
+          ".skill-shell",
+          ".lineup-page",
+          ".lineup-detail-page",
+          ".page-section-main",
+          ".stats-cont",
+          ".inspect-page",
+          ".player-search-page",
+          ".ingame-shop-page",
+          ".friendship-page",
+          ".student-state-page",
+          ".student-perks-page",
+          ".student-page",
+          ".home-page"
+        ];
+        let target = null;
+        for (const selector of selectors) {
+          target = await page.$(selector);
+          if (target) break;
+        }
+        if (!target) {
+          target = await page.$("body");
+        }
+        if (target) {
+          const box = await target.boundingBox();
+          if (box && box.width > 0 && box.height > 0) {
+            const elementMetrics = await page.evaluate((el) => {
+              const rect = el.getBoundingClientRect();
+              const element = el;
+              return {
+                x: rect.left + window.scrollX,
+                y: rect.top + window.scrollY,
+                width: Math.max(rect.width, element.scrollWidth, element.offsetWidth),
+                height: Math.max(rect.height, element.scrollHeight, element.offsetHeight)
+              };
+            }, target);
+            const capturePadding = TEMPLATE_CAPTURE_PADDING[templateName] || { left: 0, right: 0, top: 0, bottom: 0 };
+            await page.setViewport({
+              width: Math.max(Math.ceil(elementMetrics.x + elementMetrics.width + capturePadding.right) + 8, 200),
+              height: Math.max(Math.ceil(elementMetrics.y + elementMetrics.height + capturePadding.bottom) + 8, 200),
+              deviceScaleFactor: 2
+            });
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const hasOverflow = elementMetrics.width > box.width + 0.5 || elementMetrics.height > box.height + 0.5;
+            if (capturePadding.left || capturePadding.right || capturePadding.top || capturePadding.bottom || hasOverflow) {
+              const clipX = Math.max(0, elementMetrics.x - capturePadding.left);
+              const clipY = Math.max(0, elementMetrics.y - capturePadding.top);
+              const clipWidth = elementMetrics.width + capturePadding.left + capturePadding.right;
+              const clipHeight = elementMetrics.height + capturePadding.top + capturePadding.bottom;
+              const screenshot3 = await page.screenshot({
+                type: "png",
+                clip: {
+                  x: clipX,
+                  y: clipY,
+                  width: clipWidth,
+                  height: clipHeight
+                }
+              });
+              return Buffer.isBuffer(screenshot3) ? screenshot3 : Buffer.from(screenshot3);
+            }
+          }
+          const screenshot2 = await target.screenshot({ type: "png" });
+          return Buffer.isBuffer(screenshot2) ? screenshot2 : Buffer.from(screenshot2);
+        }
+        const screenshot = await page.screenshot({ fullPage: true });
+        return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+      } finally {
+        try {
+          await page.close();
+        } catch {
+        }
+        import_node_fs3.default.rmSync(tempDir, { recursive: true, force: true });
+      }
+    } catch (e) {
+      logger4.error(`render failed: ${e}`);
+      return null;
+    }
+  }
+};
+
+// src/role-token.ts
+function normalize(value) {
+  return String(value ?? "").trim();
+}
+__name(normalize, "normalize");
+function pickLatest(rows) {
+  if (!rows.length) return null;
+  return [...rows].sort((a, b) => {
+    const aTime = new Date(a.updatedAt).getTime() || 0;
+    const bTime = new Date(b.updatedAt).getTime() || 0;
+    return bTime - aTime;
+  })[0] ?? null;
+}
+__name(pickLatest, "pickLatest");
+function pickLegacyToken(binding) {
+  return normalize(binding.framework_token);
+}
+__name(pickLegacyToken, "pickLegacyToken");
+function setupRoleTokenModel(ctx) {
+  ;
+  ctx.model.extend("roleToken", {
+    UserId: "string",
+    fwt: "string",
+    bindingId: "string",
+    roleId: "string",
+    loginType: "string",
+    updatedAt: "timestamp"
+  }, {
+    primary: "UserId",
+    indexes: ["bindingId"]
+  });
+}
+__name(setupRoleTokenModel, "setupRoleTokenModel");
+async function upsertRoleToken(ctx, payload) {
+  const userId = normalize(payload.userId);
+  const fwt = normalize(payload.fwt);
+  if (!userId || !fwt) return;
+  await ctx.database.remove("roleToken", { UserId: userId });
+  await ctx.database.upsert(
+    "roleToken",
+    () => [{
+      UserId: userId,
+      fwt,
+      bindingId: normalize(payload.bindingId),
+      roleId: normalize(payload.roleId),
+      loginType: normalize(payload.loginType),
+      updatedAt: /* @__PURE__ */ new Date()
+    }],
+    "UserId"
+  );
+}
+__name(upsertRoleToken, "upsertRoleToken");
+async function getRoleToken(ctx, userId) {
+  const normalizedUserId = normalize(userId);
+  if (!normalizedUserId) return null;
+  const rows = await ctx.database.get("roleToken", { UserId: normalizedUserId });
+  if (!Array.isArray(rows) || !rows.length) return null;
+  return pickLatest(rows);
+}
+__name(getRoleToken, "getRoleToken");
+async function removeRoleToken(ctx, userId) {
+  const normalizedUserId = normalize(userId);
+  if (!normalizedUserId) return;
+  await ctx.database.remove("roleToken", { UserId: normalizedUserId });
+}
+__name(removeRoleToken, "removeRoleToken");
+async function migrateRoleTokensToUserId(ctx) {
+  const rows = await ctx.database.get("roleToken", {});
+  if (!Array.isArray(rows) || !rows.length) return 0;
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const userId = normalize(row?.UserId);
+    if (!userId) continue;
+    const bucket = groups.get(userId) || [];
+    bucket.push(row);
+    groups.set(userId, bucket);
+  }
+  let migrated = 0;
+  for (const [userId, items] of groups) {
+    if (items.length <= 1) continue;
+    const latest = pickLatest(items);
+    if (!latest?.fwt) continue;
+    await removeRoleToken(ctx, userId);
+    await upsertRoleToken(ctx, {
+      userId,
+      fwt: latest.fwt,
+      bindingId: latest.bindingId,
+      roleId: latest.roleId,
+      loginType: latest.loginType
+    });
+    migrated++;
+  }
+  return migrated;
+}
+__name(migrateRoleTokensToUserId, "migrateRoleTokensToUserId");
+async function migrateLegacyFrameworkTokens(ctx, userMgr) {
+  const allUsers = userMgr.getAllUsersBindings();
+  let migrated = 0;
+  for (const [userId, bindings] of Object.entries(allUsers)) {
+    const normalizedUserId = normalize(userId);
+    if (!normalizedUserId) continue;
+    const existing = await getRoleToken(ctx, normalizedUserId);
+    const bindingsWithToken = bindings.filter((binding) => pickLegacyToken(binding));
+    const chosen = bindingsWithToken.find((binding) => binding.is_primary) || bindingsWithToken[0];
+    if (!existing?.fwt && chosen) {
+      const legacyToken = pickLegacyToken(chosen);
+      if (legacyToken) {
+        await upsertRoleToken(ctx, {
+          userId: normalizedUserId,
+          fwt: legacyToken,
+          bindingId: chosen.binding_id,
+          roleId: chosen.role_id,
+          loginType: chosen.login_type
+        });
+        migrated++;
+      }
+    }
+    if (bindingsWithToken.length > 0) {
+      let needsSave = false;
+      for (const binding of bindings) {
+        if (!binding.framework_token) continue;
+        delete binding.framework_token;
+        needsSave = true;
+      }
+      if (needsSave) {
+        userMgr.saveUserBindings(normalizedUserId, bindings);
+      }
+    }
+  }
+  return migrated;
+}
+__name(migrateLegacyFrameworkTokens, "migrateLegacyFrameworkTokens");
+
+// src/commands/account.ts
+var import_koishi6 = require("koishi");
+
+// src/send-image.ts
+var import_koishi5 = require("koishi");
+var import_node_zlib = __toESM(require("node:zlib"));
+var logger5 = new import_koishi5.Logger("rocom-send");
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function formatSessionContext(session) {
+  if (!session) return "session=<null>";
+  const platform = session.platform ?? "unknown";
+  const userId = session.userId ?? "unknown";
+  const guildId = session.guildId ?? "private";
+  const channelId = session.channelId ?? "unknown";
+  return `platform=${platform} user=${userId} guild=${guildId} channel=${channelId}`;
+}
+__name(formatSessionContext, "formatSessionContext");
+function hasSendResult(result) {
+  if (result == null) return false;
+  if (typeof result === "string") return result.length > 0;
+  if (Array.isArray(result)) return result.length > 0;
+  return true;
+}
+__name(hasSendResult, "hasSendResult");
+function crc32(buffer) {
+  let crc = 4294967295;
+  for (let i = 0; i < buffer.length; i++) {
+    crc ^= buffer[i];
+    for (let bit = 0; bit < 8; bit++) {
+      crc = crc >>> 1 ^ 3988292384 & -(crc & 1);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+__name(crc32, "crc32");
+function pngChunk(type, data) {
+  const typeBuffer = Buffer.from(type, "ascii");
+  const lengthBuffer = Buffer.allocUnsafe(4);
+  lengthBuffer.writeUInt32BE(data.length, 0);
+  const crcBuffer = Buffer.allocUnsafe(4);
+  crcBuffer.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
+  return Buffer.concat([lengthBuffer, typeBuffer, data, crcBuffer]);
+}
+__name(pngChunk, "pngChunk");
+function isPng(buffer) {
+  return buffer.length > PNG_SIGNATURE.length && buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE);
+}
+__name(isPng, "isPng");
+function compressPngImage(image, config) {
+  if (!config.imageCompressionEnabled) return image;
+  if (!isPng(image)) return image;
+  if (image.length < Math.max(0, config.imageCompressionMinBytes || 0)) return image;
+  try {
+    const chunks = [];
+    const idatChunks = [];
+    let offset = PNG_SIGNATURE.length;
+    while (offset + 12 <= image.length) {
+      const length = image.readUInt32BE(offset);
+      const type = image.subarray(offset + 4, offset + 8).toString("ascii");
+      const dataStart = offset + 8;
+      const dataEnd = dataStart + length;
+      const nextOffset = dataEnd + 4;
+      if (dataEnd > image.length || nextOffset > image.length) return image;
+      const data = image.subarray(dataStart, dataEnd);
+      chunks.push({ type, data });
+      if (type === "IDAT") idatChunks.push(data);
+      offset = nextOffset;
+      if (type === "IEND") break;
+    }
+    if (!idatChunks.length) return image;
+    const rawImageData = import_node_zlib.default.inflateSync(Buffer.concat(idatChunks));
+    const level = Math.max(0, Math.min(9, Math.floor(config.imageCompressionLevel ?? 9)));
+    const compressedIdat = import_node_zlib.default.deflateSync(rawImageData, { level });
+    const rebuiltChunks = [];
+    let wroteIdat = false;
+    for (const chunk of chunks) {
+      if (chunk.type === "IDAT") {
+        if (!wroteIdat) {
+          rebuiltChunks.push(pngChunk("IDAT", compressedIdat));
+          wroteIdat = true;
+        }
+        continue;
+      }
+      rebuiltChunks.push(pngChunk(chunk.type, chunk.data));
+    }
+    const compressed = Buffer.concat([PNG_SIGNATURE, ...rebuiltChunks]);
+    if (compressed.length < image.length) return compressed;
+  } catch (err) {
+    logger5.warn(`PNG compression failed, sending original image: ${err}`);
+  }
+  return image;
+}
+__name(compressPngImage, "compressPngImage");
+async function sendImageWithFallback(session, image, fallbackText, scene, compressionConfig) {
+  const ctxInfo = formatSessionContext(session);
+  if (!image) {
+    logger5.warn(`[${scene}] render returned empty image, fallback to text | ${ctxInfo}`);
+    try {
+      await session.send(fallbackText);
+    } catch (e) {
+      logger5.error(`[${scene}] text fallback send failed | ${ctxInfo} | ${e}`);
+    }
+    return;
+  }
+  const outputImage = compressionConfig ? compressPngImage(image, compressionConfig) : image;
+  if (outputImage.length < image.length) {
+    logger5.info(`[${scene}] compressed image ${image.length}B -> ${outputImage.length}B | ${ctxInfo}`);
+  }
+  try {
+    const result = await session.send(import_koishi5.h.image(outputImage, "image/png"));
+    if (!hasSendResult(result)) {
+      logger5.warn(`[${scene}] image send returned empty result | size=${outputImage.length}B | ${ctxInfo}`);
+    }
+  } catch (e) {
+    logger5.error(`[${scene}] image send failed | size=${outputImage.length}B | ${ctxInfo} | ${e}`);
+    try {
+      await session.send(fallbackText);
+    } catch (fallbackErr) {
+      logger5.error(`[${scene}] text fallback send failed after image send error | ${ctxInfo} | ${fallbackErr}`);
+    }
+  }
+}
+__name(sendImageWithFallback, "sendImageWithFallback");
+
+// src/commands/account.ts
+async function getPrimaryToken(deps, userId) {
+  const token = await getRoleToken(deps.ctx, userId);
+  return token?.fwt || "";
+}
+__name(getPrimaryToken, "getPrimaryToken");
+function notLoggedInHint() {
+  return "您尚未绑定洛克王国账号，请先使用“洛克.QQ登录”或“洛克.微信登录”进行绑定。";
+}
+__name(notLoggedInHint, "notLoggedInHint");
+function formatBindTime(bindTime) {
+  if (!bindTime || bindTime <= 0) return "未知";
+  const date = new Date(bindTime);
+  const pad = /* @__PURE__ */ __name((value) => String(value).padStart(2, "0"), "pad");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+__name(formatBindTime, "formatBindTime");
+function formatLoginType(loginType) {
+  const typeMap = {
+    qq: "QQ",
+    wechat: "微信",
+    manual: "手动导入"
+  };
+  return typeMap[loginType] || loginType || "未知";
+}
+__name(formatLoginType, "formatLoginType");
+async function saveBindingWithRoleInfo(deps, session, fwToken, loginType, userId) {
+  const { ctx, client, userMgr } = deps;
+  await session.send("登录成功，正在调用绑定接口...");
+  const bindRes = await client.createBinding(ctx, fwToken, userId);
+  const bindingId = String(bindRes?.binding?.id || fwToken || "").trim();
+  if (!bindRes?.binding || !bindingId) {
+    await session.send("绑定接口调用失败，请稍后重试。");
+    return;
+  }
+  await session.send("绑定成功，正在获取角色信息...");
+  const roleRes = await client.getRole(ctx, fwToken, void 0, userId);
+  if (!roleRes?.role) {
+    await session.send("绑定成功，但获取角色信息失败，请尝试重新登录。");
+    return;
+  }
+  const role = roleRes.role;
+  const binding = {
+    binding_id: bindingId,
+    login_type: loginType,
+    role_id: role.id || "unknown",
+    nickname: role.name || "洛克",
+    bind_time: Date.now(),
+    is_primary: true
+  };
+  userMgr.addBinding(userId, binding);
+  await upsertRoleToken(ctx, {
+    userId,
+    fwt: fwToken,
+    bindingId,
+    roleId: binding.role_id,
+    loginType
+  });
+  await session.send(`绑定成功！当前账号：${binding.nickname} (ID: ${binding.role_id})`);
+}
+__name(saveBindingWithRoleInfo, "saveBindingWithRoleInfo");
+function register(deps) {
+  const { ctx, client, userMgr } = deps;
+  ctx.command("洛克").subcommand(".QQ登录", "QQ 扫码登录").action(async ({ session }) => {
+    const userId = session.userId;
+    const qrData = await client.qqQrLogin(ctx, userId);
+    if (!qrData?.qr_image) return "获取 QQ 二维码失败。";
+    const fwToken = qrData.frameworkToken;
+    const qrB64 = qrData.qr_image;
+    const imgData = qrB64.includes(",") ? qrB64.split(",")[1] : qrB64;
+    await session.send((0, import_koishi6.h)(
+      "message",
+      {},
+      import_koishi6.h.at(userId),
+      import_koishi6.h.text("\n请使用 QQ 扫描二维码登录（有效时间 2 分钟）\n注意需要双设备扫码。\n"),
+      import_koishi6.h.image(`data:image/png;base64,${imgData}`)
+    ));
+    const startTime = Date.now();
+    while (Date.now() - startTime < 115e3) {
+      await new Promise((r) => setTimeout(r, 3e3));
+      const status = await client.qqQrStatus(ctx, fwToken, userId);
+      if (!status) continue;
+      if (status.status === "done") {
+        await saveBindingWithRoleInfo(deps, session, fwToken, "qq", userId);
+        return;
+      }
+      if (["expired", "failed", "canceled"].includes(status.status)) break;
+    }
+    return "登录超时或失败，请重试。";
+  });
+  ctx.command("洛克").subcommand(".微信登录", "微信扫码登录").action(async ({ session }) => {
+    const userId = session.userId;
+    const qrData = await client.wechatQrLogin(ctx, userId);
+    if (!qrData?.qr_image) return "获取微信登录链接失败。";
+    const fwToken = qrData.frameworkToken;
+    const qrUrl = qrData.qr_image;
+    await session.send(`请使用微信打开以下链接扫码登录（有效时间 2 分钟）
+注意需要双设备扫码。
+${qrUrl}`);
+    const startTime = Date.now();
+    while (Date.now() - startTime < 115e3) {
+      await new Promise((r) => setTimeout(r, 3e3));
+      const status = await client.wechatQrStatus(ctx, fwToken, userId);
+      if (!status) continue;
+      if (status.status === "done") {
+        await saveBindingWithRoleInfo(deps, session, fwToken, "wechat", userId);
+        return;
+      }
+      if (["expired", "failed"].includes(status.status)) break;
+    }
+    return "登录超时或失败，请重试。";
+  });
+  ctx.command("洛克").subcommand(".导入 <tgpId:string> <tgpTicket:string>", "导入 WeGame 凭证").action(async ({ session }, tgpId, tgpTicket) => {
+    if (!tgpId || !tgpTicket) return "用法：洛克.导入 <tgp_id> <tgp_ticket>";
+    const userId = session.userId;
+    const res = await client.importToken(ctx, tgpId, tgpTicket, userId);
+    if (!res?.frameworkToken) return "凭证导入失败。";
+    await saveBindingWithRoleInfo(deps, session, res.frameworkToken, "manual", userId);
+  });
+  ctx.command("洛克").subcommand(".绑定列表", "查看已绑定账号").action(async ({ session }) => {
+    const bindings = userMgr.getUserBindings(session.userId);
+    if (!bindings.length) return "暂无绑定账号。";
+    const bindItems = bindings.map((binding, index) => ({
+      index: index + 1,
+      nickname: binding.nickname || "未知",
+      isPrimary: Boolean(binding.is_primary),
+      role_id: binding.role_id || "未知",
+      type_label: formatLoginType(binding.login_type),
+      created_at: formatBindTime(binding.bind_time)
+    }));
+    const data = {
+      title: "绑定账号列表",
+      subtitle: `共找到 ${bindings.length} 个有效绑定账号`,
+      bindings: bindItems,
+      commandHint: "洛克.切换 <序号> 切换主账号 | 洛克.解绑 <序号> 移除绑定",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+    const fallbackLines = ["【绑定账号列表】"];
+    bindItems.forEach((binding) => {
+      const mark = binding.isPrimary ? "（主账号）" : "";
+      fallbackLines.push(`[${binding.index}] ${binding.nickname} (ID: ${binding.role_id}) ${binding.type_label}${mark} · ${binding.created_at}`);
+    });
+    const png = await deps.renderer.renderHtml(ctx, "bind-list", data);
+    await sendImageWithFallback(session, png, fallbackLines.join("\n"), "account:bind-list", deps.config);
+  });
+  ctx.command("洛克").subcommand(".切换 <index:number>", "切换主账号").action(async ({ session }, index) => {
+    if (!index) return "用法：洛克.切换 <序号>";
+    return userMgr.switchPrimary(session.userId, index) ? `成功切换到序号 ${index} 账号。` : "序号无效。";
+  });
+  ctx.command("洛克").subcommand(".解绑 <index:number>", "解绑账号").action(async ({ session }, index) => {
+    if (!index) return "用法：洛克.解绑 <序号>";
+    const removed = userMgr.deleteUserBinding(session.userId, index);
+    if (!removed) return "序号无效。";
+    if (removed.binding_id) {
+      try {
+        await client.deleteBinding(ctx, removed.binding_id, session.userId);
+      } catch {
+      }
+    }
+    if (userMgr.getUserBindings(session.userId).length === 0) {
+      await removeRoleToken(ctx, session.userId);
+    }
+    return `已解绑账号：${removed.nickname}`;
+  });
+  ctx.command("洛克").subcommand(".刷新", "刷新当前主账号凭证").action(async ({ session }) => {
+    const userId = session.userId;
+    const binding = userMgr.getPrimaryBinding(userId);
+    if (!binding) return notLoggedInHint();
+    if (!binding.binding_id) return "绑定 ID 无效，请重新绑定账号。";
+    await session.send("正在刷新凭证，服务端会自动处理，无需手动操作。");
+    const res = await client.refreshBinding(ctx, binding.binding_id, userId);
+    if (res?.framework_token) {
+      await upsertRoleToken(ctx, {
+        userId,
+        fwt: res.framework_token,
+        bindingId: binding.binding_id,
+        roleId: binding.role_id,
+        loginType: binding.login_type
+      });
+      return "当前账号凭证刷新成功。";
+    }
+    return "凭证刷新失败，可能已过期或不支持刷新（仅 QQ 扫码支持）。";
+  });
+}
+__name(register, "register");
+
+// src/commands/query.ts
+var import_koishi8 = require("koishi");
+
+// src/subscription-send.ts
+var import_koishi7 = require("koishi");
+var logger6 = new import_koishi7.Logger("rocom-subscription-send");
+function findBot(ctx, platform = "") {
+  if (!ctx.bots?.length) return null;
+  if (!platform) return ctx.bots[0];
+  return ctx.bots.find((bot) => bot.platform === platform) || ctx.bots[0];
+}
+__name(findBot, "findBot");
+async function sendScheduledMessage(ctx, target, message) {
+  const platform = target.platform || "";
+  const channelId = target.channelId || target.guildId || "";
+  const userId = target.userId || "";
+  const bot = findBot(ctx, platform);
+  if (!bot) {
+    logger6.warn("no available bot, skip scheduled push");
+    return false;
+  }
+  try {
+    if (userId && !target.guildId) {
+      if (typeof bot.sendPrivateMessage === "function") {
+        await bot.sendPrivateMessage(userId, message);
+        return true;
+      }
+      if (typeof bot.sendMessage === "function") {
+        await bot.sendMessage(userId, message);
+        return true;
+      }
+    }
+    if (platform && channelId) {
+      await ctx.broadcast([`${platform}:${channelId}`], message);
+      return true;
+    }
+    if (channelId && typeof bot.sendMessage === "function") {
+      await bot.sendMessage(channelId, message, target.guildId);
+      return true;
+    }
+  } catch (err) {
+    logger6.warn(`scheduled push failed: ${err}`);
+    return false;
+  }
+  logger6.warn(`scheduled push target is incomplete: ${JSON.stringify(target)}`);
+  return false;
+}
+__name(sendScheduledMessage, "sendScheduledMessage");
+
+// src/commands/query.ts
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_path4 = __toESM(require("node:path"));
+var logger7 = new import_koishi8.Logger("rocom-query");
+async function sendImage(deps, session, templateName, data, fallback) {
+  const png = await deps.renderer.renderHtml(deps.ctx, templateName, data);
+  await sendImageWithFallback(session, png, fallback, `query:${templateName}`, deps.config);
+}
+__name(sendImage, "sendImage");
+function cleanPlayerFieldValue(field, value) {
+  const text = String(value ?? "").trim().replace(/^'+|'+$/g, "");
+  if (!text || ["<0B>", "<0b>", "<0B >", "<0b >"].includes(text)) return "未设置";
+  if (["is_online", "online", "chat_top_unlock", "is_friend", "is_black", "is_black_role", "is_chat_node_unlock"].includes(field)) {
+    return ["1", "true", "True", "是"].includes(text) ? "是" : "否";
+  }
+  if (["sex", "gender"].includes(field)) {
+    return { "0": "未知", "1": "男", "2": "女" }[text] || text;
+  }
+  if (field === "friend_type") {
+    return { "0": "默认", "1": "特殊" }[text] || text;
+  }
+  if (field === "battle_state") {
+    return { "0": "空闲", "1": "对战中" }[text] || text;
+  }
+  return text;
+}
+__name(cleanPlayerFieldValue, "cleanPlayerFieldValue");
+function parseIngamePlayerPayload(payload, uid) {
+  const rows = payload?.rows || [];
+  const rowMap = {};
+  const labelMap = {};
+  for (const row of rows) {
+    const field = String(row.field || "");
+    if (!field) continue;
+    rowMap[field] = String(row.value ?? "");
+    labelMap[field] = String(row.label || field);
+  }
+  const playerUid = cleanPlayerFieldValue("uin", rowMap.uin || uid);
+  const signature = cleanPlayerFieldValue("signature", rowMap.signature || "");
+  return {
+    title: String(payload?.title || "玩家搜索"),
+    nickname: cleanPlayerFieldValue("name", rowMap.name || "-"),
+    uid: playerUid,
+    level: cleanPlayerFieldValue("level", rowMap.level || "-"),
+    signature: signature === "未设置" ? "" : signature,
+    rowMap,
+    labelMap
+  };
+}
+__name(parseIngamePlayerPayload, "parseIngamePlayerPayload");
+function playerField(parsed, field, defaultValue = "未设置") {
+  if (!parsed) return defaultValue;
+  const raw = parsed.rowMap[field];
+  if (raw == null || raw === "") return defaultValue;
+  const value = cleanPlayerFieldValue(field, raw);
+  return value && value !== "-" && value !== "未设置" ? value : defaultValue;
+}
+__name(playerField, "playerField");
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+__name(tryParseJson, "tryParseJson");
+function extractTopLevelJsonSegments(text) {
+  const segments = [];
+  let start = -1;
+  let depth = 0;
+  let quote = "";
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      if (depth === 0) start = i;
+      depth++;
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      if (depth <= 0) continue;
+      depth--;
+      if (depth === 0 && start >= 0) {
+        segments.push(text.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return segments;
+}
+__name(extractTopLevelJsonSegments, "extractTopLevelJsonSegments");
+function collectExchangeItemNames(input, output) {
+  if (input == null) return;
+  if (Array.isArray(input)) {
+    for (const item of input) collectExchangeItemNames(item, output);
+    return;
+  }
+  if (typeof input === "object") {
+    const record = input;
+    const preferredKeys = ["name", "item_name", "title", "label", "text", "value"];
+    let consumedPreferred = false;
+    for (const key of preferredKeys) {
+      if (record[key] == null) continue;
+      consumedPreferred = true;
+      collectExchangeItemNames(record[key], output);
+    }
+    if (!consumedPreferred) {
+      for (const value of Object.values(record)) collectExchangeItemNames(value, output);
+    }
+    return;
+  }
+  if (typeof input === "string") {
+    const text2 = input.trim();
+    if (!text2) return;
+    const direct = tryParseJson(text2);
+    if (direct != null) {
+      collectExchangeItemNames(direct, output);
+      return;
+    }
+    const unescaped = text2.replace(/\\"/g, '"');
+    if (unescaped !== text2) {
+      const escapedParsed = tryParseJson(unescaped);
+      if (escapedParsed != null) {
+        collectExchangeItemNames(escapedParsed, output);
+        return;
+      }
+    }
+    const chunks = extractTopLevelJsonSegments(text2);
+    let parsedFromChunks = false;
+    for (const chunk of chunks) {
+      const parsed = tryParseJson(chunk);
+      if (parsed == null) continue;
+      parsedFromChunks = true;
+      collectExchangeItemNames(parsed, output);
+    }
+    if (parsedFromChunks) return;
+    const nameRegex = /["']name["']\s*:\s*["']([^"']+)["']/g;
+    let matched = false;
+    for (let match = nameRegex.exec(text2); match; match = nameRegex.exec(text2)) {
+      const candidate = match[1]?.trim();
+      if (!candidate) continue;
+      output.add(candidate);
+      matched = true;
+    }
+    if (matched) return;
+    output.add(text2);
+    return;
+  }
+  const text = String(input).trim();
+  if (text) output.add(text);
+}
+__name(collectExchangeItemNames, "collectExchangeItemNames");
+function parseExchangeItems(raw) {
+  const names = /* @__PURE__ */ new Set();
+  collectExchangeItemNames(raw, names);
+  return [...names];
+}
+__name(parseExchangeItems, "parseExchangeItems");
+function parseExchangeWantText(raw) {
+  const names = parseExchangeItems(raw);
+  return names[0] || "交友";
+}
+__name(parseExchangeWantText, "parseExchangeWantText");
+function normalizeLineupLookupId(rawValue) {
+  const text = String(rawValue ?? "").trim();
+  if (!text) return "";
+  const match = text.match(/\d+/);
+  return match ? match[0] : text;
+}
+__name(normalizeLineupLookupId, "normalizeLineupLookupId");
+function isTargetLineup(lineup, lineupId) {
+  const target = normalizeLineupLookupId(lineupId);
+  if (!target) return false;
+  const candidates = /* @__PURE__ */ new Set([
+    normalizeLineupLookupId(lineup?.id),
+    normalizeLineupLookupId(lineup?.code),
+    normalizeLineupLookupId(lineup?.lineup_code)
+  ]);
+  candidates.delete("");
+  return candidates.has(target);
+}
+__name(isTargetLineup, "isTargetLineup");
+function stringifyInspectValue(value) {
+  if (value === null || value === void 0) return "-";
+  if (typeof value === "boolean") return value ? "是" : "否";
+  if (Array.isArray(value)) {
+    if (!value.length) return "-";
+    if (value.every((item) => item === null || typeof item !== "object")) return value.map(String).join("、");
+    return `共 ${value.length} 项`;
+  }
+  if (typeof value === "object") {
+    const pairs = Object.entries(value).slice(0, 4).map(([key, item]) => `${key}: ${stringifyInspectValue(item)}`);
+    return pairs.length ? `${pairs.join(" | ")}${Object.keys(value).length > 4 ? " | ..." : ""}` : "-";
+  }
+  return String(value);
+}
+__name(stringifyInspectValue, "stringifyInspectValue");
+function accountTypeText(accountType) {
+  return { 0: "自动", 1: "QQ", 2: "微信" }[accountType] || String(accountType);
+}
+__name(accountTypeText, "accountTypeText");
+function normalizeEpochSeconds(value) {
+  const ts = Number(value);
+  if (!Number.isFinite(ts)) return 0;
+  if (ts > 1e13) return Math.floor(ts / 1e6);
+  if (ts > 1e10) return Math.floor(ts / 1e3);
+  return Math.floor(ts);
+}
+__name(normalizeEpochSeconds, "normalizeEpochSeconds");
+function normalizeDurationSeconds(value) {
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds)) return 0;
+  if (seconds > 1e9) return Math.floor(seconds / 1e6);
+  if (seconds > 1e6) return Math.floor(seconds / 1e3);
+  return Math.floor(seconds);
+}
+__name(normalizeDurationSeconds, "normalizeDurationSeconds");
+function formatHomeRemaining(targetTs, nowTs = Math.floor(Date.now() / 1e3)) {
+  if (!targetTs) return "未开始";
+  const remain = Math.max(0, targetTs - nowTs);
+  if (remain <= 0) return "已完成";
+  const hours = Math.floor(remain / 3600);
+  const minutes = Math.floor(remain % 3600 / 60);
+  if (hours >= 24) return `${Math.floor(hours / 24)}天${hours % 24}小时`;
+  if (hours > 0) return `${hours}小时${minutes}分钟`;
+  return `${minutes}分钟`;
+}
+__name(formatHomeRemaining, "formatHomeRemaining");
+function homeInfoPayload(res) {
+  const payload = res || {};
+  if (payload.result?.home_info) return payload.result.home_info;
+  if (payload.home_info) return payload.home_info;
+  if (payload.data?.result?.home_info) return payload.data.result.home_info;
+  if (payload.data?.home_info) return payload.data.home_info;
+  return payload && typeof payload === "object" ? payload : {};
+}
+__name(homeInfoPayload, "homeInfoPayload");
+function homeBriefInfo(homeInfo) {
+  return homeInfo?.friend_home_brief_info || homeInfo?.home_brief_info || homeInfo || {};
+}
+__name(homeBriefInfo, "homeBriefInfo");
+function homeCellInfo(homeInfo) {
+  return homeInfo?.friend_cell_home_brief_info || homeInfo?.cell_home_brief_info || {};
+}
+__name(homeCellInfo, "homeCellInfo");
+function homePetIcon(petId, iconUrl = "") {
+  if (iconUrl) return iconUrl;
+  let assetId = Number(String(petId || "0"));
+  if (!Number.isFinite(assetId) || assetId <= 0) return "";
+  if (assetId < 3e3) assetId += 3e3;
+  return `https://game.gtimg.cn/images/rocom/rocodata/jingling/${assetId}/icon.png`;
+}
+__name(homePetIcon, "homePetIcon");
+function extractHomePet(raw, index, guard = false) {
+  if (!raw || typeof raw !== "object") return null;
+  const homePet = raw.home_pet_info && typeof raw.home_pet_info === "object" ? raw.home_pet_info : raw;
+  const display = raw.display_info && typeof raw.display_info === "object" ? raw.display_info : {};
+  const petId = homePet.pet_cfg_id || homePet.pet_id || homePet.pet_base_id || raw.pet_cfg_id || raw.pet_id || raw.id;
+  if (["", "0"].includes(String(petId || "0")) && !guard) return null;
+  const feedInfo = homePet.feed_info && typeof homePet.feed_info === "object" ? homePet.feed_info : {};
+  const beginTime = normalizeEpochSeconds(feedInfo.begin_time);
+  const timeCost = normalizeDurationSeconds(feedInfo.time_cost);
+  let readyAt = normalizeEpochSeconds(homePet.pet_rip_time || raw.pet_rip_time || raw.rip_time);
+  if (!readyAt && beginTime && timeCost) readyAt = beginTime + timeCost;
+  const nowTs = Math.floor(Date.now() / 1e3);
+  const hasInspiration = Boolean(readyAt);
+  const inspireReady = hasInspiration && nowTs >= readyAt;
+  const isGuard = guard || Boolean(raw.is_guard || raw.guard) || ["2", "guard", "守卫"].includes(String(raw.status).toLowerCase());
+  const statusText = isGuard && !hasInspiration ? "守卫中" : inspireReady ? "灵感已完成" : hasInspiration ? "灵感收集中" : "未喂食";
+  const statusClass = isGuard && !hasInspiration ? "guard" : inspireReady ? "ready" : hasInspiration ? "progress" : "idle";
+  return {
+    id: String(petId || ""),
+    pos: raw.pos || raw.position || index + 1,
+    name: String(homePet.name || homePet.pet_name || raw.name || raw.pet_name || `精灵 ${petId || ""}`),
+    level: display.level || raw.level || homePet.level || "--",
+    iconUrl: homePetIcon(petId, raw.icon_url || raw.pet_img_url || raw.petIcon || ""),
+    badge: isGuard ? "守" : "",
+    isGuard,
+    statusText,
+    statusClass,
+    note: hasInspiration ? formatHomeRemaining(readyAt, nowTs) : isGuard ? "家园守卫位" : "暂无灵感倒计时",
+    inspireReady,
+    readyAt
+  };
+}
+__name(extractHomePet, "extractHomePet");
+function homePetSources(homeInfo) {
+  const cell = homeCellInfo(homeInfo);
+  const indoorSources = [];
+  const guardSources = [];
+  if (Array.isArray(homeInfo?.home_pets)) indoorSources.push(...homeInfo.home_pets);
+  if (Array.isArray(cell?.home_pets)) {
+    for (const pet of cell.home_pets) {
+      const homePet = pet?.home_pet_info || {};
+      if (String(homePet.pet_cfg_id || "0") === "0" && (homePet.name || homePet.pet_name)) guardSources.push(pet);
+      else indoorSources.push(pet);
+    }
+  }
+  const petInfo = cell?.home_pet_info || {};
+  if (Array.isArray(petInfo.home_pet_list)) indoorSources.push(...petInfo.home_pet_list);
+  for (const key of ["guard_pets", "home_guard_pets", "guard_pet_list"]) {
+    if (Array.isArray(homeInfo?.[key])) guardSources.push(...homeInfo[key]);
+    if (Array.isArray(cell?.[key])) guardSources.push(...cell[key]);
+  }
+  for (const key of ["guard_pet", "home_guard_pet", "guard_pet_info", "home_guard_pet_info", "defend_pet", "defend_pet_info", "protect_pet", "protect_pet_info"]) {
+    if (homeInfo?.[key] && typeof homeInfo[key] === "object") guardSources.push(homeInfo[key]);
+    if (cell?.[key] && typeof cell[key] === "object") guardSources.push(cell[key]);
+  }
+  return { indoorSources, guardSources };
+}
+__name(homePetSources, "homePetSources");
+function homePlantIcon(deps, iconId) {
+  if (!iconId) return "";
+  const text = String(iconId);
+  if (/^(https?:|data:)/.test(text)) return text;
+  return deps.renderer.resourceUrl(`render-templates/home/img/home_icon/${text}_2.png`);
+}
+__name(homePlantIcon, "homePlantIcon");
+var homePlantMapCache = null;
+function loadHomePlantMap() {
+  if (homePlantMapCache) return homePlantMapCache;
+  const filePath = import_node_path4.default.resolve(__dirname, "..", "render-templates", "home", "data", "home_item_list.json");
+  try {
+    const data = JSON.parse(import_node_fs4.default.readFileSync(filePath, "utf-8"));
+    homePlantMapCache = data && typeof data === "object" ? data : {};
+  } catch (err) {
+    logger7.warn(`加载家园作物映射失败: ${err}`);
+    homePlantMapCache = {};
+  }
+  return homePlantMapCache;
+}
+__name(loadHomePlantMap, "loadHomePlantMap");
+function extractHomePlants(deps, homeInfo) {
+  const cell = homeCellInfo(homeInfo);
+  const plantSources = [];
+  const plantMap = loadHomePlantMap();
+  if (Array.isArray(homeInfo?.home_plants)) plantSources.push(...homeInfo.home_plants);
+  const plantInfo = cell?.home_plant_info || {};
+  for (const land of Array.isArray(plantInfo.home_plant_land_list) ? plantInfo.home_plant_land_list : []) {
+    for (const item of land.home_plant_list || []) plantSources.push({ ...item, land_index: land.land_index });
+  }
+  const nowTs = Math.floor(Date.now() / 1e3);
+  return plantSources.map((raw, index) => {
+    const plantData = raw.plant_info && typeof raw.plant_info === "object" ? raw.plant_info : raw;
+    const plantId = raw.plant_seed_id || raw.plant_cfg_id || raw.plant_id || plantData.id;
+    if (["", "0"].includes(String(plantId || "0"))) return null;
+    const mappedPlant = plantMap[String(plantId)] || {};
+    const iconId = plantData.icon_url || plantData.iconUrl || raw.icon_url || raw.iconUrl || plantData.iconid || raw.iconid || raw.icon_id || mappedPlant.iconid;
+    let readyAt = normalizeEpochSeconds(raw.plant_rip_time || raw.rip_time || raw.end_time);
+    const leftTime = Number(raw.left_time || 0);
+    if (!readyAt && leftTime > 0) readyAt = nowTs + leftTime;
+    const ready = Boolean(readyAt && nowTs >= readyAt) || ["2", "ready", "mature"].includes(String(raw.status));
+    const total = Number(raw.time_cost || raw.total_time || 0);
+    const progress = total && readyAt ? Math.max(0, Math.min(100, Math.floor((total - Math.max(0, readyAt - nowTs)) / total * 100))) : ready ? 100 : 35;
+    const harvestNum = raw.plant_harvest_num;
+    const stealAccount = raw.plant_steal_account;
+    const canStealAccount = raw.plant_can_steal_account;
+    return {
+      id: String(plantId),
+      landIndex: raw.slot_index || raw.land_index || index + 1,
+      plantName: plantData.name || raw.name || mappedPlant.name || `种子 ${plantId}`,
+      iconUrl: homePlantIcon(deps, iconId),
+      stateType: ready ? "ready" : "warning",
+      statusText: ready ? "已成熟" : "成长中",
+      leftTimeText: ready ? "可收获" : formatHomeRemaining(readyAt, nowTs),
+      progress,
+      ready,
+      readyAt,
+      harvestText: harvestNum !== void 0 && harvestNum !== "" ? `产量 ${harvestNum}` : "",
+      stealText: stealAccount !== void 0 && canStealAccount !== void 0 ? `可偷 ${stealAccount}/${canStealAccount}` : ""
+    };
+  }).filter(Boolean);
+}
+__name(extractHomePlants, "extractHomePlants");
+function buildHomeRenderData(deps, res, uid) {
+  const homeInfo = homeInfoPayload(res);
+  const brief = homeBriefInfo(homeInfo);
+  const { indoorSources, guardSources } = homePetSources(homeInfo);
+  const indoorPets = [];
+  const guardPets = [];
+  indoorSources.forEach((raw, index) => {
+    const item = extractHomePet(raw, index);
+    if (!item) return;
+    if (item.isGuard) guardPets.push(item);
+    else indoorPets.push(item);
+  });
+  guardSources.forEach((raw, index) => {
+    const item = extractHomePet(raw, index, true);
+    if (item) guardPets.push(item);
+  });
+  const gardenPlots = extractHomePlants(deps, homeInfo);
+  const createdAt = normalizeEpochSeconds(res?.meta?.created_at);
+  return {
+    title: "洛克家园",
+    subtitle: "Home Information",
+    homeName: brief.home_name || brief.name || `${uid} 的小屋`,
+    uid,
+    summaryCards: [
+      { label: "房间等级", value: brief.room_level || "--" },
+      { label: "家园等级", value: brief.home_level || "--" },
+      { label: "家园经验", value: brief.home_experience || "--" },
+      { label: "舒适度", value: brief.home_comfort_level || "--" }
+    ],
+    gardenPlots,
+    guardPets,
+    indoorPets,
+    gardenCount: gardenPlots.length,
+    guardCount: guardPets.length,
+    indoorCount: indoorPets.length,
+    guardEmptyText: "后端当前返回中没有守卫精灵字段",
+    updatedAt: new Date(createdAt ? createdAt * 1e3 : Date.now()).toLocaleString("zh-CN")
+  };
+}
+__name(buildHomeRenderData, "buildHomeRenderData");
+function buildPlayerSearchRenderData(payload, uid) {
+  const parsed = parseIngamePlayerPayload(payload, uid);
+  const pack = /* @__PURE__ */ __name((title, pairs) => {
+    const items = pairs.filter(([, value]) => value && value !== "-" && value !== "未设置").map(([label, value]) => ({ label, value }));
+    return items.length ? { title, items } : null;
+  }, "pack");
+  const sections = [
+    pack("核心档案", [
+      ["等级", parsed.level],
+      ["在线状态", playerField(parsed, "online", playerField(parsed, "is_online"))],
+      ["性别", playerField(parsed, "gender", playerField(parsed, "sex"))],
+      ["世界等级", playerField(parsed, "world_level")],
+      ["图鉴收集", playerField(parsed, "card_handbook_collect_num")],
+      ["最后离线", playerField(parsed, "last_logout_time")]
+    ]),
+    pack("家园信息", [
+      ["家园名称", playerField(parsed, "home_name")],
+      ["家园等级", playerField(parsed, "home_level")],
+      ["家园经验", playerField(parsed, "home_experience")],
+      ["舒适度", playerField(parsed, "home_comfort_level")],
+      ["访客数量", playerField(parsed, "visitor_num")]
+    ]),
+    pack("名片信息", [
+      ["名片皮肤", playerField(parsed, "card_skin_selected")],
+      ["名片头像", playerField(parsed, "card_icon_selected")],
+      ["首标签", playerField(parsed, "card_label_first_selected")],
+      ["尾标签", playerField(parsed, "card_label_last_selected")]
+    ])
+  ].filter(Boolean);
+  const summaryCards = [
+    { label: "等级", value: parsed.level },
+    { label: "在线状态", value: playerField(parsed, "online", playerField(parsed, "is_online")) },
+    { label: "世界等级", value: playerField(parsed, "world_level") },
+    { label: "图鉴收集", value: playerField(parsed, "card_handbook_collect_num") },
+    { label: "家园等级", value: playerField(parsed, "home_level") },
+    { label: "舒适度", value: playerField(parsed, "home_comfort_level") }
+  ].filter((item) => item.value && item.value !== "-");
+  const signature = parsed.signature && parsed.signature !== "未设置" ? parsed.signature : "";
+  return {
+    title: "洛克玩家",
+    subtitle: parsed.title,
+    heroTitle: "玩家信息",
+    heroValue: parsed.nickname,
+    heroSubvalue: `UID ${parsed.uid}`,
+    summaryCards,
+    signature,
+    showSignature: Boolean(signature),
+    sections,
+    commandHint: "洛克.玩家 <UID>",
+    copyright: "Koishi & WeGame Locke Kingdom Plugin"
+  };
+}
+__name(buildPlayerSearchRenderData, "buildPlayerSearchRenderData");
+function buildShopRenderData(payload, shopId) {
+  const sections = [];
+  const detailItems = [];
+  const summaryCards = [{ label: "商店 ID", value: shopId }];
+  if (Array.isArray(payload?.rows)) {
+    detailItems.push(...payload.rows.filter((row) => Number(row.level || 0) === 0).map((row) => ({
+      label: row.label || row.field || "-",
+      value: stringifyInspectValue(row.value)
+    })));
+  } else {
+    for (const [key, value] of Object.entries(payload || {})) {
+      if (Array.isArray(value)) {
+        summaryCards.push({ label: key, value: String(value.length) });
+        sections.push({
+          title: key.replace(/_/g, " "),
+          cards: value.slice(0, 24).map((item, index) => ({
+            title: item?.name || item?.title || item?.item_name || `${key} #${index + 1}`,
+            image: item?.icon || item?.icon_url || item?.image || item?.image_url || "",
+            meta: Object.entries(item || {}).filter(([metaKey, metaValue]) => !["name", "title", "item_name", "icon", "icon_url", "image", "image_url"].includes(metaKey) && (metaValue === null || typeof metaValue !== "object")).slice(0, 6).map(([metaKey, metaValue]) => ({ label: metaKey.replace(/_/g, " "), value: stringifyInspectValue(metaValue) }))
+          }))
+        });
+      } else if (value === null || typeof value !== "object") {
+        detailItems.push({ label: key.replace(/_/g, " "), value: stringifyInspectValue(value) });
+      }
+    }
+  }
+  return {
+    title: "洛克商店",
+    subtitle: `shop_id = ${shopId}`,
+    heroTitle: "商店查询",
+    heroValue: detailItems.find((item) => ["name", "title", "名称", "标题"].includes(item.label))?.value || shopId,
+    heroSubvalue: `shop_id = ${shopId}`,
+    summaryCards: summaryCards.slice(0, 3),
+    sections,
+    detailItems: detailItems.slice(0, 18),
+    commandHint: "洛克.商店 <shop_id>",
+    copyright: "Koishi & WeGame Locke Kingdom Plugin"
+  };
+}
+__name(buildShopRenderData, "buildShopRenderData");
+function buildFriendshipRenderData(payload, userIds) {
+  const result = payload?.result || {};
+  const users = payload?.user_list || payload?.userList || [];
+  const userCards = users.map((user, index) => {
+    const statusCode = user.status;
+    return {
+      title: `用户 ${index + 1}`,
+      userId: String(user.user_id || user.userId || "-"),
+      statusCode: stringifyInspectValue(statusCode),
+      statusText: String(statusCode) === "0" ? "状态正常" : `状态码 ${statusCode}`,
+      statusDesc: "接口已返回该用户状态，但后端当前没有提供更具体的关系类型说明。"
+    };
+  });
+  return {
+    title: "好友关系",
+    subtitle: `查询 ID：${userIds}`,
+    summaryCards: [
+      { label: "查询对象", value: String(userCards.length || userIds.split(",").length) },
+      { label: "接口状态", value: Number(result.error_code || 0) === 0 ? "成功" : "异常" },
+      { label: "上游返回", value: result.error_message || "OK" }
+    ],
+    userCards,
+    resultCode: stringifyInspectValue(result.error_code || 0),
+    resultDesc: "当前接口只返回 status 字段，尚未提供“好友/非好友/黑名单”等可读关系类型。",
+    commandHint: "洛克.好友关系 <id1,id2>",
+    copyright: "Koishi & WeGame Locke Kingdom Plugin"
+  };
+}
+__name(buildFriendshipRenderData, "buildFriendshipRenderData");
+function buildStudentRenderData(statePayload, perksPayload, area, accountType) {
+  const school = statePayload?.school || statePayload?.school_name || "未返回";
+  const certified = String(statePayload?.certified) === "1";
+  const cards = perksPayload?.cards || [];
+  return {
+    title: "洛克学生",
+    subtitle: `大区：${area}  账号类型：${accountTypeText(accountType)}`,
+    heroTitle: "学生信息总览",
+    heroValue: certified ? "已通过" : "未认证",
+    heroSubvalue: school,
+    summaryCards: [
+      { label: "认证状态", value: certified ? "已认证" : "未认证" },
+      { label: "学校", value: school },
+      { label: "奖励数量", value: String(cards.length) }
+    ],
+    stateItems: [
+      { label: "学生认证", value: certified ? "是" : "否" },
+      { label: "游戏内认证", value: String(statePayload?.game_certified) === "1" ? "是" : "否" },
+      { label: "学校", value: school },
+      { label: "上游状态", value: statePayload?.result?.error_message || "WG_COMM_SUCC" },
+      { label: "上游错误码", value: stringifyInspectValue(statePayload?.result?.error_code || 0) }
+    ],
+    perkCards: cards.map((card) => ({
+      name: card.name || `奖励 #${card.id || "-"}`,
+      count: card.count || 0,
+      desc: card.desc || "暂无说明",
+      icon: card.icon || "",
+      id: stringifyInspectValue(card.id),
+      stateText: `状态码 ${stringifyInspectValue(card.state)}`
+    })),
+    detailItems: Object.entries(perksPayload || {}).filter(([key, value]) => !["cards", "result"].includes(key) && (value === null || typeof value !== "object")).map(([key, value]) => ({ label: key.replace(/_/g, " "), value: stringifyInspectValue(value) })),
+    stateResult: statePayload?.result?.error_message || "WG_COMM_SUCC",
+    perksResult: perksPayload?.result?.error_message || "WG_COMM_SUCC",
+    commandHint: "洛克.学生 [area] [account_type]",
+    copyright: "Koishi & WeGame Locke Kingdom Plugin"
+  };
+}
+__name(buildStudentRenderData, "buildStudentRenderData");
+function sessionTarget(session) {
+  return {
+    platform: session?.platform || session?.bot?.platform || "",
+    channelId: session?.channelId || session?.guildId || "",
+    userId: session?.guildId ? "" : session?.userId || ""
+  };
+}
+__name(sessionTarget, "sessionTarget");
+function homeSubscriptionKey(session, uid, kind) {
+  const target = sessionTarget(session);
+  return [target.platform, target.channelId || "private", target.userId || session?.guildId || "", uid, kind].join(":");
+}
+__name(homeSubscriptionKey, "homeSubscriptionKey");
+function isBotAdmin(session, adminUserIds) {
+  return adminUserIds.includes(session?.userId || "");
+}
+__name(isBotAdmin, "isBotAdmin");
+async function resolveHomeUid(deps, session, uid = "") {
+  const targetUid = String(uid || "").trim();
+  if (targetUid) return targetUid;
+  return String(deps.userMgr.getPrimaryBinding(session?.userId || "")?.role_id || "");
+}
+__name(resolveHomeUid, "resolveHomeUid");
+async function subscribeHome(deps, session, uid, kind) {
+  const target = sessionTarget(session);
+  if (!target.userId && !isBotAdmin(session, deps.config.adminUserIds)) return "此指令仅限管理员使用。";
+  const targetUid = await resolveHomeUid(deps, session, uid);
+  if (!targetUid) return kind === "garden" ? "请提供玩家 UID，或先完成绑定后再订阅家园菜园。" : "请提供玩家 UID，或先完成绑定后再订阅家园灵感。";
+  const key = homeSubscriptionKey(session, targetUid, kind);
+  deps.homeSubMgr.upsert(key, {
+    key,
+    kind,
+    uid: targetUid,
+    platform: target.platform,
+    channel_id: target.channelId,
+    guild_id: session?.guildId || "",
+    user_id: target.userId,
+    updated_by: session?.userId || "",
+    notify_state: {},
+    updated_at: Math.floor(Date.now() / 1e3)
+  });
+  return kind === "garden" ? `已订阅 UID ${targetUid} 的家园菜园提醒：首个成熟和全部成熟时各推送一次。` : `已订阅 UID ${targetUid} 的家园精灵灵感提醒：首个完成和全部完成时各推送一次。`;
+}
+__name(subscribeHome, "subscribeHome");
+function homeSubscriptionState(data, kind) {
+  if (kind === "garden") {
+    const items2 = data.gardenPlots || [];
+    const readyItems2 = items2.filter((item) => item.ready);
+    const names2 = readyItems2.map((item) => `田地${item.landIndex} ${item.plantName}`);
+    return { items: items2, readyItems: readyItems2, names: names2 };
+  }
+  const items = [...data.indoorPets || [], ...data.guardPets || []].filter((item) => item.readyAt);
+  const readyItems = items.filter((item) => item.inspireReady);
+  const names = readyItems.map((item) => item.name || "未知精灵");
+  return { items, readyItems, names };
+}
+__name(homeSubscriptionState, "homeSubscriptionState");
+function homeSubscriptionMessage(uid, kind, level, totalCount, readyItems, names) {
+  const kindText = kind === "garden" ? "菜园作物" : "精灵灵感";
+  const actionText = kind === "garden" ? "成熟" : "完成";
+  const levelText = level === "first" ? "首个" : "全部";
+  return [
+    `家园${kindText}${levelText}${actionText}提醒：${uid}`,
+    `进度：${readyItems.length}/${totalCount}`,
+    names.length ? `已完成：${names.slice(0, 8).join("、")}` : ""
+  ].filter(Boolean).join("\n");
+}
+__name(homeSubscriptionMessage, "homeSubscriptionMessage");
+async function checkHomeSubscriptions(deps) {
+  const subs = deps.homeSubMgr.getAll();
+  const cache = /* @__PURE__ */ new Map();
+  let checkedCount = 0;
+  let pushedCount = 0;
+  for (const [key, sub] of Object.entries(subs)) {
+    if (!sub.uid || !["garden", "inspiration"].includes(sub.kind)) continue;
+    checkedCount++;
+    if (!cache.has(sub.uid)) {
+      cache.set(sub.uid, await deps.client.ingameHomeInfo(deps.ctx, sub.uid));
+    }
+    const res = cache.get(sub.uid);
+    if (!res) continue;
+    const data = buildHomeRenderData(deps, res, sub.uid);
+    const { items, readyItems, names } = homeSubscriptionState(data, sub.kind);
+    const totalCount = items.length;
+    if (totalCount <= 0) continue;
+    const notifyState = sub.notify_state || {};
+    const pushLevels = [];
+    if (!readyItems.length) {
+      notifyState.first = false;
+      notifyState.all = false;
+    } else {
+      if (!notifyState.first) pushLevels.push("first");
+      if (readyItems.length >= totalCount && !notifyState.all) pushLevels.push("all");
+      if (readyItems.length < totalCount) notifyState.all = false;
+    }
+    if (!pushLevels.length) {
+      deps.homeSubMgr.upsert(key, { ...sub, notify_state: notifyState });
+      continue;
+    }
+    const messages = pushLevels.map((level) => homeSubscriptionMessage(sub.uid, sub.kind, level, totalCount, readyItems, names));
+    try {
+      const sent = await sendScheduledMessage(deps.ctx, {
+        platform: sub.platform,
+        channelId: sub.channel_id || sub.guild_id || sub.user_id || "",
+        guildId: sub.guild_id || "",
+        userId: sub.user_id || ""
+      }, messages.join("\n\n"));
+      if (!sent) continue;
+    } catch (e) {
+      logger7.warn(`家园订阅推送失败: ${e}`);
+      continue;
+    }
+    for (const level of pushLevels) notifyState[level] = true;
+    pushedCount += pushLevels.length;
+    deps.homeSubMgr.upsert(key, { ...sub, notify_state: notifyState, last_push_time: Math.floor(Date.now() / 1e3) });
+  }
+  return { subscriptions: Object.keys(subs).length, checked: checkedCount, pushed: pushedCount };
+}
+__name(checkHomeSubscriptions, "checkHomeSubscriptions");
+function register2(deps) {
+  const { ctx, client } = deps;
+  ctx.command("洛克").subcommand(".档案", "查看个人档案").action(async ({ session }) => {
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const userIdentifier = session.userId;
+    await session.send("正在获取洛克王国数据...");
+    const [roleRes, evalRes, sumRes, collRes, boRes, blRes] = await Promise.all([
+      client.getRole(ctx, fwToken, void 0, userIdentifier),
+      client.getEvaluation(ctx, fwToken, userIdentifier),
+      client.getPetSummary(ctx, fwToken, userIdentifier),
+      client.getCollection(ctx, fwToken, userIdentifier),
+      client.getBattleOverview(ctx, fwToken, userIdentifier),
+      client.getBattleList(ctx, fwToken, 1, "", userIdentifier)
+    ]);
+    if (!roleRes?.role) return "获取角色档案失败，凭据可能已过期，请重新登录。";
+    const role = roleRes.role;
+    const ev = evalRes || {};
+    const sm = sumRes || {};
+    const cl = collRes || {};
+    const bo = boRes || {};
+    const recentBattle = blRes?.battles?.[0];
+    const playerSearchRes = role?.id ? await client.ingamePlayerSearch(ctx, String(role.id)) : null;
+    const playerSearchData = parseIngamePlayerPayload(playerSearchRes, String(role.id || ""));
+    const profileSignature = playerSearchData?.signature || "";
+    const profileHeadTags = playerSearchData ? [
+      { label: "在线", value: playerField(playerSearchData, "online", "未知") },
+      { label: "性别", value: playerField(playerSearchData, "gender", playerField(playerSearchData, "sex", "未知")) },
+      { label: "世界等级", value: playerField(playerSearchData, "world_level") },
+      { label: "家园等级", value: playerField(playerSearchData, "home_level") }
+    ].filter((item) => item.value && item.value !== "-" && item.value !== "未设置").slice(0, 4) : [];
+    const profileHomeItems = playerSearchData ? [
+      { label: "家园名称", value: playerField(playerSearchData, "home_name") },
+      { label: "家园等级", value: playerField(playerSearchData, "home_level") },
+      { label: "家园经验", value: playerField(playerSearchData, "home_experience") },
+      { label: "舒适度", value: playerField(playerSearchData, "home_comfort_level") },
+      { label: "访客数量", value: playerField(playerSearchData, "visitor_num") }
+    ].filter((item) => item.value && item.value !== "-" && item.value !== "未设置") : [];
+    const profileCardItems = playerSearchData ? [
+      { label: "名片皮肤", value: playerField(playerSearchData, "card_skin_selected") },
+      { label: "名片头像", value: playerField(playerSearchData, "card_icon_selected") }
+    ].filter((item) => item.value && item.value !== "-" && item.value !== "未设置") : [];
+    const profileCardImage = playerSearchData ? playerField(playerSearchData, "card_bussiness_card_url", "") : "";
+    const profileStatusText = playerSearchData ? playerField(playerSearchData, "online", "未知") : "未知";
+    const hasExtraProfileData = Boolean(profileSignature || profileHomeItems.length || profileCardItems.length || profileCardImage);
+    let degraded = false;
+    if (!sm) {
+      logger7.warn("[Rocom] 洛克.档案：pet-summary 接口不可用，已降级为基础档案渲染");
+      degraded = true;
+    }
+    if (!ev) {
+      logger7.warn("[Rocom] 洛克.档案：evaluation 接口不可用，已降级为基础档案渲染");
+      degraded = true;
+    }
+    if (!cl) {
+      logger7.warn("[Rocom] 洛克.档案：collection 接口不可用，已降级为基础档案渲染");
+      degraded = true;
+    }
+    if (!bo) {
+      logger7.warn("[Rocom] 洛克.档案：battle-overview 接口不可用，已降级为基础档案渲染");
+      degraded = true;
+    }
+    if (degraded) {
+      try {
+        await session.send("AI评分接口暂不可用，已降级为基础档案渲染。");
+      } catch {
+      }
+    }
+    const radarData = {
+      strength: ev.strength || 0,
+      collection: ev.collection || 0,
+      capture: ev.capture || 0,
+      progression: ev.progression || 0
+    };
+    const cx = 130;
+    const cy = 130;
+    const r = 90;
+    const dims = [
+      { label: "战力", value: radarData.strength, angle: -90 },
+      { label: "收藏", value: radarData.collection, angle: 0 },
+      { label: "捕捉", value: radarData.capture, angle: 90 },
+      { label: "推进", value: radarData.progression, angle: 180 }
+    ];
+    const toXY = /* @__PURE__ */ __name((angle, radius) => {
+      const rad = angle * Math.PI / 180;
+      return { x: Math.round(cx + radius * Math.cos(rad)), y: Math.round(cy + radius * Math.sin(rad)) };
+    }, "toXY");
+    const radarPolygons = [1, 0.66, 0.33].map((scale) => {
+      const pts = dims.map((dim) => toXY(dim.angle, r * scale));
+      return pts.map((point) => `${point.x},${point.y}`).join(" ");
+    });
+    const radarAxes = dims.map((dim) => toXY(dim.angle, r));
+    const radarAreaPoints = dims.map((dim) => toXY(dim.angle, r * Math.min(dim.value, 100) / 100)).map((point) => `${point.x},${point.y}`).join(" ");
+    const radarAxisLabels = dims.map((dim) => {
+      const point = toXY(dim.angle, r + 28);
+      return { x: point.x, y: point.y, name: dim.label, anchor: "middle" };
+    });
+    const radarValueBadges = dims.map((dim) => {
+      const point = toXY(dim.angle, r + 14);
+      return { x: point.x - 20, y: point.y + 8, width: 40, value: dim.value };
+    });
+    const radarDots = dims.map((dim) => toXY(dim.angle, r * Math.min(dim.value, 100) / 100));
+    const data = {
+      userName: role.name || "洛克",
+      userLevel: role.level || 1,
+      userUid: role.id || "",
+      userAvatarDisplay: role.avatar_url || "",
+      enrollDays: role.enroll_days || 0,
+      starName: role.star_name || "魔法学徒",
+      backgroundUrl: role.background_url || "",
+      hasAiProfileData: !!sm.best_pet_name,
+      bestPetName: sm.best_pet_name || "",
+      summaryTitleParts: String(sm.summary_title || "未 知").split(" "),
+      bestPetImageDisplay: sm.best_pet_img_url || "",
+      fallbackPetImage: "{{_res_path}}img/roco_icon.png",
+      scoreText: ev.score || "0.0",
+      aiCommentText: sm.summary_content || "暂无点评",
+      centerX: cx,
+      centerY: cy,
+      radarPolygons,
+      radarAxes,
+      radarAreaPoints,
+      radarAxisLabels,
+      radarValueBadges,
+      radarDots,
+      currentCollectionCount: cl.current_collection_count || 0,
+      totalCollectionCount: cl.total_collection_count || 0,
+      amazingSpriteCount: cl.amazing_sprite_count || 0,
+      shinySpriteCount: cl.shiny_sprite_count || 0,
+      colorfulSpriteCount: cl.colorful_sprite_count || 0,
+      fashionCollectionCount: cl.fashion_collection_count || 0,
+      itemCount: cl.item_count || 0,
+      collectionHint: "查看收藏详情",
+      hasBattleData: bo.total_match > 0,
+      tierBadgeUrl: bo.tier_icon_url || "",
+      winRate: `${bo.win_rate || 0}%`,
+      totalMatch: bo.total_match || 0,
+      matchResult: "",
+      leftTeamPets: [],
+      rightTeamPets: [],
+      opponentName: "",
+      opponentAvatarDisplay: "",
+      hasExtraProfileData,
+      profileSignature,
+      showProfileSignature: Boolean(profileSignature),
+      profileHeadTags,
+      profileHomeItems,
+      profileCardItems,
+      profileCardImage,
+      profileStatusText,
+      profileStatusClass: profileStatusText === "是" ? "online" : "offline",
+      commandHint: "洛克.背包 <筛选> <页码> | 洛克.战绩 <页码> | 洛克 查看菜单",
+      copyright: "AstrBot & WeGame Locke Kingdom Plugin"
+    };
+    if (recentBattle) {
+      data.hasBattleData = true;
+      data.matchResult = recentBattle.result === 1 ? "fail" : "win";
+      data.opponentName = recentBattle.enemy_nickname || "";
+      data.opponentAvatarDisplay = recentBattle.enemy_avatar_url || "";
+      data.leftTeamPets = (recentBattle.pet_base_info || []).map((pet) => ({
+        icon: pet.pet_img_url?.replace("/image.png", "/icon.png") || ""
+      }));
+      data.rightTeamPets = (recentBattle.enemy_pet_base_info || []).map((pet) => ({
+        icon: pet.pet_img_url?.replace("/image.png", "/icon.png") || ""
+      }));
+    }
+    const fallback = `【${role.name}的档案】Lv.${role.level} UID:${role.id}
+评分:${ev.score || "0"} 收藏:${cl.current_collection_count || 0}/${cl.total_collection_count || 0}`;
+    await sendImage(deps, session, "personal-card", data, fallback);
+  });
+  ctx.command("洛克").subcommand(".战绩 [page:number]", "查看对战战绩").action(async ({ session }, _page = 1) => {
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const userIdentifier = session.userId;
+    const [roleRes, boRes, blRes] = await Promise.all([
+      client.getRole(ctx, fwToken, void 0, userIdentifier),
+      client.getBattleOverview(ctx, fwToken, userIdentifier),
+      client.getBattleList(ctx, fwToken, 4, "", userIdentifier)
+    ]);
+    if (!roleRes?.role) return "获取战绩数据失败。";
+    const role = roleRes.role;
+    const bo = boRes || {};
+    const battles = (blRes?.battles || []).map((battle) => {
+      const result = battle.result === 1 ? "fail" : "win";
+      const battleTime = battle.battle_time ? new Date(battle.battle_time) : null;
+      return {
+        time: battleTime ? battleTime.toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" }) : "?",
+        date: battleTime ? battleTime.toLocaleDateString("zh-CN") : "?",
+        result,
+        leftName: battle.nickname || "",
+        leftAvatar: battle.avatar_url || "",
+        leftPets: (battle.pet_base_info || []).map((pet) => ({
+          icon: pet.pet_img_url?.replace("/image.png", "/icon.png") || ""
+        })),
+        rightName: battle.enemy_nickname || "",
+        rightAvatar: battle.enemy_avatar_url || "",
+        rightPets: (battle.enemy_pet_base_info || []).map((pet) => ({
+          icon: pet.pet_img_url?.replace("/image.png", "/icon.png") || ""
+        }))
+      };
+    });
+    const data = {
+      userAvatarDisplay: role.avatar_url || "",
+      userName: role.name,
+      userLevel: role.level || 1,
+      userUid: role.id || "",
+      winRate: `${bo.win_rate || 0}%`,
+      totalMatch: bo.total_match || 0,
+      battles,
+      commandHint: "洛克.战绩 <页码>",
+      copyright: "Koishi & WeGame 洛克王国插件"
+    };
+    await sendImage(deps, session, "record", data, `【${role.name}的战绩】胜率:${bo.win_rate || 0}% 场次:${bo.total_match || 0}`);
+  });
+  ctx.command("洛克").subcommand(".背包 [arg1:string] [arg2:string]", "查看精灵背包").action(async ({ session }, arg1, arg2) => {
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const catMap = { "全部": 0, "了不起": 1, "异色": 2, "炫彩": 3 };
+    let category = "全部";
+    let pageNo = 1;
+    for (const arg of [arg1, arg2]) {
+      if (!arg) continue;
+      if (/^\d+$/.test(arg)) pageNo = parseInt(arg);
+      else if (arg in catMap) category = arg;
+      else if (arg.replace("精灵", "") in catMap) category = arg.replace("精灵", "");
+    }
+    const userIdentifier = session.userId;
+    const petSubset = catMap[category] ?? 0;
+    const [roleRes, petRes] = await Promise.all([
+      client.getRole(ctx, fwToken, void 0, userIdentifier),
+      client.getPets(ctx, fwToken, petSubset, pageNo, 10, userIdentifier)
+    ]);
+    if (!roleRes?.role || !petRes?.pets) return "获取背包数据失败。";
+    const role = roleRes.role;
+    const data = {
+      userName: role.name || "洛克",
+      userLevel: role.level || 1,
+      userUid: role.id || "",
+      userAvatar: role.avatar_url || "",
+      pageTitle: `背包 - ${category}精灵`,
+      tabs: [
+        { text: "全部精灵", active: category === "全部" },
+        { text: "了不起精灵", active: category === "了不起" },
+        { text: "异色精灵", active: category === "异色" },
+        { text: "炫彩精灵", active: category === "炫彩" }
+      ],
+      currentTab: `${category}精灵`,
+      totalCount: petRes.total || 0,
+      accountLabel: role.name || "",
+      pets: (petRes.pets || []).map((pet) => ({
+        name: pet.pet_name?.split("&")[0] || "?",
+        custom_name: pet.pet_name?.includes("&") ? pet.pet_name.split("&")[1] : void 0,
+        level: pet.pet_level || 1,
+        pet_img_url: pet.pet_img_url || "",
+        elementIcons: (pet.pet_types_info || []).map((petType2) => ({ src: petType2.icon || "", name: petType2.name || "" })),
+        badgeImage: ""
+      })),
+      emptySlots: [],
+      currentPage: pageNo,
+      totalPages: Math.max(1, Math.ceil((petRes.total || 0) / 10)),
+      pageSize: 10,
+      commandHint: "洛克.背包 <全部/异色/了不起/炫彩> <页码>",
+      fallbackPetImage: ""
+    };
+    await sendImage(deps, session, "package", data, `【背包 - ${category}精灵】共${petRes.total || 0}只`);
+  });
+  ctx.command("洛克").subcommand(".阵容 [arg1:string] [arg2:string]", "查看阵容推荐").action(async ({ session }, arg1, arg2) => {
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const userIdentifier = session.userId;
+    let category = "";
+    let pageNo = 1;
+    for (const arg of [arg1, arg2]) {
+      if (!arg) continue;
+      if (/^\d+$/.test(arg)) pageNo = parseInt(arg);
+      else category = arg;
+    }
+    const res = await client.getLineupList(ctx, fwToken, pageNo, category, userIdentifier);
+    if (!res?.lineups) return "获取阵容数据失败。";
+    const data = {
+      category: category || "热门推荐",
+      lineups: (res.lineups || []).map((lineup) => ({
+        name: lineup.name || "",
+        tags: lineup.tags || [],
+        likes: lineup.likes || 0,
+        author_name: lineup.author_name || "?",
+        lineup_code: String(lineup.id || ""),
+        pets: (lineup.lineup?.pets || []).map((pet) => ({
+          pet_name: pet.pet_name || "",
+          pet_img_url: pet.pet_img_url || "",
+          skills_info: (pet.skills_info || []).map((skill) => ({ skill_img_url: skill.skill_img_url || "" }))
+        }))
+      })),
+      page_no: res.page_no || pageNo,
+      total_pages: res.total_pages || 1,
+      fallbackPetImage: "",
+      commandHint: "洛克.阵容 <分类> <页码>"
+    };
+    await sendImage(deps, session, "lineup", data, `【阵容推荐】${category || "热门"} 第${pageNo}页`);
+  });
+  ctx.command("查看阵容 <lineupId:string>", "查看阵容详情").action(async ({ session }, lineupId) => {
+    const normalizedLineupId = normalizeLineupLookupId(lineupId);
+    if (!normalizedLineupId) return "请提供有效的阵容码。用法：查看阵容 <阵容码>";
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const userIdentifier = session.userId;
+    const firstPageRes = await client.getLineupList(ctx, fwToken, 1, "", userIdentifier);
+    if (!firstPageRes?.lineups) return "获取阵容数据失败。";
+    let targetLineup = (firstPageRes.lineups || []).find((lineup) => isTargetLineup(lineup, normalizedLineupId));
+    if (!targetLineup) {
+      const totalPages = Math.max(1, Number(firstPageRes.total_pages) || 1);
+      const maxSearchPage = Math.min(totalPages, 10);
+      for (let page = 2; page <= maxSearchPage; page++) {
+        const pageRes = await client.getLineupList(ctx, fwToken, page, "", userIdentifier);
+        const lineups = pageRes?.lineups || [];
+        targetLineup = lineups.find((lineup) => isTargetLineup(lineup, normalizedLineupId));
+        if (targetLineup) break;
+      }
+    }
+    if (!targetLineup) return `未找到阵容码为 ${normalizedLineupId} 的阵容。`;
+    const lineupData = targetLineup.lineup || {};
+    const processedPets = (lineupData.pets || []).map((pet) => ({
+      pet_name: pet.pet_name || "",
+      pet_img_url: pet.pet_img_url || "",
+      skills: (pet.skills_info || []).map((skill) => skill.skill_img_url || "").filter(Boolean),
+      bloodline: Boolean(pet.bloodline_info),
+      bloodline_icon: pet.bloodline_info?.icon || ""
+    }));
+    const data = {
+      lineup: {
+        name: targetLineup.name || "",
+        tags: targetLineup.tags || [],
+        pets: processedPets,
+        author_name: targetLineup.author_name || "",
+        author_avatar: targetLineup.author_avatar || "",
+        likes: targetLineup.likes || 0,
+        lineup_code: normalizedLineupId
+      },
+      fallbackPetImage: "{{_res_path}}img/roco_icon.png"
+    };
+    const fallback = `【阵容详情】${targetLineup.name || "未知阵容"} | 阵容码: ${normalizedLineupId}`;
+    await sendImage(deps, session, "lineup-detail", data, fallback);
+  });
+  ctx.command("洛克").subcommand(".交换大厅 [page:number]", "查看交换大厅").action(async ({ session }, page = 1) => {
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const userIdentifier = session.userId;
+    const res = await client.getExchangePosters(ctx, fwToken, page, userIdentifier);
+    if (!res?.posters) return "获取交换大厅数据失败。";
+    const data = {
+      filterLabel: "全部",
+      posts: (res.posters || []).map((poster) => {
+        const user = poster.user_info || {};
+        const provideItems = parseExchangeItems(
+          poster.offer_items ?? poster.offer_item_names ?? poster.offerItems ?? []
+        );
+        return {
+          userName: user.nickname || "?",
+          userLevel: user.level || 0,
+          isOnline: user.online_status === 1,
+          avatarUrl: user.avatar_url || "",
+          userId: user.role_id || "",
+          wantText: parseExchangeWantText(
+            poster.want_item_name ?? poster.want_item ?? poster.wantText ?? "交友"
+          ),
+          wantBadgeUrl: "",
+          isExpired: false,
+          provideItems: provideItems.length > 0 ? provideItems : ["暂无"],
+          timeLabel: poster.create_time ? new Date(Number(poster.create_time) * 1e3).toLocaleString("zh-CN", {
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit"
+          }) : "?"
+        };
+      }),
+      currentPage: page,
+      totalPages: res.total_pages || 1,
+      commandHint: "洛克.交换大厅 <页码>"
+    };
+    await sendImage(deps, session, "exchange-hall", data, `【交换大厅】第${page}页`);
+  });
+  ctx.command("洛克").subcommand(".玩家 <uid:string>", "通过 ingame 接口查询玩家基础资料").action(async ({ session }, uid) => {
+    if (!uid) return "请提供玩家 UID。用法：洛克.玩家 <UID>";
+    const res = await client.ingamePlayerSearch(ctx, uid);
+    if (!res) return `玩家搜索失败：${client.getLastError()}`;
+    await sendImage(deps, session, "player-search", buildPlayerSearchRenderData(res, uid), `【洛克玩家】UID ${uid}`);
+  });
+  ctx.command("洛克").subcommand(".家园 [uid:string]", "通过 UID 查询家园菜园、守卫和室内精灵").action(async ({ session }, uid = "") => {
+    let targetUid = String(uid || "").trim();
+    if (!targetUid) {
+      const binding = deps.userMgr.getPrimaryBinding(session.userId);
+      targetUid = String(binding?.role_id || "");
+    }
+    if (!targetUid) return "请提供玩家 UID，或先完成绑定后使用 洛克.家园。";
+    const res = await client.ingameHomeInfo(ctx, targetUid);
+    if (!res) return `家园查询失败：${client.getLastError()}`;
+    await sendImage(deps, session, "home", buildHomeRenderData(deps, res, targetUid), `【洛克家园】UID ${targetUid}`);
+  });
+  ctx.command("洛克").subcommand(".商店 <shopId:string>", "通过 ingame 接口查询商店信息").action(async ({ session }, shopId) => {
+    if (!shopId) return "请提供商店 ID。用法：洛克.商店 <shop_id>";
+    const res = await client.ingameMerchantInfo(ctx, shopId);
+    if (!res) return `商店查询失败：${client.getLastError()}`;
+    await sendImage(deps, session, "ingame-shop", buildShopRenderData(res, shopId), `【洛克商店】shop_id=${shopId}`);
+  });
+  ctx.command("洛克").subcommand(".好友关系 <userIds:string>", "查询好友关系").action(async ({ session }, userIds) => {
+    if (!userIds) return "请提供要查询的用户 ID 列表。用法：洛克.好友关系 <id1,id2>";
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const res = await client.getFriendship(ctx, fwToken, userIds, session.userId);
+    if (!res) return `好友关系查询失败：${client.getLastError()}`;
+    await sendImage(deps, session, "friendship", buildFriendshipRenderData(res, userIds), `【好友关系】${userIds}`);
+  });
+  ctx.command("洛克").subcommand(".学生 [area:number] [accountType:number]", "查询学生认证状态与学生活动福利").action(async ({ session }, area = 101, accountType = 0) => {
+    const fwToken = await getPrimaryToken(deps, session.userId);
+    if (!fwToken) return notLoggedInHint();
+    const userIdentifier = session.userId;
+    const [stateRes, perksRes] = await Promise.all([
+      client.getStudentState(ctx, fwToken, accountType, userIdentifier),
+      client.getStudentPerks(ctx, fwToken, area, accountType, userIdentifier)
+    ]);
+    if (!stateRes) return `学生认证状态查询失败：${client.getLastError()}`;
+    if (!perksRes) return `学生活动福利查询失败：${client.getLastError()}`;
+    await sendImage(deps, session, "student", buildStudentRenderData(stateRes, perksRes, area, accountType), "【洛克学生】认证与福利信息");
+  });
+  ctx.command("订阅家园菜园 [uid:string]", "订阅指定 UID 的家园菜园成熟提醒").action(async ({ session }, uid = "") => subscribeHome(deps, session, uid, "garden"));
+  ctx.command("订阅家园灵感 [uid:string]", "订阅指定 UID 的家园精灵灵感完成提醒").action(async ({ session }, uid = "") => subscribeHome(deps, session, uid, "inspiration"));
+  ctx.command("取消订阅家园 [kind:string] [uid:string]", "取消当前会话的家园订阅").action(async ({ session }, kind = "全部", uid = "") => {
+    const target = sessionTarget(session);
+    if (!target.userId && !isBotAdmin(session, deps.config.adminUserIds)) return "此指令仅限管理员使用。";
+    const kindMap = { "菜园": "garden", "灵感": "inspiration", "全部": "", all: "", garden: "garden", inspiration: "inspiration" };
+    const deleted = deps.homeSubMgr.deleteMatching(target, kindMap[String(kind || "全部")] ?? "", String(uid || "").trim());
+    return deleted ? `已取消 ${deleted} 条家园订阅。` : "当前会话没有匹配的家园订阅。";
+  });
+  ctx.command("洛克").subcommand(".调试家园订阅", "立即执行一次家园订阅检查").action(async ({ session }) => {
+    if (!isBotAdmin(session, deps.config.adminUserIds)) return "此指令仅限管理员使用。";
+    const result = await checkHomeSubscriptions(deps);
+    return `家园订阅检查完成：订阅 ${result.subscriptions} 条，检查 ${result.checked} 条，推送 ${result.pushed} 档提醒。`;
+  });
+  if (deps.config.homeSubscriptionEnabled) {
+    ctx.setInterval(() => checkHomeSubscriptions(deps).catch((err) => logger7.warn(`家园订阅检查失败: ${err}`)), Math.max(1, deps.config.homeSubscriptionIntervalMinutes || 5) * 6e4);
+  }
+}
+__name(register2, "register");
+
+// src/commands/merchant.ts
+var import_koishi9 = require("koishi");
+var logger8 = new import_koishi9.Logger("rocom-merchant");
+var TEXT = {
+  merchant: "远行商人",
+  subscribe: "订阅远行商人",
+  unsubscribe: "取消订阅远行商人",
+  viewSubscribe: "查看远行商人订阅",
+  unknown: "未知",
+  notOpen: "未开放",
+  defaultSource: "默认",
+  customSource: "自定义"
+};
+function normalizeTimestamp(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const timestamp = Number(value);
+  if (!Number.isFinite(timestamp)) return null;
+  return timestamp < 1e11 ? timestamp * 1e3 : timestamp;
+}
+__name(normalizeTimestamp, "normalizeTimestamp");
+function formatProductWindow(product) {
+  const start = normalizeTimestamp(product?.start_time);
+  const end = normalizeTimestamp(product?.end_time);
+  if (!start && !end) return "";
+  const formatTime = /* @__PURE__ */ __name((timestamp) => {
+    const date = new Date(timestamp);
+    const hour = String(date.getHours()).padStart(2, "0");
+    const minute = String(date.getMinutes()).padStart(2, "0");
+    return `${hour}:${minute}`;
+  }, "formatTime");
+  if (start && end) return `${formatTime(start)}-${formatTime(end)}`;
+  if (start) return `${formatTime(start)}+`;
+  return `${formatTime(end)}-`;
+}
+__name(formatProductWindow, "formatProductWindow");
+function getMerchantActivity(res) {
+  const activities = res?.merchantActivities || res?.merchant_activities || [];
+  return activities[0] || {};
+}
+__name(getMerchantActivity, "getMerchantActivity");
+function getActiveProducts(res) {
+  const activity = getMerchantActivity(res);
+  const products = activity?.products || activity?.product_list || activity?.get_props || [];
+  return products.filter((p) => {
+    const now = Date.now();
+    const start = normalizeTimestamp(p.start_time) ?? 0;
+    const end = normalizeTimestamp(p.end_time) ?? Infinity;
+    return now >= start && now < end;
+  });
+}
+__name(getActiveProducts, "getActiveProducts");
+function getCurrentMerchantRound() {
+  const now = /* @__PURE__ */ new Date();
+  const hour = now.getHours();
+  const rounds = [8, 12, 16, 20];
+  let currentRound = null;
+  let nextRound = null;
+  for (let i = 0; i < rounds.length; i++) {
+    if (hour >= rounds[i] && (i === rounds.length - 1 || hour < rounds[i + 1])) {
+      currentRound = i + 1;
+      nextRound = i < rounds.length - 1 ? rounds[i + 1] : rounds[0];
+      break;
+    }
+  }
+  if (currentRound === null) nextRound = rounds[0];
+  const nextTime = new Date(now);
+  if (nextRound <= hour) nextTime.setDate(nextTime.getDate() + 1);
+  nextTime.setHours(nextRound, 0, 0, 0);
+  const diff = nextTime.getTime() - now.getTime();
+  const hours = Math.floor(diff / 36e5);
+  const mins = Math.floor(diff % 36e5 / 6e4);
+  const datePart = [
+    now.getFullYear(),
+    String(now.getMonth() + 1).padStart(2, "0"),
+    String(now.getDate()).padStart(2, "0")
+  ].join("-");
+  return {
+    current: currentRound,
+    countdown: `${hours}小时${mins}分钟`,
+    is_open: currentRound !== null,
+    round_id: `${datePart}-${currentRound || "closed"}`
+  };
+}
+__name(getCurrentMerchantRound, "getCurrentMerchantRound");
+function parseMerchantSubscriptionArgs(args, defaultItems) {
+  const parts = (args || "").split(/\s+/).filter(Boolean);
+  let mentionAll = false;
+  if (parts[0] === "1" || parts[0] === "0") {
+    mentionAll = parts.shift() === "1";
+  }
+  const items = parts.length ? parts : defaultItems;
+  return {
+    mention_all: mentionAll,
+    items,
+    source: parts.length ? TEXT.customSource : TEXT.defaultSource
+  };
+}
+__name(parseMerchantSubscriptionArgs, "parseMerchantSubscriptionArgs");
+function getSubscriptionTarget(session) {
+  const platform = session.platform || session.bot?.platform || "";
+  const privateChat = !session.guildId;
+  const channelId = session.channelId || session.guildId || session.userId || "";
+  const key = privateChat ? `private_${session.userId}` : session.guildId;
+  return { key, platform, channelId, privateChat };
+}
+__name(getSubscriptionTarget, "getSubscriptionTarget");
+function isBotAdmin2(session, adminUserIds) {
+  return adminUserIds.includes(session?.userId || "");
+}
+__name(isBotAdmin2, "isBotAdmin");
+function sameStringArray(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+__name(sameStringArray, "sameStringArray");
+async function checkMerchantSubscriptions(deps) {
+  const { ctx, client, merchantSubMgr } = deps;
+  const res = await client.getMerchantInfo(ctx, true);
+  if (!res) return { subscriptions: 0, matched: 0, pushed: 0 };
+  const products = getActiveProducts(res);
+  const productNames = products.map((p) => p.name || "").filter(Boolean);
+  const roundInfo = getCurrentMerchantRound();
+  const subs = merchantSubMgr.getAll();
+  let matchedCount = 0;
+  let pushedCount = 0;
+  for (const [key, sub] of Object.entries(subs)) {
+    const matched = sub.items.filter((item) => productNames.some((n) => n.includes(item)));
+    if (!matched.length) continue;
+    matchedCount++;
+    if (sub.last_push_round === roundInfo.round_id && sameStringArray(matched, sub.last_matched_items || [])) continue;
+    const msg = `🔔 远行商人刷新提醒
+当前商品：${productNames.join("、")}
+匹配订阅：${matched.join("、")}`;
+    const platform = sub.platform || ctx.bots[0]?.platform;
+    const channelId = sub.channel_id || sub.group_id || sub.user_id || key;
+    if (!platform || !channelId) {
+      logger8.warn(`推送失败 ${key}: 无法确定平台或频道`);
+      continue;
+    }
+    const sent = await sendScheduledMessage(ctx, {
+      platform,
+      channelId,
+      guildId: sub.group_id || "",
+      userId: sub.user_id || ""
+    }, sub.mention_all ? `@全体
+${msg}` : msg);
+    if (!sent) continue;
+    pushedCount++;
+    merchantSubMgr.upsert(key, {
+      ...sub,
+      last_push_round: roundInfo.round_id,
+      last_matched_items: matched
+    });
+  }
+  return { subscriptions: Object.keys(subs).length, matched: matchedCount, pushed: pushedCount };
+}
+__name(checkMerchantSubscriptions, "checkMerchantSubscriptions");
+function register3(deps) {
+  const { ctx, config, client, merchantSubMgr } = deps;
+  ctx.command(TEXT.merchant, "查看远行商人商品").action(async ({ session }) => {
+    const res = await client.getMerchantInfo(ctx, true);
+    if (!res) return "获取远行商人数据失败。";
+    const products = getActiveProducts(res);
+    const roundInfo = getCurrentMerchantRound();
+    const activity = getMerchantActivity(res);
+    const data = {
+      background: "",
+      title: activity.name || TEXT.merchant,
+      subtitle: activity.start_date || "每日 08:00 / 12:00 / 16:00 / 20:00 刷新",
+      titleIcon: "",
+      product_count: products.length,
+      round_info: roundInfo,
+      products: products.map((p) => ({
+        name: p.name || TEXT.unknown,
+        image: p.icon_url || "",
+        time_label: formatProductWindow(p)
+      }))
+    };
+    const fallback = products.length ? `远行商人当前商品：${products.map((p) => p.name || TEXT.unknown).join("、")}
+轮次：${roundInfo.current || TEXT.notOpen}
+剩余：${roundInfo.countdown}` : "当前远行商人暂无商品。";
+    const png = await deps.renderer.renderHtml(ctx, "yuanxing-shangren", data);
+    await sendImageWithFallback(session, png, fallback, "merchant:yuanxing-shangren", deps.config);
+  });
+  ctx.command(`${TEXT.subscribe} [args:text]`, "订阅远行商人商品提醒").action(async ({ session }, args) => {
+    const target = getSubscriptionTarget(session);
+    if (!target.privateChat && !isBotAdmin2(session, config.adminUserIds)) return "此指令仅限管理员使用。";
+    if (target.privateChat && !config.merchantPrivateSubscriptionEnabled) return "个人私聊订阅功能已被禁用，请联系机器人管理员。";
+    const parsed = parseMerchantSubscriptionArgs(args, config.merchantSubscriptionItems);
+    const existing = merchantSubMgr.get(target.key);
+    merchantSubMgr.upsert(target.key, {
+      group_id: session.guildId || "",
+      user_id: target.privateChat ? session.userId : "",
+      type: target.privateChat ? "个人订阅" : "群订阅",
+      channel_id: target.channelId,
+      platform: target.platform,
+      items: parsed.items,
+      mention_all: target.privateChat ? false : parsed.mention_all,
+      last_push_round: existing?.last_push_round ?? null,
+      last_matched_items: existing?.last_matched_items ?? [],
+      updated_by: session.userId
+    });
+    return `✅ 已订阅远行商人商品：${parsed.items.join("、")}（${parsed.source}）；${target.privateChat ? "个人订阅" : parsed.mention_all ? "命中后会 @全体" : "命中后不 @全体"}`;
+  });
+  ctx.command(TEXT.viewSubscribe, "查看当前会话的远行商人订阅").action(async ({ session }) => {
+    const target = getSubscriptionTarget(session);
+    if (!target.privateChat && !isBotAdmin2(session, config.adminUserIds)) return "此指令仅限管理员使用。";
+    const sub = merchantSubMgr.get(target.key);
+    const scopeName = target.privateChat ? "你" : "当前群组";
+    if (!sub) return `${scopeName}未订阅远行商人。
+用法：${TEXT.subscribe} [1/0] [商品名1] [商品名2] ...`;
+    return `${scopeName}订阅商品：${sub.items.join("、")}
+提醒方式：${target.privateChat ? "私聊提醒" : sub.mention_all ? "@全体" : "普通提醒"}`;
+  });
+  ctx.command(TEXT.unsubscribe, "取消远行商人订阅").action(async ({ session }) => {
+    const target = getSubscriptionTarget(session);
+    if (!target.privateChat && !isBotAdmin2(session, config.adminUserIds)) return "此指令仅限管理员使用。";
+    merchantSubMgr.delete(target.key);
+    return "✅ 已取消远行商人订阅。";
+  });
+  ctx.command("洛克").subcommand(".调试远行商人订阅", "立即执行一次远行商人订阅检查").action(async ({ session }) => {
+    if (!isBotAdmin2(session, config.adminUserIds)) return "此指令仅限管理员使用。";
+    const result = await checkMerchantSubscriptions(deps);
+    return `远行商人订阅检查完成：订阅 ${result.subscriptions} 条，命中 ${result.matched} 条，推送 ${result.pushed} 条。`;
+  });
+  if (config.merchantSubscriptionEnabled) {
+    ctx.setInterval(async () => {
+      await checkMerchantSubscriptions(deps);
+    }, config.merchantCheckInterval);
+  }
+}
+__name(register3, "register");
+
+// src/commands/wiki.ts
+var WIKI_CLOSED_MESSAGE = "该功能暂时关闭";
+function register4(deps) {
+  const { ctx } = deps;
+  ctx.command("洛克").subcommand(".wiki <name:text>", "查询精灵 wiki").action(() => WIKI_CLOSED_MESSAGE);
+  ctx.command("洛克").subcommand(".技能 <name:text>", "查询技能 wiki").action(() => WIKI_CLOSED_MESSAGE);
+}
+__name(register4, "register");
+
+// src/commands/egg.ts
+function petName2(p) {
+  return p?.localized?.zh?.name || p?.name || "未知精灵";
+}
+__name(petName2, "petName");
+function parseHeightValue(raw) {
+  const text = String(raw ?? "").trim().toLowerCase().replace(/^(身高|高度|h)\s*/i, "").trim();
+  const match = text.match(/^([0-9]+(?:\.[0-9]+)?)(?:\s*(m|米))?$/);
+  if (!match) return null;
+  const meterValue = Number(match[1]);
+  if (!Number.isFinite(meterValue)) return null;
+  return {
+    dataValue: meterValue * 100,
+    meterValue,
+    display: `${formatNumber2(meterValue)} m`
+  };
+}
+__name(parseHeightValue, "parseHeightValue");
+function parseWeightValue(raw) {
+  const text = String(raw ?? "").trim().toLowerCase().replace(/^(体重|重量|w)\s*/i, "").trim();
+  const match = text.match(/^([0-9]+(?:\.[0-9]+)?)(?:\s*(kg|千克|公斤))?$/);
+  if (!match) return null;
+  const value = Number(match[1]);
+  return Number.isFinite(value) ? value : null;
+}
+__name(parseWeightValue, "parseWeightValue");
+function formatNumber2(value) {
+  return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(4)));
+}
+__name(formatNumber2, "formatNumber");
+function searchResultCandidates(result) {
+  return result.candidates || [];
+}
+__name(searchResultCandidates, "searchResultCandidates");
+async function sendEggImage(deps, session, templateName, data, fallback) {
+  const png = await deps.renderer.renderHtml(deps.ctx, templateName, data);
+  await sendImageWithFallback(session, png, fallback, `egg:${templateName}`, deps.config);
+}
+__name(sendEggImage, "sendEggImage");
+function register5(deps) {
+  const { ctx, client, eggService } = deps;
+  ctx.command("洛克").subcommand(".查蛋 [arg1:string] [arg2:string]", "查询精灵蛋组").action(async ({ session }, arg1, arg2) => {
+    if (!arg1) {
+      return [
+        "查蛋用法：",
+        "  洛克.查蛋 <精灵名>",
+        "  洛克.查蛋 0.18 1.5",
+        "  洛克.查蛋 0.18m 1.5kg",
+        "  洛克.查蛋 身高0.18m 体重1.5kg"
+      ].join("\n");
+    }
+    let height;
+    let heightMeters;
+    let heightDisplay;
+    let weight;
+    const nameParts = [];
+    const numericArgs = [];
+    for (const rawArg of [arg1, arg2]) {
+      if (!rawArg) continue;
+      const arg = String(rawArg).trim();
+      const explicitHeight = /^(身高|高度|h)/i.test(arg);
+      const explicitWeight = /^(体重|重量|w)/i.test(arg);
+      if (explicitHeight) {
+        const parsed = parseHeightValue(arg);
+        if (parsed) {
+          height = parsed.dataValue;
+          heightMeters = parsed.meterValue;
+          heightDisplay = parsed.display;
+          continue;
+        }
+      }
+      if (explicitWeight) {
+        const parsed = parseWeightValue(arg);
+        if (parsed != null) {
+          weight = parsed;
+          continue;
+        }
+      }
+      const heightCandidate = parseHeightValue(arg);
+      const weightCandidate = parseWeightValue(arg);
+      if (heightCandidate || weightCandidate != null) {
+        numericArgs.push({ height: heightCandidate, weight: weightCandidate });
+      } else {
+        nameParts.push(arg);
+      }
+    }
+    if (numericArgs.length) {
+      if (height == null && numericArgs[0]?.height) {
+        height = numericArgs[0].height.dataValue;
+        heightMeters = numericArgs[0].height.meterValue;
+        heightDisplay = numericArgs[0].height.display;
+      }
+      if (weight == null && numericArgs[1]?.weight != null) {
+        weight = numericArgs[1].weight;
+      }
+    }
+    if (height != null || weight != null) {
+      let data2 = null;
+      let fallback = "";
+      if (height != null && weight != null) {
+        const backendResults = await client.queryPetSize(ctx, heightMeters ?? height / 100, weight);
+        if (backendResults) {
+          data2 = eggService.buildSizeSearchDataFromApi(height, weight, backendResults, heightDisplay);
+          fallback = eggService.buildSizeSearchTextFromApi(height, weight, backendResults, heightDisplay);
+        }
+      }
+      if (!data2) {
+        const results = eggService.searchBySize(height, weight);
+        data2 = eggService.buildSizeSearchData(height, weight, results, heightDisplay);
+        fallback = eggService.buildSizeSearchText(height, weight, results, heightDisplay);
+      }
+      await sendEggImage(deps, session, "searcheggs/size", data2, fallback);
+      return;
+    }
+    const name2 = nameParts.join(" ");
+    if (!name2) return "请输入精灵名称。用法：洛克.查蛋 <精灵名>";
+    const sr = eggService.search(name2);
+    if (sr.matchType === "multi") {
+      const candidates = searchResultCandidates(sr);
+      const data2 = eggService.buildCandidatesRenderData(name2, candidates);
+      await sendEggImage(deps, session, "searcheggs/candidates", data2, eggService.buildCandidatesText(name2, candidates));
+      return;
+    }
+    if (sr.matchType === "not_found") return `未找到名为「${name2}」的精灵，请检查名称后重试。`;
+    const pet = sr.pet;
+    const data = eggService.buildSearchData(pet);
+    data.commandHint = "洛克.查蛋 <名称> | 洛克.查蛋 身高0.18m 体重1.5kg | 洛克.配种 <父体> <母体>";
+    data.copyright = "Koishi & WeGame 洛克王国插件";
+    const hint = sr.matchType === "fuzzy" ? `模糊匹配到「${petName2(pet)}」
+` : "";
+    await sendEggImage(deps, session, "searcheggs", data, hint + eggService.buildSearchText(pet));
+  });
+  ctx.command("洛克").subcommand(".配种 <nameA:string> [nameB:string]", "配种查询").action(async ({ session }, nameA, nameB) => {
+    if (!nameA) {
+      return [
+        "配种用法：",
+        "  洛克.配种 <精灵名>",
+        "    查询想孵出这个精灵时可选哪些父体。",
+        "  洛克.配种 <父体> <母体>",
+        "    判断两只精灵是否可以配种，默认前父后母，孵蛋结果跟随母体。",
+        "示例：",
+        "  洛克.配种 喵喵",
+        "  洛克.配种 父体名称 母体名称"
+      ].join("\n");
+    }
+    if (!nameB) {
+      const sr = eggService.search(nameA);
+      if (sr.matchType === "multi") {
+        const candidates = searchResultCandidates(sr);
+        const data3 = eggService.buildCandidatesRenderData(nameA, candidates);
+        await sendEggImage(deps, session, "searcheggs/candidates", data3, eggService.buildCandidatesText(nameA, candidates));
+        return;
+      }
+      if (sr.matchType === "not_found") return `未找到名为「${nameA}」的精灵。`;
+      const data2 = eggService.buildWantPetData(sr.pet);
+      await sendEggImage(deps, session, "searcheggs/want", data2, eggService.buildWantPetText(sr.pet));
+      return;
+    }
+    const srA = eggService.search(nameA);
+    if (srA.matchType === "multi") {
+      const candidates = searchResultCandidates(srA);
+      const data2 = eggService.buildCandidatesRenderData(nameA, candidates);
+      await sendEggImage(deps, session, "searcheggs/candidates", data2, eggService.buildCandidatesText(nameA, candidates));
+      return;
+    }
+    if (srA.matchType === "not_found") return `未找到名为「${nameA}」的精灵。`;
+    const srB = eggService.search(nameB);
+    if (srB.matchType === "multi") {
+      const candidates = searchResultCandidates(srB);
+      const data2 = eggService.buildCandidatesRenderData(nameB, candidates);
+      await sendEggImage(deps, session, "searcheggs/candidates", data2, eggService.buildCandidatesText(nameB, candidates));
+      return;
+    }
+    if (srB.matchType === "not_found") return `未找到名为「${nameB}」的精灵。`;
+    const data = eggService.buildPairData(srB.pet, srA.pet);
+    data.commandHint = "默认前父后母，孵蛋结果跟随母体 | 洛克.配种 <精灵名> 查询怎么孵";
+    data.copyright = "Koishi & WeGame 洛克王国插件";
+    await sendEggImage(deps, session, "searcheggs/pair", data, eggService.buildPairText(srB.pet, srA.pet));
+  });
+}
+__name(register5, "register");
+
+// src/commands/admin.ts
+var import_koishi10 = require("koishi");
+var logger9 = new import_koishi10.Logger("rocom-admin");
+function register6(deps) {
+  const { ctx, config, client, userMgr } = deps;
+  function isAdmin(userId) {
+    return config.adminUserIds.includes(userId);
+  }
+  __name(isAdmin, "isAdmin");
+  ctx.command("洛克").subcommand(".刷新所有凭证", "刷新所有用户凭证（管理员）").action(async ({ session }) => {
+    if (!isAdmin(session.userId)) return "此指令仅限管理员使用。";
+    await session.send("正在刷新所有用户的凭证...");
+    const allUsers = userMgr.getAllUsersBindings();
+    let success = 0;
+    let fail = 0;
+    for (const [userId] of Object.entries(allUsers)) {
+      const binding = userMgr.getPrimaryBinding(userId);
+      if (!binding || binding.login_type !== "qq" || !binding.binding_id) continue;
+      try {
+        const res = await client.refreshBinding(ctx, binding.binding_id, userId);
+        if (res?.framework_token) {
+          await upsertRoleToken(ctx, {
+            userId,
+            fwt: res.framework_token,
+            bindingId: binding.binding_id,
+            roleId: binding.role_id,
+            loginType: binding.login_type
+          });
+          success++;
+        } else {
+          fail++;
+        }
+      } catch {
+        fail++;
+      }
+    }
+    return `刷新完成：成功 ${success}，失败 ${fail}`;
+  });
+  ctx.command("洛克").subcommand(".删除失效绑定", "清理失效绑定（管理员）").action(async ({ session }) => {
+    if (!isAdmin(session.userId)) return "此指令仅限管理员使用。";
+    await session.send("正在检查所有用户的绑定有效性...");
+    const allUsers = userMgr.getAllUsersBindings();
+    let totalInvalid = 0;
+    let totalValid = 0;
+    for (const [userId, bindings] of Object.entries(allUsers)) {
+      const token = await getRoleToken(ctx, userId);
+      if (!token?.fwt) {
+        logger9.warn(`用户 ${userId} 没有可用的 fwt，跳过失效检测`);
+        continue;
+      }
+      const fwToken = token.fwt;
+      const valid = [];
+      for (const binding of bindings) {
+        const roleRes = await client.getRole(ctx, fwToken, void 0, userId);
+        if (roleRes?.role) {
+          valid.push(binding);
+          totalValid++;
+          continue;
+        }
+        if (binding.binding_id) {
+          try {
+            await client.deleteBinding(ctx, binding.binding_id, userId);
+          } catch (e) {
+            logger9.warn(`删除用户 ${userId} 服务端绑定 ${binding.binding_id} 失败：${e}`);
+          }
+        }
+        totalInvalid++;
+      }
+      userMgr.saveUserBindings(userId, valid);
+      if (valid.length === 0) {
+        await removeRoleToken(ctx, userId);
+      }
+    }
+    return totalInvalid > 0 ? `清理完成：移除 ${totalInvalid} 个无效绑定，剩余 ${totalValid} 个有效绑定。` : `所有绑定均有效，无需清理。共 ${totalValid} 个有效绑定。`;
+  });
+  if (config.autoRefreshEnabled) {
+    ctx.setInterval(async () => {
+      const now = /* @__PURE__ */ new Date();
+      const timeStr = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+      if (!config.autoRefreshTime.includes(timeStr)) return;
+      const allUsers = userMgr.getAllUsersBindings();
+      for (const [userId] of Object.entries(allUsers)) {
+        const binding = userMgr.getPrimaryBinding(userId);
+        if (!binding || binding.login_type !== "qq" || !binding.binding_id) continue;
+        try {
+          const res = await client.refreshBinding(ctx, binding.binding_id, userId);
+          if (res?.framework_token) {
+            await upsertRoleToken(ctx, {
+              userId,
+              fwt: res.framework_token,
+              bindingId: binding.binding_id,
+              roleId: binding.role_id,
+              loginType: binding.login_type
+            });
+          }
+        } catch (e) {
+          logger9.warn(`自动刷新用户 ${userId} 失败: ${e}`);
+        }
+      }
+    }, 6e4);
+  }
+}
+__name(register6, "register");
+
+// src/index.ts
+var name = "rocom";
+var inject = { required: ["puppeteer", "database"] };
+var Config = import_koishi11.Schema.intersect([
+  import_koishi11.Schema.object({
+    apiBaseUrl: import_koishi11.Schema.string().default("https://wegame.shallow.ink").description("API 基础地址"),
+    wegameApiKey: import_koishi11.Schema.string().default("").description("WeGame API Key"),
+    qqLoginDebugMode: import_koishi11.Schema.boolean().default(false).description("QQ 扫码登录调试模式：扫码成功后输出用户 fwt（敏感凭证，请仅调试时开启）"),
+    adminUserIds: import_koishi11.Schema.array(String).default([]).description("管理员用户 ID 列表（仅用于管理员命令）"),
+    autoRefreshEnabled: import_koishi11.Schema.boolean().default(false).description("启用自动刷新凭证"),
+    autoRefreshTime: import_koishi11.Schema.array(String).default(["00:00", "12:00"]).description("自动刷新时间")
+  }).description("基础设置"),
+  import_koishi11.Schema.object({
+    imageCompressionEnabled: import_koishi11.Schema.boolean().default(true).description("发送图片前启用 PNG 无损压缩。失败或压缩后不更小时会发送原图。"),
+    imageCompressionMinBytes: import_koishi11.Schema.number().default(262144).description("触发压缩的最小图片大小，单位字节。低于此大小直接发送原图。"),
+    imageCompressionLevel: import_koishi11.Schema.number().min(0).max(9).default(9).description("PNG zlib 压缩等级，0-9，数值越大越慢但通常更小。")
+  }).description("图片压缩设置"),
+  import_koishi11.Schema.object({
+    merchantSubscriptionEnabled: import_koishi11.Schema.boolean().default(true).description("启用远行商人订阅"),
+    merchantSubscriptionItems: import_koishi11.Schema.array(String).default(["国王球", "棱镜球", "炫彩精灵蛋"]).description("默认订阅商品"),
+    merchantCheckInterval: import_koishi11.Schema.number().default(3e5).description("商人检查间隔(ms)"),
+    merchantPrivateSubscriptionEnabled: import_koishi11.Schema.boolean().default(true).description("允许个人私聊订阅远行商人推送"),
+    homeSubscriptionEnabled: import_koishi11.Schema.boolean().default(true).description("启用家园菜园和灵感订阅推送"),
+    homeSubscriptionIntervalMinutes: import_koishi11.Schema.number().default(5).description("家园订阅检查间隔（分钟）")
+  }).description("订阅推送设置")
+]);
+function apply(ctx, config) {
+  setupRoleTokenModel(ctx);
+  const client = new RocomClient(config.apiBaseUrl, config.wegameApiKey);
+  const dataDir = import_node_path5.default.join(ctx.baseDir, "data", "rocom");
+  const userMgr = new UserManager(dataDir);
+  const merchantSubMgr = new MerchantSubscriptionManager(dataDir);
+  const homeSubMgr = new HomeSubscriptionManager(dataDir);
+  const resPath = import_node_path5.default.resolve(__dirname, "..");
+  const renderer = new Renderer(resPath);
+  const searcheggsDir = import_node_path5.default.join(resPath, "src", "render-templates", "searcheggs");
+  const eggService = new EggService(searcheggsDir);
+  const deps = { ctx, config, client, userMgr, merchantSubMgr, homeSubMgr, eggService, renderer };
+  ctx.on("ready", () => {
+    migrateRoleTokensToUserId(ctx).catch((err) => {
+      console.warn(`[rocom] role token migration failed: ${err}`);
+    });
+    migrateLegacyFrameworkTokens(ctx, userMgr).catch((err) => {
+      console.warn(`[rocom] legacy framework token migration failed: ${err}`);
+    });
+  });
+  ctx.command("洛克", "洛克王国帮助菜单").action(async () => [
+    "【洛克王国插件】",
+    "",
+    "📋 账号管理：",
+    "  洛克.QQ登录 / 洛克.微信登录 / 洛克.导入",
+    "  洛克.绑定列表 / 洛克.切换 / 洛克.解绑 / 洛克.刷新",
+    "",
+    "📊 数据查询：",
+    "  洛克.档案 / 洛克.战绩 / 洛克.背包 / 洛克.阵容",
+    "  洛克.交换大厅 / 远行商人 / 订阅远行商人",
+    "",
+    "📖 百科查询：",
+    "  洛克.wiki / 洛克.技能 / 洛克.查蛋 / 洛克.配种"
+  ].join("\n"));
+  register(deps);
+  register2(deps);
+  register3(deps);
+  register4(deps);
+  register5(deps);
+  register6(deps);
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});