@naplink/naplink 0.0.1

package/dist/index.js

@@ -0,0 +1,1572 @@
+// src/naplink.ts
+import EventEmitter2 from "events";
+
+// src/utils/logger.ts
+var LOG_LEVEL_MAP = {
+  debug: 0 /* DEBUG */,
+  info: 1 /* INFO */,
+  warn: 2 /* WARN */,
+  error: 3 /* ERROR */,
+  off: 4 /* OFF */
+};
+var DefaultLogger = class {
+  level;
+  constructor(level = "info") {
+    this.level = LOG_LEVEL_MAP[level];
+  }
+  /**
+   * 设置日志等级
+   */
+  setLevel(level) {
+    this.level = LOG_LEVEL_MAP[level];
+  }
+  debug(message, ...meta) {
+    if (this.shouldLog(0 /* DEBUG */)) {
+      console.debug(this.format("DEBUG", message), ...meta);
+    }
+  }
+  info(message, ...meta) {
+    if (this.shouldLog(1 /* INFO */)) {
+      console.info(this.format("INFO", message), ...meta);
+    }
+  }
+  warn(message, ...meta) {
+    if (this.shouldLog(2 /* WARN */)) {
+      console.warn(this.format("WARN", message), ...meta);
+    }
+  }
+  error(message, error, ...meta) {
+    if (this.shouldLog(3 /* ERROR */)) {
+      console.error(this.format("ERROR", message), error || "", ...meta);
+    }
+  }
+  /**
+   * 检查是否应该输出日志
+   */
+  shouldLog(level) {
+    return level >= this.level;
+  }
+  /**
+   * 格式化日志消息
+   */
+  format(level, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `[${timestamp}] [NapLink] ${level}: ${message}`;
+  }
+};
+
+// src/core/connection/manager.ts
+import WebSocket2 from "isomorphic-ws";
+
+// src/types/errors.ts
+var NapLinkError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * 转换为JSON格式
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+};
+var ConnectionError = class extends NapLinkError {
+  constructor(message, cause) {
+    super(message, "E_CONNECTION", cause);
+  }
+};
+var ApiTimeoutError = class extends NapLinkError {
+  constructor(method, timeout) {
+    super(
+      `API\u8C03\u7528 ${method} \u8D85\u65F6 (${timeout}ms)`,
+      "E_API_TIMEOUT",
+      { method, timeout }
+    );
+  }
+};
+var ApiError = class extends NapLinkError {
+  constructor(method, retcode, message, wording) {
+    super(
+      wording || message || `API\u8C03\u7528\u5931\u8D25: ${method}`,
+      "E_API_FAILED",
+      { method, retcode, message, wording }
+    );
+  }
+};
+var MaxReconnectAttemptsError = class extends NapLinkError {
+  constructor(attempts) {
+    super(
+      `\u8FBE\u5230\u6700\u5927\u91CD\u8FDE\u6B21\u6570 (${attempts})`,
+      "E_MAX_RECONNECT",
+      { attempts }
+    );
+  }
+};
+var ConnectionClosedError = class extends NapLinkError {
+  constructor(code, reason) {
+    super(
+      `\u8FDE\u63A5\u5DF2\u5173\u95ED: ${reason} (code: ${code})`,
+      "E_CONNECTION_CLOSED",
+      { code, reason }
+    );
+  }
+};
+var InvalidConfigError = class extends NapLinkError {
+  constructor(field, reason) {
+    super(
+      `\u65E0\u6548\u7684\u914D\u7F6E: ${field} - ${reason}`,
+      "E_INVALID_CONFIG",
+      { field, reason }
+    );
+  }
+};
+
+// src/core/reconnect.ts
+var ReconnectService = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.backoffMs = config.backoff.initial;
+  }
+  currentAttempt = 0;
+  backoffMs;
+  reconnectTimer;
+  hasRemainingAttempts() {
+    return this.currentAttempt < this.config.maxAttempts;
+  }
+  getMaxAttempts() {
+    return this.config.maxAttempts;
+  }
+  /**
+   * 调度重连
+   * @param reconnectFn 重连函数
+   * @returns 是否调度成功
+   */
+  schedule(reconnectFn) {
+    if (!this.config.enabled) {
+      this.logger.warn("\u81EA\u52A8\u91CD\u8FDE\u672A\u542F\u7528");
+      return false;
+    }
+    if (this.currentAttempt >= this.config.maxAttempts) {
+      this.logger.error(
+        `\u8FBE\u5230\u6700\u5927\u91CD\u8FDE\u6B21\u6570 (${this.config.maxAttempts})`,
+        void 0,
+        { attempts: this.currentAttempt }
+      );
+      return false;
+    }
+    this.currentAttempt++;
+    this.logger.info(
+      `\u5C06\u5728 ${this.backoffMs}ms \u540E\u8FDB\u884C\u7B2C ${this.currentAttempt} \u6B21\u91CD\u8FDE...`
+    );
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await reconnectFn();
+        this.reset();
+      } catch (error) {
+        this.logger.error("\u91CD\u8FDE\u5931\u8D25", error);
+        this.backoffMs = Math.min(
+          this.backoffMs * this.config.backoff.multiplier,
+          this.config.backoff.max
+        );
+        this.schedule(reconnectFn);
+      }
+    }, this.backoffMs);
+    return true;
+  }
+  /**
+   * 重置重连状态
+   * 在连接成功后调用
+   */
+  reset() {
+    this.currentAttempt = 0;
+    this.backoffMs = this.config.backoff.initial;
+    this.cancel();
+  }
+  /**
+   * 取消待定的重连
+   */
+  cancel() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+  }
+  /**
+   * 获取当前重连尝试次数
+   */
+  getCurrentAttempt() {
+    return this.currentAttempt;
+  }
+};
+
+// src/core/heartbeat.ts
+var HeartbeatService = class _HeartbeatService {
+  constructor(interval, sendPing, onTimeout, logger) {
+    this.interval = interval;
+    this.sendPing = sendPing;
+    this.onTimeout = onTimeout;
+    this.logger = logger;
+  }
+  timer;
+  lastPongTime = 0;
+  missedPings = 0;
+  static MAX_MISSED_PINGS = 3;
+  /**
+   * 启动心跳
+   */
+  start() {
+    if (this.interval <= 0) {
+      this.logger.debug("\u5FC3\u8DF3\u5DF2\u7981\u7528 (interval: 0)");
+      return;
+    }
+    this.logger.debug(`\u542F\u52A8\u5FC3\u8DF3\u670D\u52A1 (\u95F4\u9694: ${this.interval}ms)`);
+    this.lastPongTime = Date.now();
+    this.missedPings = 0;
+    this.timer = setInterval(() => {
+      const now = Date.now();
+      const elapsed = now - this.lastPongTime;
+      if (elapsed > this.interval * _HeartbeatService.MAX_MISSED_PINGS) {
+        this.missedPings++;
+        this.logger.warn(
+          `\u5FC3\u8DF3\u8D85\u65F6 (${this.missedPings}/${_HeartbeatService.MAX_MISSED_PINGS})`,
+          { elapsed }
+        );
+        if (this.missedPings >= _HeartbeatService.MAX_MISSED_PINGS) {
+          this.logger.error("\u5FC3\u8DF3\u8FDE\u7EED\u8D85\u65F6\uFF0C\u89E6\u53D1\u91CD\u8FDE");
+          this.stop();
+          this.onTimeout();
+          return;
+        }
+      }
+      this.logger.debug("\u53D1\u9001\u5FC3\u8DF3 ping");
+      this.sendPing();
+    }, this.interval);
+  }
+  /**
+   * 停止心跳
+   */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+      this.logger.debug("\u5FC3\u8DF3\u670D\u52A1\u5DF2\u505C\u6B62");
+    }
+  }
+  /**
+   * 记录收到pong
+   */
+  recordPong() {
+    this.lastPongTime = Date.now();
+    this.missedPings = 0;
+    this.logger.debug("\u6536\u5230\u5FC3\u8DF3 pong");
+  }
+  /**
+   * 检查心跳是否活跃
+   */
+  isActive() {
+    return this.timer !== void 0;
+  }
+};
+
+// src/core/connection/state.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState3) => {
+  ConnectionState3["DISCONNECTED"] = "disconnected";
+  ConnectionState3["CONNECTING"] = "connecting";
+  ConnectionState3["CONNECTED"] = "connected";
+  ConnectionState3["RECONNECTING"] = "reconnecting";
+  return ConnectionState3;
+})(ConnectionState || {});
+
+// src/core/connection/url.ts
+function buildWebSocketUrl(config) {
+  const { url, token } = config.connection;
+  if (token) {
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}access_token=${token}`;
+  }
+  return url;
+}
+
+// src/core/connection/heartbeat-runner.ts
+function startHeartbeat(deps) {
+  const { config, logger, send, onTimeout, createService } = deps;
+  const interval = config.connection.pingInterval || 0;
+  const heartbeatAction = config.connection.heartbeatAction;
+  if (interval <= 0 || !heartbeatAction?.action) {
+    return void 0;
+  }
+  const service = createService(
+    interval,
+    () => {
+      try {
+        const payload = {
+          action: heartbeatAction.action,
+          params: heartbeatAction.params ?? {},
+          echo: `heartbeat_${Date.now()}`
+        };
+        send(JSON.stringify(payload));
+      } catch (error) {
+        logger.error("\u53D1\u9001\u5FC3\u8DF3\u5931\u8D25", error);
+      }
+    },
+    onTimeout,
+    logger
+  );
+  service.start();
+  return service;
+}
+
+// src/core/connection/retry-handler.ts
+function handleReconnect(deps) {
+  const { config, logger, reconnectService, setState, connect } = deps;
+  if (!reconnectService.hasRemainingAttempts()) {
+    setState("disconnected" /* DISCONNECTED */);
+    const err = new MaxReconnectAttemptsError(reconnectService.getMaxAttempts());
+    logger.error("\u81EA\u52A8\u91CD\u8FDE\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u505C\u6B62\u91CD\u8FDE", err);
+    return false;
+  }
+  setState("reconnecting" /* RECONNECTING */);
+  const scheduled = reconnectService.schedule(() => connect());
+  if (!scheduled) {
+    setState("disconnected" /* DISCONNECTED */);
+    const err = new MaxReconnectAttemptsError(config.reconnect.maxAttempts);
+    logger.error("\u81EA\u52A8\u91CD\u8FDE\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u505C\u6B62\u91CD\u8FDE", err);
+    return false;
+  }
+  return true;
+}
+
+// src/core/connection/close-handler.ts
+function handleCloseEvent(deps, event) {
+  const { getState, setState, stopHeartbeat, logger, config, reconnectService, reconnect } = deps;
+  stopHeartbeat();
+  logger.info(`\u8FDE\u63A5\u5173\u95ED (code: ${event.code}, reason: ${event.reason})`);
+  if (event.code === 1e3) {
+    setState("disconnected" /* DISCONNECTED */);
+    return;
+  }
+  const state = getState();
+  if (state === "connected" /* CONNECTED */ || state === "reconnecting" /* RECONNECTING */ || state === "connecting" /* CONNECTING */) {
+    handleReconnect({
+      config,
+      logger,
+      reconnectService,
+      setState,
+      connect: reconnect
+    });
+  } else {
+    setState("disconnected" /* DISCONNECTED */);
+  }
+}
+
+// src/core/connection/handlers.ts
+import WebSocket from "isomorphic-ws";
+function attachWebSocketHandlers(ws, deps, resolve, reject) {
+  const { config, logger } = deps;
+  const timeoutMs = config.connection.timeout || 3e4;
+  const connectTimeout = setTimeout(() => {
+    if (ws && ws.readyState !== WebSocket.OPEN) {
+      logger.error(`\u8FDE\u63A5\u8D85\u65F6 (${timeoutMs}ms)`);
+      ws.close();
+      reject(new ConnectionError(`\u8FDE\u63A5\u8D85\u65F6 (${timeoutMs}ms)`));
+    }
+  }, timeoutMs);
+  ws.onopen = () => {
+    deps.clearConnectTimeout();
+    deps.setState("connected" /* CONNECTED */);
+    deps.resetReconnect();
+    deps.startHeartbeat();
+    deps.logger.info("WebSocket \u8FDE\u63A5\u5DF2\u5EFA\u7ACB");
+    resolve();
+  };
+  ws.onerror = (event) => {
+    deps.clearConnectTimeout();
+    const error = new ConnectionError("WebSocket \u9519\u8BEF", event);
+    deps.logger.error("\u8FDE\u63A5\u9519\u8BEF", error);
+    reject(error);
+  };
+  ws.onclose = (event) => {
+    deps.clearConnectTimeout();
+    deps.onClose(event);
+  };
+  ws.onmessage = (event) => {
+    try {
+      deps.recordPong();
+      deps.onMessage(event.data.toString());
+    } catch (error) {
+      deps.logger.error("\u6D88\u606F\u5904\u7406\u5931\u8D25", error);
+    }
+  };
+  return connectTimeout;
+}
+
+// src/core/connection/manager.ts
+var ConnectionManager = class {
+  constructor(config, logger, onMessage, onStateChange) {
+    this.config = config;
+    this.logger = logger;
+    this.onMessage = onMessage;
+    this.onStateChange = onStateChange;
+    this.reconnectService = new ReconnectService(config.reconnect, logger);
+  }
+  ws;
+  state = "disconnected" /* DISCONNECTED */;
+  reconnectService;
+  heartbeatService;
+  connectPromise;
+  connectTimeout;
+  /**
+   * 连接到WebSocket服务器
+   */
+  async connect() {
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.setState("connecting" /* CONNECTING */);
+    this.connectPromise = this.performConnect();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = void 0;
+    }
+  }
+  /**
+   * 执行实际的连接逻辑
+   */
+  performConnect() {
+    return new Promise((resolve, reject) => {
+      const url = buildWebSocketUrl(this.config);
+      this.logger.info(`\u8FDE\u63A5\u5230 ${url}`);
+      try {
+        this.ws = new WebSocket2(url);
+      } catch (error) {
+        const err = new ConnectionError("WebSocket \u521B\u5EFA\u5931\u8D25", error);
+        this.logger.error("\u8FDE\u63A5\u5931\u8D25", err);
+        reject(err);
+        return;
+      }
+      const timeoutHandle = attachWebSocketHandlers(
+        this.ws,
+        {
+          config: this.config,
+          logger: this.logger,
+          setState: (s) => this.setState(s),
+          resetReconnect: () => this.reconnectService.reset(),
+          startHeartbeat: () => {
+            this.heartbeatService = startHeartbeat({
+              config: this.config,
+              logger: this.logger,
+              send: (payload) => this.send(payload),
+              onTimeout: () => this.handleHeartbeatTimeout(),
+              createService: (interval, onPing, onTimeout, logger) => new HeartbeatService(interval, onPing, onTimeout, logger)
+            });
+          },
+          recordPong: () => this.heartbeatService?.recordPong(),
+          onMessage: (data) => this.onMessage(data),
+          onClose: (event) => handleCloseEvent({
+            getState: () => this.state,
+            setState: (s) => this.setState(s),
+            stopHeartbeat: () => this.stopHeartbeat(),
+            logger: this.logger,
+            config: this.config,
+            reconnectService: this.reconnectService,
+            reconnect: () => this.connect()
+          }, event),
+          clearConnectTimeout: () => this.clearConnectTimeout()
+        },
+        resolve,
+        reject
+      );
+      this.connectTimeout = timeoutHandle;
+    });
+  }
+  /**
+   * 断开连接
+   * @param code 关闭代码
+   * @param reason 关闭原因
+   */
+  disconnect(code = 1e3, reason = "\u6B63\u5E38\u5173\u95ED") {
+    this.logger.info(`\u65AD\u5F00\u8FDE\u63A5: ${reason}`);
+    this.reconnectService.cancel();
+    this.stopHeartbeat();
+    if (this.ws) {
+      try {
+        this.ws.close(code, reason);
+      } catch (error) {
+        this.logger.error("\u5173\u95ED\u8FDE\u63A5\u5931\u8D25", error);
+      }
+      this.ws = void 0;
+    }
+    this.setState("disconnected" /* DISCONNECTED */);
+  }
+  /**
+   * 发送数据
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
+      throw new ConnectionClosedError(
+        this.ws?.readyState || -1,
+        "\u8FDE\u63A5\u672A\u5EFA\u7ACB\u6216\u5DF2\u5173\u95ED"
+      );
+    }
+    this.ws.send(data);
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 检查是否已连接
+   */
+  isConnected() {
+    return this.state === "connected" /* CONNECTED */ && this.ws?.readyState === WebSocket2.OPEN;
+  }
+  /**
+   * 设置状态并通知
+   */
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.logger.debug(`\u72B6\u6001\u53D8\u66F4: ${state}`);
+      this.onStateChange(state);
+    }
+  }
+  /**
+   * 停止心跳
+   */
+  stopHeartbeat() {
+    if (this.heartbeatService) {
+      this.heartbeatService.stop();
+      this.heartbeatService = void 0;
+    }
+  }
+  /**
+   * 处理心跳超时
+   */
+  handleHeartbeatTimeout() {
+    this.logger.warn("\u5FC3\u8DF3\u8D85\u65F6\uFF0C\u4E3B\u52A8\u65AD\u5F00\u8FDE\u63A5");
+    this.disconnect(4e3, "\u5FC3\u8DF3\u8D85\u65F6");
+  }
+  /**
+   * 处理连接关闭并尝试重连
+   */
+  clearConnectTimeout() {
+    if (this.connectTimeout) {
+      clearTimeout(this.connectTimeout);
+      this.connectTimeout = void 0;
+    }
+  }
+};
+
+// src/core/api/request-builder.ts
+function buildRequestPayload(method, params, echo) {
+  return {
+    echo,
+    payload: JSON.stringify({
+      action: method,
+      params,
+      echo
+    })
+  };
+}
+
+// src/core/api/response-registry.ts
+var ResponseRegistry = class {
+  pending = /* @__PURE__ */ new Map();
+  add(echo, request, timeout) {
+    const timer = setTimeout(() => {
+      this.pending.delete(echo);
+      request.reject(new ApiTimeoutError(request.method, timeout));
+    }, timeout);
+    const entry = { ...request, timer };
+    this.pending.set(echo, entry);
+    return entry;
+  }
+  resolve(echo, data) {
+    const req = this.pending.get(echo);
+    if (!req) return false;
+    this.pending.delete(echo);
+    clearTimeout(req.timer);
+    req.resolve(data);
+    return true;
+  }
+  reject(echo, error) {
+    const req = this.pending.get(echo);
+    if (!req) return false;
+    this.pending.delete(echo);
+    clearTimeout(req.timer);
+    req.reject(error);
+    return true;
+  }
+  take(echo) {
+    const req = this.pending.get(echo);
+    if (req) {
+      this.pending.delete(echo);
+      clearTimeout(req.timer);
+    }
+    return req;
+  }
+  clearAll(reason) {
+    for (const [, req] of this.pending) {
+      clearTimeout(req.timer);
+      req.reject(new Error(reason));
+    }
+    this.pending.clear();
+  }
+  cleanupStale(now, maxAge, onTimeout) {
+    for (const [echo, req] of this.pending) {
+      if (now - req.createdAt > maxAge) {
+        onTimeout(req.method, echo);
+        this.reject(echo, new ApiTimeoutError(req.method, maxAge / 2));
+      }
+    }
+  }
+};
+
+// src/core/api/retry.ts
+async function withRetry(fn, retries, method, logger, delayFn) {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === retries) {
+        break;
+      }
+      if (error instanceof ApiTimeoutError || error instanceof ApiError) {
+        logger.warn(
+          `API\u8C03\u7528\u5931\u8D25\uFF0C\u91CD\u8BD5 ${attempt + 1}/${retries}: ${method}`,
+          error
+        );
+        await delayFn(Math.min(1e3 * (attempt + 1), 5e3));
+      } else {
+        throw error;
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/core/api-client.ts
+var ApiClient = class {
+  constructor(connection, config, logger) {
+    this.connection = connection;
+    this.config = config;
+    this.logger = logger;
+    this.startCleanupTimer();
+  }
+  registry = new ResponseRegistry();
+  cleanupTimer;
+  requestIdCounter = 0;
+  /**
+   * 调用API
+   * @param method API方法名
+   * @param params API参数
+   * @param options 调用选项
+   */
+  async call(method, params = {}, options) {
+    const timeout = options?.timeout ?? this.config.api.timeout;
+    const retries = options?.retries ?? this.config.api.retries;
+    return withRetry(
+      () => this.sendRequest(method, params, timeout),
+      retries,
+      method,
+      this.logger,
+      this.delay.bind(this)
+    );
+  }
+  /**
+   * 处理API响应
+   * 由连接管理器调用
+   */
+  handleResponse(echo, response) {
+    const request = this.registry.take(echo);
+    if (!request) {
+      this.logger.warn(`\u6536\u5230\u672A\u77E5\u8BF7\u6C42\u7684\u54CD\u5E94: ${echo}`);
+      return;
+    }
+    if (response.status === "ok" || response.retcode === 0) {
+      this.logger.debug(`API\u6210\u529F: ${request.method}`);
+      request.resolve(response.data);
+    } else {
+      this.logger.warn(`API\u5931\u8D25: ${request.method}`, {
+        retcode: response.retcode,
+        message: response.message
+      });
+      request.reject(
+        new ApiError(
+          request.method,
+          response.retcode,
+          response.message,
+          response.wording
+        )
+      );
+    }
+  }
+  /**
+   * 销毁API客户端
+   */
+  destroy() {
+    this.registry.clearAll("API\u5BA2\u6237\u7AEF\u5DF2\u9500\u6BC1");
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+  }
+  /**
+   * 发送API请求
+   */
+  sendRequest(method, params, timeout) {
+    return new Promise((resolve, reject) => {
+      const echo = this.generateRequestId();
+      this.logger.debug(`\u53D1\u9001API\u8BF7\u6C42: ${method}`, { echo, params });
+      this.registry.add(
+        echo,
+        {
+          resolve,
+          reject,
+          createdAt: Date.now(),
+          method
+        },
+        timeout
+      );
+      try {
+        if (!this.connection.isConnected()) {
+          throw new ConnectionClosedError(-1, "\u8FDE\u63A5\u672A\u5EFA\u7ACB\uFF0C\u8BF7\u5148\u8C03\u7528 connect()");
+        }
+        const { payload } = buildRequestPayload(method, params, echo);
+        this.connection.send(payload);
+      } catch (error) {
+        this.registry.reject(echo, error);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 延迟
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 生成请求ID
+   */
+  generateRequestId() {
+    return `naplink_${Date.now()}_${this.requestIdCounter++}`;
+  }
+  /**
+   * 启动清理定时器
+   * 定期清理超时的待处理请求
+   */
+  startCleanupTimer() {
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      const timeout = this.config.api.timeout;
+      this.registry.cleanupStale(now, timeout * 2, (method, echo) => {
+        this.logger.warn(`\u6E05\u7406\u8D85\u65F6\u8BF7\u6C42: ${method}`, { echo });
+      });
+    }, 6e4);
+  }
+};
+
+// src/core/event-router.ts
+import EventEmitter from "events";
+var EventRouter = class extends EventEmitter {
+  constructor(logger) {
+    super();
+    this.logger = logger;
+  }
+  anyListeners = [];
+  /**
+   * 监听所有事件
+   */
+  onAny(listener) {
+    this.anyListeners.push(listener);
+    return this;
+  }
+  /**
+   * 重写emit以支持onAny
+   */
+  emit(event, ...args) {
+    this.anyListeners.forEach((listener) => {
+      try {
+        listener(event, ...args);
+      } catch (error) {
+        this.logger.error("onAny listener error", error);
+      }
+    });
+    return super.emit(event, ...args);
+  }
+  /**
+   * 路由消息到相应的事件
+   * @param data 原始消息数据
+   */
+  route(data) {
+    try {
+      const postType = data.post_type;
+      if (!postType) {
+        this.logger.warn("\u6536\u5230\u65E0\u6548\u6D88\u606F: \u7F3A\u5C11 post_type", data);
+        return;
+      }
+      this.logger.debug(`\u8DEF\u7531\u4E8B\u4EF6: ${postType}`, {
+        messageType: data.message_type,
+        noticeType: data.notice_type
+      });
+      switch (postType) {
+        case "meta_event":
+          this.routeMetaEvent(data);
+          break;
+        case "message":
+          this.routeMessage(data);
+          break;
+        case "message_sent":
+          this.routeMessageSent(data);
+          break;
+        case "notice":
+          this.routeNotice(data);
+          break;
+        case "request":
+          this.routeRequest(data);
+          break;
+        default:
+          this.logger.warn(`\u672A\u77E5\u7684 post_type: ${postType}`);
+          this.emit("unknown", data);
+      }
+      this.emit("raw", data);
+    } catch (error) {
+      this.logger.error("\u4E8B\u4EF6\u8DEF\u7531\u5931\u8D25", error, data);
+    }
+  }
+  /**
+   * 路由元事件
+   */
+  routeMetaEvent(data) {
+    const type = data.meta_event_type;
+    const events = [`meta_event`, `meta_event.${type}`];
+    if (type === "lifecycle") {
+      events.push(`meta_event.lifecycle.${data.sub_type}`);
+    }
+    this.emitEvents(events, data);
+  }
+  /**
+   * 路由消息事件
+   */
+  routeMessage(data) {
+    const messageType = data.message_type;
+    const subType = data.sub_type;
+    const events = [
+      "message",
+      `message.${messageType}`,
+      `message.${messageType}.${subType}`
+    ];
+    this.emitEvents(events, data);
+  }
+  /**
+   * 路由发送消息事件
+   */
+  routeMessageSent(data) {
+    const messageType = data.message_type;
+    const subType = data.sub_type;
+    const events = [
+      "message_sent",
+      `message_sent.${messageType}`,
+      `message_sent.${messageType}.${subType}`
+    ];
+    this.emitEvents(events, data);
+  }
+  /**
+   * 路由通知事件
+   */
+  routeNotice(data) {
+    const noticeType = data.notice_type;
+    const subType = data.sub_type;
+    const events = ["notice", `notice.${noticeType}`];
+    if (subType) {
+      events.push(`notice.${noticeType}.${subType}`);
+    }
+    this.emitEvents(events, data);
+  }
+  /**
+   * 路由请求事件
+   */
+  routeRequest(data) {
+    const requestType = data.request_type;
+    const subType = data.sub_type;
+    const events = ["request", `request.${requestType}`];
+    if (subType) {
+      events.push(`request.${requestType}.${subType}`);
+    }
+    this.emitEvents(events, data);
+  }
+  /**
+   * 触发多个事件
+   */
+  emitEvents(events, data) {
+    for (const event of events) {
+      this.logger.debug(`\u89E6\u53D1\u4E8B\u4EF6: ${event}`);
+      this.emit(event, data);
+    }
+  }
+};
+
+// src/core/dispatcher.ts
+var MessageDispatcher = class {
+  constructor(apiClient, eventRouter, logger) {
+    this.apiClient = apiClient;
+    this.eventRouter = eventRouter;
+    this.logger = logger;
+  }
+  /**
+   * 分发消息
+   * @param message WebSocket 接收到的原始字符串消息
+   */
+  dispatch(message) {
+    try {
+      const data = JSON.parse(message);
+      if (data.echo) {
+        if (typeof data.echo === "string" && data.echo.startsWith("heartbeat_")) {
+          return;
+        }
+        this.apiClient.handleResponse(data.echo, data);
+      } else {
+        this.eventRouter.route(data);
+      }
+    } catch (error) {
+      this.logger.error("\u6D88\u606F\u89E3\u6790\u5931\u8D25", error, { message });
+    }
+  }
+};
+
+// src/core/connection/state-handler.ts
+function handleConnectionStateChange(emitter, state) {
+  emitter.emit("state_change", state);
+  switch (state) {
+    case "connected" /* CONNECTED */:
+      emitter.emit("connect");
+      break;
+    case "disconnected" /* DISCONNECTED */:
+      emitter.emit("disconnect");
+      break;
+    case "reconnecting" /* RECONNECTING */:
+      emitter.emit("reconnecting");
+      break;
+  }
+}
+
+// src/api/onebot/message.ts
+function createMessageApi(client) {
+  return {
+    sendMessage(params) {
+      return client.call("send_msg", params);
+    },
+    sendPrivateMessage(userId, message) {
+      return client.call("send_private_msg", { user_id: userId, message });
+    },
+    sendGroupMessage(groupId, message) {
+      return client.call("send_group_msg", { group_id: groupId, message });
+    },
+    deleteMessage(messageId) {
+      return client.call("delete_msg", { message_id: messageId });
+    },
+    getMessage(messageId) {
+      return client.call("get_msg", { message_id: messageId });
+    },
+    getForwardMessage(id) {
+      return client.call("get_forward_msg", { id });
+    },
+    sendGroupForwardMessage(groupId, messages) {
+      return client.call("send_group_forward_msg", { group_id: groupId, messages });
+    },
+    setEssenceMessage(messageId) {
+      return client.call("set_essence_msg", { message_id: messageId });
+    },
+    deleteEssenceMessage(messageId) {
+      return client.call("delete_essence_msg", { message_id: messageId });
+    },
+    getEssenceMessageList(groupId) {
+      return client.call("get_essence_msg_list", { group_id: groupId });
+    },
+    markMessageAsRead(messageId) {
+      return client.call("mark_msg_as_read", { message_id: messageId });
+    },
+    getGroupAtAllRemain(groupId) {
+      return client.call("get_group_at_all_remain", { group_id: groupId });
+    },
+    getGroupSystemMsg() {
+      return client.call("get_group_system_msg");
+    },
+    getGroupHonorInfo(groupId, type) {
+      return client.call("get_group_honor_info", { group_id: groupId, type });
+    }
+  };
+}
+
+// src/api/onebot/media.ts
+function createMediaApi(client, logger) {
+  const api = {
+    getImage(file) {
+      return client.call("get_image", { file });
+    },
+    getRecord(file, outFormat) {
+      return client.call("get_record", { file, out_format: outFormat });
+    },
+    getFile(file) {
+      return client.call("get_file", { file });
+    },
+    async hydrateMedia(message) {
+      if (!Array.isArray(message)) return;
+      await Promise.all(message.map(async (segment) => {
+        const type = segment?.type;
+        const data = segment?.data;
+        if (!type || !data) return;
+        if (["image", "video", "record", "audio", "file"].includes(type)) {
+          const fileId = data.file;
+          if (typeof fileId === "string" && !/^https?:\/\//.test(fileId) && !fileId.startsWith("file://")) {
+            try {
+              const res = await api.getFile(fileId);
+              if (res?.file) {
+                data.url = res.file;
+                data.file = res.file;
+                return;
+              }
+              if (type === "record" || type === "audio") {
+                const rec = await api.getRecord(fileId, "mp3");
+                if (rec?.file) {
+                  data.url = rec.file;
+                  data.file = rec.file;
+                }
+              } else if (type === "image") {
+                const img = await api.getImage(fileId);
+                if (img?.file) {
+                  data.url = img.file;
+                  data.file = img.file;
+                }
+              }
+            } catch (e) {
+              logger.debug(`Failed to hydrate media for ${type}: ${fileId}`, e);
+            }
+          }
+        }
+      }));
+    }
+  };
+  return api;
+}
+
+// src/api/onebot/account.ts
+function createAccountApi(client) {
+  return {
+    getLoginInfo() {
+      return client.call("get_login_info");
+    },
+    getStatus() {
+      return client.call("get_status");
+    },
+    getFriendList() {
+      return client.call("get_friend_list");
+    },
+    getGroupList() {
+      return client.call("get_group_list");
+    },
+    getGroupInfo(groupId, noCache = false) {
+      return client.call("get_group_info", { group_id: groupId, no_cache: noCache });
+    },
+    getGroupMemberList(groupId) {
+      return client.call("get_group_member_list", { group_id: groupId });
+    },
+    getGroupMemberInfo(groupId, userId, noCache = false) {
+      return client.call("get_group_member_info", {
+        group_id: groupId,
+        user_id: userId,
+        no_cache: noCache
+      });
+    },
+    getStrangerInfo(userId, noCache = false) {
+      return client.call("get_stranger_info", { user_id: userId, no_cache: noCache });
+    },
+    getVersionInfo() {
+      return client.call("get_version_info");
+    }
+  };
+}
+
+// src/api/onebot/group.ts
+function createGroupApi(client) {
+  return {
+    setGroupBan(groupId, userId, duration = 30 * 60) {
+      return client.call("set_group_ban", { group_id: groupId, user_id: userId, duration });
+    },
+    unsetGroupBan(groupId, userId) {
+      return client.call("set_group_ban", { group_id: groupId, user_id: userId, duration: 0 });
+    },
+    setGroupWholeBan(groupId, enable = true) {
+      return client.call("set_group_whole_ban", { group_id: groupId, enable });
+    },
+    setGroupKick(groupId, userId, rejectAddRequest = false) {
+      return client.call("set_group_kick", {
+        group_id: groupId,
+        user_id: userId,
+        reject_add_request: rejectAddRequest
+      });
+    },
+    setGroupLeave(groupId, isDismiss = false) {
+      return client.call("set_group_leave", { group_id: groupId, is_dismiss: isDismiss });
+    },
+    setGroupCard(groupId, userId, card) {
+      return client.call("set_group_card", { group_id: groupId, user_id: userId, card });
+    },
+    setGroupName(groupId, groupName) {
+      return client.call("set_group_name", { group_id: groupId, group_name: groupName });
+    },
+    setGroupAdmin(groupId, userId, enable = true) {
+      return client.call("set_group_admin", { group_id: groupId, user_id: userId, enable });
+    },
+    setGroupAnonymousBan(groupId, anonymousFlag, duration = 30 * 60) {
+      return client.call("set_group_anonymous_ban", {
+        group_id: groupId,
+        anonymous_flag: anonymousFlag,
+        duration
+      });
+    },
+    setGroupSpecialTitle(groupId, userId, specialTitle, duration = -1) {
+      return client.call("set_group_special_title", {
+        group_id: groupId,
+        user_id: userId,
+        special_title: specialTitle,
+        duration
+      });
+    },
+    sendLike(userId, times = 1) {
+      return client.call("send_like", { user_id: userId, times });
+    }
+  };
+}
+
+// src/api/onebot/files.ts
+import { promises as fs, createWriteStream } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { pipeline } from "stream/promises";
+function createFileApi(client) {
+  const normalizeFileInput = async (file, name) => {
+    if (typeof file === "string") return file;
+    const tempPath = join(tmpdir(), `${randomUUID()}-${name || "naplink.tmp"}`);
+    if (file instanceof Buffer || file instanceof Uint8Array) {
+      await fs.writeFile(tempPath, file);
+      return tempPath;
+    }
+    await pipeline(file, createWriteStream(tempPath));
+    return tempPath;
+  };
+  return {
+    async uploadGroupFile(groupId, file, name) {
+      const normalized = await normalizeFileInput(file, name);
+      return client.call("upload_group_file", { group_id: groupId, file: normalized, name });
+    },
+    async uploadPrivateFile(userId, file, name) {
+      const normalized = await normalizeFileInput(file, name);
+      return client.call("upload_private_file", { user_id: userId, file: normalized, name });
+    },
+    async setGroupPortrait(groupId, file) {
+      return this.uploadGroupFile(groupId, file, "portrait");
+    },
+    getGroupFileSystemInfo(groupId) {
+      return client.call("get_group_file_system_info", { group_id: groupId });
+    },
+    getGroupRootFiles(groupId) {
+      return client.call("get_group_root_files", { group_id: groupId });
+    },
+    getGroupFilesByFolder(groupId, folderId) {
+      return client.call("get_group_files_by_folder", { group_id: groupId, folder_id: folderId });
+    },
+    getGroupFileUrl(groupId, fileId, busid) {
+      return client.call("get_group_file_url", { group_id: groupId, file_id: fileId, busid });
+    },
+    deleteGroupFile(groupId, fileId, busid) {
+      return client.call("delete_group_file", { group_id: groupId, file_id: fileId, busid });
+    },
+    createGroupFileFolder(groupId, name, parentId) {
+      return client.call("create_group_file_folder", { group_id: groupId, name, parent_id: parentId });
+    },
+    deleteGroupFolder(groupId, folderId) {
+      return client.call("delete_group_folder", { group_id: groupId, folder_id: folderId });
+    },
+    downloadFile(url, threadCount = 3, headers) {
+      return client.call("download_file", { url, thread_count: threadCount, headers });
+    }
+  };
+}
+
+// src/api/onebot/stream.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/core/upload/stream.ts
+import { promises as fs2, createWriteStream as createWriteStream2, createReadStream } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2, basename } from "path";
+import { randomUUID as randomUUID2, createHash } from "crypto";
+import { pipeline as pipeline2 } from "stream/promises";
+async function prepareStreamSource(file, overrideName) {
+  if (typeof file === "string") {
+    const stats2 = await fs2.stat(file);
+    return { source: file, size: stats2.size, filename: overrideName || basename(file) };
+  }
+  if (file instanceof Buffer || file instanceof Uint8Array) {
+    return { source: Buffer.from(file), size: file.length, filename: overrideName || "upload.bin" };
+  }
+  const tempPath = join2(tmpdir2(), `${randomUUID2()}-upload.tmp`);
+  await pipeline2(file, createWriteStream2(tempPath));
+  const stats = await fs2.stat(tempPath);
+  return {
+    source: tempPath,
+    size: stats.size,
+    filename: overrideName || basename(tempPath),
+    cleanupTemp: async () => {
+      try {
+        await fs2.unlink(tempPath);
+      } catch {
+      }
+    }
+  };
+}
+async function* iterateChunks(source, size, chunkSize) {
+  if (typeof source === "string") {
+    const stream = createReadStream(source, { highWaterMark: chunkSize });
+    for await (const chunk of stream) {
+      yield chunk;
+    }
+  } else {
+    let offset = 0;
+    while (offset < size) {
+      const end = Math.min(offset + chunkSize, size);
+      yield source.slice(offset, end);
+      offset = end;
+    }
+  }
+}
+async function computeSha256(source) {
+  const hash = createHash("sha256");
+  if (typeof source === "string") {
+    const stream = createReadStream(source);
+    for await (const chunk of stream) {
+      hash.update(chunk);
+    }
+  } else {
+    hash.update(source);
+  }
+  return hash.digest("hex");
+}
+
+// src/api/onebot/stream.ts
+function createStreamApi(client) {
+  return {
+    async uploadFileStream(file, options) {
+      const chunkSize = options?.chunkSize ?? 256 * 1024;
+      const streamId = options?.streamId ?? randomUUID3();
+      const { source, size, filename, cleanupTemp } = await prepareStreamSource(file, options?.filename);
+      const expectedSha256 = options?.expectedSha256 ?? await computeSha256(source);
+      const totalChunks = Math.ceil(size / chunkSize);
+      if (options?.reset) {
+        await client.call("upload_file_stream", { stream_id: streamId, reset: true });
+      }
+      let chunkIndex = 0;
+      for await (const chunk of iterateChunks(source, size, chunkSize)) {
+        const payload = {
+          stream_id: streamId,
+          chunk_data: chunk.toString("base64"),
+          chunk_index: chunkIndex,
+          total_chunks: totalChunks,
+          file_size: size,
+          expected_sha256: expectedSha256,
+          filename
+        };
+        if (options?.fileRetention != null) {
+          payload.file_retention = options.fileRetention;
+        }
+        if (options?.verifyOnly) {
+          payload.verify_only = true;
+        }
+        await client.call("upload_file_stream", payload);
+        chunkIndex++;
+      }
+      const completion = await client.call("upload_file_stream", {
+        stream_id: streamId,
+        is_complete: true
+      });
+      await cleanupTemp?.();
+      return completion;
+    },
+    getUploadStreamStatus(streamId) {
+      return client.call("upload_file_stream", { stream_id: streamId });
+    }
+  };
+}
+
+// src/api/onebot/requests.ts
+function createRequestApi(client) {
+  return {
+    handleFriendRequest(flag, approve = true, remark) {
+      return client.call("set_friend_add_request", { flag, approve, remark });
+    },
+    handleGroupRequest(flag, subType, approve = true, reason) {
+      return client.call("set_group_add_request", { flag, sub_type: subType, approve, reason });
+    }
+  };
+}
+
+// src/api/onebot/index.ts
+var OneBotApi = class {
+  messageApi;
+  mediaApi;
+  accountApi;
+  groupApi;
+  fileApi;
+  streamApi;
+  requestApi;
+  constructor(client, logger) {
+    this.messageApi = createMessageApi(client);
+    this.mediaApi = createMediaApi(client, logger);
+    this.accountApi = createAccountApi(client);
+    this.groupApi = createGroupApi(client);
+    this.fileApi = createFileApi(client);
+    this.streamApi = createStreamApi(client);
+    this.requestApi = createRequestApi(client);
+    Object.assign(
+      this,
+      this.messageApi,
+      this.mediaApi,
+      this.accountApi,
+      this.groupApi,
+      this.fileApi,
+      this.streamApi,
+      this.requestApi
+    );
+  }
+};
+
+// src/api/delegates.ts
+function bindOneBotApiMethods(api, target) {
+  const bindings = {
+    getLoginInfo: () => api.getLoginInfo(),
+    getStatus: () => api.getStatus(),
+    sendMessage: (params) => api.sendMessage(params),
+    sendPrivateMessage: (userId, message) => api.sendPrivateMessage(userId, message),
+    sendGroupMessage: (groupId, message) => api.sendGroupMessage(groupId, message),
+    deleteMessage: (messageId) => api.deleteMessage(messageId),
+    getMessage: (messageId) => api.getMessage(messageId),
+    getForwardMessage: (id) => api.getForwardMessage(id),
+    getEssenceMessageList: (groupId) => api.getEssenceMessageList(groupId),
+    markMessageAsRead: (messageId) => api.markMessageAsRead(messageId),
+    getGroupAtAllRemain: (groupId) => api.getGroupAtAllRemain(groupId),
+    getGroupSystemMsg: () => api.getGroupSystemMsg(),
+    getGroupHonorInfo: (groupId, type) => api.getGroupHonorInfo(groupId, type),
+    getGroupFileSystemInfo: (groupId) => api.getGroupFileSystemInfo(groupId),
+    getGroupRootFiles: (groupId) => api.getGroupRootFiles(groupId),
+    getGroupFilesByFolder: (groupId, folderId) => api.getGroupFilesByFolder(groupId, folderId),
+    getGroupFileUrl: (groupId, fileId, busid) => api.getGroupFileUrl(groupId, fileId, busid),
+    deleteGroupFile: (groupId, fileId, busid) => api.deleteGroupFile(groupId, fileId, busid),
+    createGroupFileFolder: (groupId, name, parentId) => api.createGroupFileFolder(groupId, name, parentId),
+    deleteGroupFolder: (groupId, folderId) => api.deleteGroupFolder(groupId, folderId),
+    downloadFile: (url, threadCount, headers) => api.downloadFile(url, threadCount, headers),
+    uploadFileStream: (file, options) => api.uploadFileStream(file, options),
+    getUploadStreamStatus: (streamId) => api.getUploadStreamStatus(streamId),
+    sendGroupForwardMessage: (groupId, messages) => api.sendGroupForwardMessage(groupId, messages),
+    getImage: (file) => api.getImage(file),
+    getRecord: (file, outFormat) => api.getRecord(file, outFormat),
+    getFile: (file) => api.getFile(file),
+    getFriendList: () => api.getFriendList(),
+    getGroupList: () => api.getGroupList(),
+    getGroupInfo: (groupId, noCache = false) => api.getGroupInfo(groupId, noCache),
+    getGroupMemberList: (groupId) => api.getGroupMemberList(groupId),
+    getGroupMemberInfo: (groupId, userId, noCache = false) => api.getGroupMemberInfo(groupId, userId, noCache),
+    setGroupBan: (groupId, userId, duration = 30 * 60) => api.setGroupBan(groupId, userId, duration),
+    unsetGroupBan: (groupId, userId) => api.unsetGroupBan(groupId, userId),
+    setGroupWholeBan: (groupId, enable = true) => api.setGroupWholeBan(groupId, enable),
+    setGroupKick: (groupId, userId, rejectAddRequest = false) => api.setGroupKick(groupId, userId, rejectAddRequest),
+    setGroupLeave: (groupId, isDismiss = false) => api.setGroupLeave(groupId, isDismiss),
+    setGroupCard: (groupId, userId, card) => api.setGroupCard(groupId, userId, card),
+    setGroupName: (groupId, groupName) => api.setGroupName(groupId, groupName),
+    setGroupPortrait: (groupId, file) => api.setGroupPortrait(groupId, file),
+    setGroupAdmin: (groupId, userId, enable = true) => api.setGroupAdmin(groupId, userId, enable),
+    setGroupAnonymousBan: (groupId, anonymousFlag, duration = 30 * 60) => api.setGroupAnonymousBan(groupId, anonymousFlag, duration),
+    setEssenceMessage: (messageId) => api.setEssenceMessage(messageId),
+    deleteEssenceMessage: (messageId) => api.deleteEssenceMessage(messageId),
+    setGroupSpecialTitle: (groupId, userId, specialTitle, duration = -1) => api.setGroupSpecialTitle(groupId, userId, specialTitle, duration),
+    sendLike: (userId, times = 1) => api.sendLike(userId, times),
+    uploadGroupFile: (groupId, file, name) => api.uploadGroupFile(groupId, file, name),
+    uploadPrivateFile: (userId, file, name) => api.uploadPrivateFile(userId, file, name),
+    getStrangerInfo: (userId, noCache = false) => api.getStrangerInfo(userId, noCache),
+    getVersionInfo: () => api.getVersionInfo(),
+    handleFriendRequest: (flag, approve = true, remark) => api.handleFriendRequest(flag, approve, remark),
+    handleGroupRequest: (flag, subType, approve = true, reason) => api.handleGroupRequest(flag, subType, approve, reason)
+  };
+  Object.assign(target, bindings);
+}
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  reconnect: {
+    enabled: true,
+    maxAttempts: 10,
+    backoff: {
+      initial: 1e3,
+      max: 6e4,
+      multiplier: 2
+    }
+  },
+  logging: {
+    level: "info"
+  },
+  api: {
+    timeout: 3e4,
+    retries: 3
+  }
+};
+
+// src/utils/merge-config.ts
+function mergeConfig(userConfig) {
+  if (!userConfig.connection?.url) {
+    throw new InvalidConfigError("connection.url", "\u5FC5\u987B\u63D0\u4F9B\u8FDE\u63A5URL");
+  }
+  return {
+    connection: {
+      url: userConfig.connection.url,
+      token: userConfig.connection.token,
+      timeout: userConfig.connection.timeout ?? 3e4,
+      pingInterval: userConfig.connection.pingInterval ?? 3e4,
+      heartbeatAction: userConfig.connection.heartbeatAction ?? {
+        action: "get_status",
+        params: {}
+      }
+    },
+    reconnect: {
+      enabled: userConfig.reconnect?.enabled ?? DEFAULT_CONFIG.reconnect.enabled,
+      maxAttempts: userConfig.reconnect?.maxAttempts ?? DEFAULT_CONFIG.reconnect.maxAttempts,
+      backoff: {
+        initial: userConfig.reconnect?.backoff?.initial ?? DEFAULT_CONFIG.reconnect.backoff.initial,
+        max: userConfig.reconnect?.backoff?.max ?? DEFAULT_CONFIG.reconnect.backoff.max,
+        multiplier: userConfig.reconnect?.backoff?.multiplier ?? DEFAULT_CONFIG.reconnect.backoff.multiplier
+      }
+    },
+    logging: {
+      level: userConfig.logging?.level ?? DEFAULT_CONFIG.logging.level,
+      logger: userConfig.logging?.logger
+    },
+    api: {
+      timeout: userConfig.api?.timeout ?? DEFAULT_CONFIG.api.timeout,
+      retries: userConfig.api?.retries ?? DEFAULT_CONFIG.api.retries
+    }
+  };
+}
+
+// src/naplink.ts
+var NapLink = class extends EventEmitter2 {
+  config;
+  logger;
+  connection;
+  apiClient;
+  eventRouter;
+  dispatcher;
+  oneBotApi;
+  constructor(config) {
+    super();
+    this.config = mergeConfig(config);
+    this.logger = this.config.logging.logger || new DefaultLogger(this.config.logging.level);
+    this.eventRouter = new EventRouter(this.logger);
+    this.setupEventForwarding();
+    this.connection = new ConnectionManager(
+      this.config,
+      this.logger,
+      (message) => this.dispatcher.dispatch(message),
+      (state) => handleConnectionStateChange(this, state)
+    );
+    this.apiClient = new ApiClient(this.connection, this.config, this.logger);
+    this.dispatcher = new MessageDispatcher(this.apiClient, this.eventRouter, this.logger);
+    this.oneBotApi = new OneBotApi(this.apiClient, this.logger);
+    bindOneBotApiMethods(this.oneBotApi, this);
+    this.logger.info("NapLink \u5BA2\u6237\u7AEF\u5DF2\u521D\u59CB\u5316");
+  }
+  /**
+   * 连接到NapCat服务器
+   */
+  async connect() {
+    this.logger.info("\u5F00\u59CB\u8FDE\u63A5...");
+    await this.connection.connect();
+  }
+  /**
+   * 断开连接
+   */
+  disconnect() {
+    this.logger.info("\u65AD\u5F00\u8FDE\u63A5...");
+    this.connection.disconnect();
+    this.apiClient.destroy();
+  }
+  /**
+   * 获取连接状态
+   */
+  getState() {
+    return this.connection.getState();
+  }
+  /**
+   * 检查是否已连接
+   */
+  isConnected() {
+    return this.connection.isConnected();
+  }
+  /**
+   * 补充消息中的媒体直链
+   * 自动通过 get_file / get_image / get_record 获取真实下载链接
+   */
+  async hydrateMessage(message) {
+    return this.api.hydrateMedia(message);
+  }
+  /**
+   * 调用自定义API
+   */
+  async callApi(method, params = {}) {
+    return this.apiClient.call(method, params);
+  }
+  /**
+   * 暴露 OneBot API 便于直接使用
+   */
+  get api() {
+    return this.oneBotApi;
+  }
+  // ============ 内部方法 ============
+  /**
+   * 设置事件转发
+   */
+  setupEventForwarding() {
+    this.eventRouter.onAny((event, data) => {
+      this.emit(event, data);
+    });
+  }
+};
+export {
+  ApiError,
+  ApiTimeoutError,
+  ConnectionClosedError,
+  ConnectionError,
+  ConnectionState,
+  InvalidConfigError,
+  MaxReconnectAttemptsError,
+  NapLink,
+  NapLinkError,
+  OneBotApi,
+  NapLink as default
+};
+//# sourceMappingURL=index.js.map