@maoyugames/phaser-framework 1.0.0

package/dist/index.js

@@ -0,0 +1,3790 @@
+import { PlatformUnsupportedError } from './chunk-II3JM4R3.js';
+export { PlatformUnsupportedError } from './chunk-II3JM4R3.js';
+import { __publicField } from './chunk-PKBMQBKP.js';
+import Phaser4 from 'phaser';
+
+// src/App.ts
+var parts = null;
+function require2(key) {
+  if (!parts) {
+    throw new Error(
+      `[App] \u8BBF\u95EE App.${String(key)} \u5931\u8D25:App \u5C1A\u672A\u521D\u59CB\u5316\u3002\u8BF7\u786E\u8BA4\u5DF2\u901A\u8FC7 startGame()(@maoyugames/phaser-framework \u7684 startGame)\u542F\u52A8,\u4E1A\u52A1\u4EE3\u7801\u4E0D\u8981\u5728 bootstrap \u5B8C\u6210\u524D\u8BBF\u95EE App\u3002`
+    );
+  }
+  return parts[key];
+}
+var App = {
+  get platform() {
+    return require2("platform");
+  },
+  get net() {
+    return require2("net");
+  },
+  get events() {
+    return require2("events");
+  },
+  get log() {
+    return require2("log");
+  },
+  get config() {
+    return require2("config");
+  },
+  get audio() {
+    return require2("audio");
+  },
+  get storage() {
+    return require2("storage");
+  },
+  get assets() {
+    return require2("assets");
+  },
+  get ads() {
+    return require2("ads");
+  },
+  get payment() {
+    return require2("payment");
+  },
+  get analytics() {
+    return require2("analytics");
+  },
+  get account() {
+    return require2("account");
+  },
+  get scenes() {
+    return require2("scenes");
+  },
+  get i18n() {
+    return require2("i18n");
+  },
+  get save() {
+    return require2("save");
+  },
+  get tables() {
+    return require2("tables");
+  },
+  get panels() {
+    return require2("panels");
+  },
+  get modules() {
+    return require2("modules");
+  },
+  get lifecycle() {
+    return require2("lifecycle");
+  }
+};
+function __initApp(injected) {
+  if (parts) {
+    console.warn("[App] \u5DF2\u521D\u59CB\u5316,\u91CD\u590D __initApp \u88AB\u5FFD\u7565");
+    return;
+  }
+  parts = injected;
+}
+
+// src/platform/PlatformContext.ts
+var _current = null;
+var PlatformContext = {
+  /** 注入当前平台实现(仅 bootstrap 调用一次) */
+  set(platform) {
+    if (_current) {
+      console.warn("[PlatformContext] \u5E73\u53F0\u5DF2\u521D\u59CB\u5316,\u91CD\u590D\u6CE8\u5165\u5C06\u88AB\u5FFD\u7565");
+      return;
+    }
+    _current = platform;
+  },
+  /** 当前平台实现 */
+  get current() {
+    if (!_current) {
+      throw new Error(
+        "[PlatformContext] \u5E73\u53F0\u5C1A\u672A\u521D\u59CB\u5316\u3002\u8BF7\u786E\u8BA4\u901A\u8FC7 startGame() \u542F\u52A8,\u4E14\u5E73\u53F0\u5165\u53E3\u5DF2\u6CE8\u5165\u5E73\u53F0\u5B9E\u73B0\u3002"
+      );
+    }
+    return _current;
+  },
+  /** 是否已初始化 */
+  get ready() {
+    return _current !== null;
+  },
+  /** 仅供测试重置 */
+  _resetForTest() {
+    _current = null;
+  }
+};
+
+// src/net/HttpClient.ts
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "PUT",
+  "DELETE"
+]);
+var HttpClient = class {
+  constructor(config = {}) {
+    __publicField(this, "baseURL");
+    __publicField(this, "headers");
+    __publicField(this, "timeout");
+    __publicField(this, "retries");
+    /** 拦截器按 use 顺序累积;请求拦截顺序执行,响应拦截顺序执行 */
+    __publicField(this, "requestInterceptors", []);
+    __publicField(this, "responseInterceptors", []);
+    __publicField(this, "errorInterceptors", []);
+    this.baseURL = config.baseURL ?? "";
+    this.headers = { ...config.headers ?? {} };
+    this.timeout = config.timeout ?? 0;
+    this.retries = config.retries ?? 0;
+  }
+  /** 设置 / 覆盖一个默认请求头(作用于后续所有请求) */
+  setHeader(key, value) {
+    this.headers[key] = value;
+  }
+  /** 注册拦截器,可链式多次调用累积 */
+  use(interceptors) {
+    if (interceptors.request) this.requestInterceptors.push(interceptors.request);
+    if (interceptors.response) this.responseInterceptors.push(interceptors.response);
+    if (interceptors.error) this.errorInterceptors.push(interceptors.error);
+  }
+  /** 核心请求方法:拼 URL、合并 header、跑拦截器、超时、重试、解析返回 */
+  async request(options) {
+    let opts = {
+      ...options,
+      url: this.resolveUrl(options.url),
+      method: options.method ?? "GET",
+      headers: { ...this.headers, ...options.headers ?? {} },
+      responseType: options.responseType ?? "json",
+      timeout: options.timeout ?? this.timeout
+    };
+    for (const interceptor of this.requestInterceptors) {
+      opts = await interceptor(opts);
+    }
+    const method = opts.method ?? "GET";
+    const canRetry = IDEMPOTENT_METHODS.has(method);
+    const maxAttempts = canRetry ? this.retries + 1 : 1;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const response = await this.sendOnce(opts);
+        if (!response.ok) {
+          throw new HttpError(
+            `HTTP ${response.status}`,
+            response.status,
+            response.data
+          );
+        }
+        let data = response.data;
+        for (const interceptor of this.responseInterceptors) {
+          data = await interceptor(data, response.status);
+        }
+        return data;
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+        if (attempt < maxAttempts - 1 && isRetryableError(lastError)) {
+          await delay(this.backoffMs(attempt));
+          continue;
+        }
+        break;
+      }
+    }
+    const finalError = lastError ?? new Error("HTTP \u8BF7\u6C42\u5931\u8D25(\u672A\u77E5\u539F\u56E0)");
+    for (const interceptor of this.errorInterceptors) {
+      try {
+        interceptor(finalError);
+      } catch {
+      }
+    }
+    throw finalError;
+  }
+  get(url, options = {}) {
+    return this.request({ ...options, url, method: "GET" });
+  }
+  post(url, body, options = {}) {
+    return this.request({ ...options, url, method: "POST", body });
+  }
+  put(url, body, options = {}) {
+    return this.request({ ...options, url, method: "PUT", body });
+  }
+  delete(url, options = {}) {
+    return this.request({ ...options, url, method: "DELETE" });
+  }
+  /** 发一次底层请求(经平台层),不含重试 / 拦截器 */
+  async sendOnce(opts) {
+    return PlatformContext.current.net.request(opts);
+  }
+  /** baseURL + path 拼接:绝对 URL 原样返回,相对 path 拼基址(处理斜杠) */
+  resolveUrl(url) {
+    if (/^https?:\/\//i.test(url)) return url;
+    if (!this.baseURL) return url;
+    const base = this.baseURL.replace(/\/+$/, "");
+    const path = url.replace(/^\/+/, "");
+    return path ? `${base}/${path}` : base;
+  }
+  /** 第 attempt 次失败后的退避时长:base 100ms 指数增长,封顶 5s */
+  backoffMs(attempt) {
+    return Math.min(100 * Math.pow(2, attempt), 5e3);
+  }
+};
+var HttpError = class extends Error {
+  constructor(message, status, data) {
+    super(message);
+    __publicField(this, "status", status);
+    __publicField(this, "data", data);
+    this.name = "HttpError";
+  }
+};
+function isRetryableError(error) {
+  if (error.name === "AbortError") return false;
+  if (error instanceof HttpError) {
+    return error.status >= 500 && error.status < 600;
+  }
+  return true;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/net/reconnect.ts
+var Reconnector = class {
+  constructor(options) {
+    __publicField(this, "opts");
+    /** 已尝试的重连次数(用于退避指数与上限判断) */
+    __publicField(this, "attempts", 0);
+    /** 当前挂起的定时器 */
+    __publicField(this, "timer", null);
+    /** 是否已被取消(取消后所有 schedule 都无效) */
+    __publicField(this, "cancelled", false);
+    this.opts = {
+      autoReconnect: options.autoReconnect,
+      maxReconnect: options.maxReconnect,
+      baseIntervalMs: options.baseIntervalMs,
+      maxIntervalMs: options.maxIntervalMs ?? 3e4,
+      attempt: options.attempt,
+      onScheduled: options.onScheduled,
+      onGiveUp: options.onGiveUp
+    };
+  }
+  /** 连接成功后调用:清零计数,使下次断线从最短间隔重连 */
+  reset() {
+    this.attempts = 0;
+  }
+  /**
+   * 安排下一次重连。
+   * 若未启用自动重连、已取消、或已达到最大次数,则不再重连。
+   */
+  schedule() {
+    if (this.cancelled || !this.opts.autoReconnect) return;
+    if (this.attempts >= this.opts.maxReconnect) {
+      this.opts.onGiveUp?.();
+      return;
+    }
+    if (this.timer !== null) return;
+    const index = this.attempts;
+    const delay2 = this.computeDelay(index);
+    this.opts.onScheduled?.(index, delay2);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      if (this.cancelled) return;
+      this.attempts += 1;
+      this.opts.attempt().catch(() => {
+        if (!this.cancelled) this.schedule();
+      });
+    }, delay2);
+  }
+  /** 取消挂起的重连并永久禁用(主动关闭 / 销毁时调用) */
+  cancel() {
+    this.cancelled = true;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /** 重新启用(主动关闭后又想复用同一实例时;通常配合 reset) */
+  revive() {
+    this.cancelled = false;
+    this.attempts = 0;
+  }
+  /** 计算第 index 次重连的退避间隔 */
+  computeDelay(index) {
+    const raw = this.opts.baseIntervalMs * Math.pow(2, index);
+    return Math.min(raw, this.opts.maxIntervalMs);
+  }
+};
+
+// src/net/WebSocketClient.ts
+var WebSocketClient = class {
+  constructor(config) {
+    __publicField(this, "url");
+    __publicField(this, "heartbeatIntervalMs");
+    __publicField(this, "heartbeatPayload");
+    __publicField(this, "socket", null);
+    __publicField(this, "_state", "closed");
+    /** 当前底层 socket 上注册的取消订阅句柄,断开时统一清理 */
+    __publicField(this, "socketUnsubs", []);
+    /** 心跳定时器 */
+    __publicField(this, "heartbeatTimer", null);
+    /** 是否为主动关闭(主动关闭不重连) */
+    __publicField(this, "manualClose", false);
+    /** 当前 connect() 的 resolve/reject(用于把首次连接结果回传给调用方) */
+    __publicField(this, "pendingConnect", null);
+    __publicField(this, "reconnector");
+    // 业务侧事件监听集合
+    __publicField(this, "openListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "messageListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "errorListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "closeListeners", /* @__PURE__ */ new Set());
+    this.url = config.url;
+    this.heartbeatIntervalMs = config.heartbeatIntervalMs ?? 0;
+    this.heartbeatPayload = config.heartbeatPayload ?? "ping";
+    this.reconnector = new Reconnector({
+      autoReconnect: config.autoReconnect ?? true,
+      maxReconnect: config.maxReconnect ?? Infinity,
+      baseIntervalMs: config.reconnectIntervalMs ?? 1e3,
+      // 重连尝试:重新打开底层 socket;成功(open)由事件回调触发 reset
+      attempt: () => this.openSocket()
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  /** 建立连接:open 时 resolve,失败时 reject。重连由内部自动处理。 */
+  connect() {
+    if (this._state === "open") return Promise.resolve();
+    this.manualClose = false;
+    this.reconnector.revive();
+    return new Promise((resolve, reject) => {
+      this.pendingConnect = { resolve, reject };
+      this.openSocket().catch((e) => {
+        if (this.pendingConnect) {
+          this.pendingConnect.reject(e instanceof Error ? e : new Error(String(e)));
+          this.pendingConnect = null;
+        }
+        if (!this.manualClose) this.reconnector.schedule();
+      });
+    });
+  }
+  send(data) {
+    if (this._state !== "open" || !this.socket) {
+      throw new Error("[WebSocketClient] \u8FDE\u63A5\u672A\u5C31\u7EEA,\u65E0\u6CD5\u53D1\u9001");
+    }
+    this.socket.send(data);
+  }
+  /** 主动关闭:停心跳、取消重连、关闭底层 socket */
+  close() {
+    this.manualClose = true;
+    this.reconnector.cancel();
+    this.stopHeartbeat();
+    if (this.socket && (this._state === "open" || this._state === "connecting")) {
+      this._state = "closing";
+      this.socket.close();
+    } else {
+      this.setClosed();
+    }
+  }
+  onOpen(cb) {
+    this.openListeners.add(cb);
+    return () => this.openListeners.delete(cb);
+  }
+  onMessage(cb) {
+    this.messageListeners.add(cb);
+    return () => this.messageListeners.delete(cb);
+  }
+  onError(cb) {
+    this.errorListeners.add(cb);
+    return () => this.errorListeners.delete(cb);
+  }
+  onClose(cb) {
+    this.closeListeners.add(cb);
+    return () => this.closeListeners.delete(cb);
+  }
+  /* --------------------------- 内部实现 --------------------------- */
+  /** 打开一条底层 socket 并接线事件;返回的 Promise 在 open 时 resolve */
+  openSocket() {
+    this.teardownSocket();
+    this._state = "connecting";
+    const options = {
+      url: this.url,
+      binaryType: "arraybuffer"
+    };
+    return new Promise((resolve, reject) => {
+      let socket;
+      try {
+        socket = PlatformContext.current.net.createSocket(options);
+      } catch (e) {
+        this._state = "closed";
+        reject(e instanceof Error ? e : new Error(String(e)));
+        return;
+      }
+      this.socket = socket;
+      let settled = false;
+      this.socketUnsubs.push(
+        socket.onOpen(() => {
+          settled = true;
+          this._state = "open";
+          this.reconnector.reset();
+          this.startHeartbeat();
+          if (this.pendingConnect) {
+            this.pendingConnect.resolve();
+            this.pendingConnect = null;
+          }
+          this.emitOpen();
+          resolve();
+        })
+      );
+      this.socketUnsubs.push(
+        socket.onMessage((data) => this.emitMessage(data))
+      );
+      this.socketUnsubs.push(
+        socket.onError((err2) => {
+          this.emitError(err2);
+          if (!settled) {
+            settled = true;
+            reject(err2);
+          }
+        })
+      );
+      this.socketUnsubs.push(
+        socket.onClose(() => this.handleClose())
+      );
+    });
+  }
+  /** 底层 close 事件处理:停心跳、回调,非主动关闭则安排重连 */
+  handleClose() {
+    this.stopHeartbeat();
+    this.teardownSocket();
+    if (this.manualClose) {
+      this.setClosed();
+      return;
+    }
+    this._state = "closed";
+    this.emitClose();
+    this.reconnector.schedule();
+  }
+  /** 标记彻底关闭并通知业务 */
+  setClosed() {
+    if (this._state === "closed") return;
+    this._state = "closed";
+    this.emitClose();
+  }
+  /** 解绑当前 socket 的所有事件订阅 */
+  teardownSocket() {
+    for (const unsub of this.socketUnsubs) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.socketUnsubs = [];
+    this.socket = null;
+  }
+  startHeartbeat() {
+    if (this.heartbeatIntervalMs <= 0) return;
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this._state === "open" && this.socket) {
+        try {
+          this.socket.send(this.heartbeatPayload);
+        } catch {
+        }
+      }
+    }, this.heartbeatIntervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  emitOpen() {
+    for (const cb of this.openListeners) cb();
+  }
+  emitMessage(data) {
+    for (const cb of this.messageListeners) cb(data);
+  }
+  emitError(err2) {
+    for (const cb of this.errorListeners) cb(err2);
+  }
+  emitClose() {
+    for (const cb of this.closeListeners) cb();
+  }
+};
+
+// src/net/kcp/ikcp.ts
+var IKCP_RTO_NDL = 30;
+var IKCP_RTO_MIN = 100;
+var IKCP_RTO_DEF = 200;
+var IKCP_RTO_MAX = 6e4;
+var IKCP_CMD_PUSH = 81;
+var IKCP_CMD_ACK = 82;
+var IKCP_CMD_WASK = 83;
+var IKCP_CMD_WINS = 84;
+var IKCP_ASK_SEND = 1;
+var IKCP_ASK_TELL = 2;
+var IKCP_WND_SND = 32;
+var IKCP_WND_RCV = 128;
+var IKCP_MTU_DEF = 1400;
+var IKCP_INTERVAL = 100;
+var IKCP_OVERHEAD = 24;
+var IKCP_DEADLINK = 20;
+var IKCP_THRESH_INIT = 2;
+var IKCP_THRESH_MIN = 2;
+var IKCP_PROBE_INIT = 7e3;
+var IKCP_PROBE_LIMIT = 12e4;
+var IKCP_FASTACK_LIMIT = 5;
+function u32(x) {
+  return x >>> 0;
+}
+function _itimediff(later, earlier) {
+  return u32(later) - u32(earlier) | 0;
+}
+function _ibound(lower, middle, upper) {
+  return Math.min(Math.max(lower, middle), upper);
+}
+var IKCPSEG = class {
+  constructor(size = 0) {
+    __publicField(this, "conv", 0);
+    // 会话编号
+    __publicField(this, "cmd", 0);
+    // 命令字
+    __publicField(this, "frg", 0);
+    // 分片序号(倒序:0 表示最后一片)
+    __publicField(this, "wnd", 0);
+    // 发送方剩余接收窗口
+    __publicField(this, "ts", 0);
+    // 时间戳
+    __publicField(this, "sn", 0);
+    // 序号
+    __publicField(this, "una", 0);
+    // 待接收序号(对端已收到的连续最大 sn + 1)
+    __publicField(this, "len", 0);
+    // data 长度
+    // —— 发送缓冲控制字段(仅 snd_buf 中的段使用)——
+    __publicField(this, "resendts", 0);
+    // 下次重传时间戳
+    __publicField(this, "rto", 0);
+    // 该段的重传超时
+    __publicField(this, "fastack", 0);
+    // 被跨越次数(快速重传计数)
+    __publicField(this, "xmit", 0);
+    // 已发送次数
+    /** 段数据。固定持有一个 Uint8Array(可能长度为 0) */
+    __publicField(this, "data");
+    this.data = new Uint8Array(size);
+  }
+};
+function encode8u(view, offset, value) {
+  view.setUint8(offset, value & 255);
+  return offset + 1;
+}
+function encode16u(view, offset, value) {
+  view.setUint16(offset, value & 65535, true);
+  return offset + 2;
+}
+function encode32u(view, offset, value) {
+  view.setUint32(offset, u32(value), true);
+  return offset + 4;
+}
+function decode8u(view, offset) {
+  return [view.getUint8(offset), offset + 1];
+}
+function decode16u(view, offset) {
+  return [view.getUint16(offset, true), offset + 2];
+}
+function decode32u(view, offset) {
+  return [view.getUint32(offset, true), offset + 4];
+}
+var IKCPCB = class _IKCPCB {
+  constructor(conv, user) {
+    __publicField(this, "conv");
+    // 会话号
+    __publicField(this, "mtu");
+    // 最大传输单元
+    __publicField(this, "mss");
+    // 最大分片大小 = mtu - overhead
+    __publicField(this, "state", 0);
+    // 连接状态(0 正常,-1 断链)
+    __publicField(this, "snd_una", 0);
+    // 第一个未确认的包
+    __publicField(this, "snd_nxt", 0);
+    // 下一个待分配序号
+    __publicField(this, "rcv_nxt", 0);
+    // 待接收的下一个序号
+    __publicField(this, "ts_recent", 0);
+    __publicField(this, "ts_lastack", 0);
+    __publicField(this, "ssthresh", IKCP_THRESH_INIT);
+    // 拥塞窗口阈值
+    __publicField(this, "rx_rttval", 0);
+    // RTT 平均偏差
+    __publicField(this, "rx_srtt", 0);
+    // 平滑后 RTT
+    __publicField(this, "rx_rto", IKCP_RTO_DEF);
+    // 重传超时
+    __publicField(this, "rx_minrto", IKCP_RTO_MIN);
+    // 最小 RTO
+    __publicField(this, "snd_wnd", IKCP_WND_SND);
+    // 发送窗口
+    __publicField(this, "rcv_wnd", IKCP_WND_RCV);
+    // 接收窗口
+    __publicField(this, "rmt_wnd", IKCP_WND_RCV);
+    // 远端接收窗口
+    __publicField(this, "cwnd", 0);
+    // 拥塞窗口
+    __publicField(this, "probe", 0);
+    // 探测标志(ASK_SEND / ASK_TELL)
+    __publicField(this, "current", 0);
+    // 当前时间(update 传入)
+    __publicField(this, "interval", IKCP_INTERVAL);
+    // flush 间隔
+    __publicField(this, "ts_flush", IKCP_INTERVAL);
+    // 下次 flush 时间
+    __publicField(this, "xmit", 0);
+    // 总重传次数
+    __publicField(this, "nrcv_buf", 0);
+    // rcv_buf 段数
+    __publicField(this, "nsnd_buf", 0);
+    // snd_buf 段数
+    __publicField(this, "nrcv_que", 0);
+    // rcv_queue 段数
+    __publicField(this, "nsnd_que", 0);
+    // snd_queue 段数
+    // 注意:ikcp.c 里字段与函数同名都叫 nodelay;TS 不允许字段与方法同名,
+    // 这里字段重命名为 nodelayMode,配置方法仍叫 nodelay()。
+    __publicField(this, "nodelayMode", 0);
+    // 是否 nodelay 模式(0 关闭,1/2 启用)
+    __publicField(this, "updated", 0);
+    // 是否调用过 update
+    __publicField(this, "ts_probe", 0);
+    // 下次探测窗口时间
+    __publicField(this, "probe_wait", 0);
+    // 探测等待时长
+    __publicField(this, "dead_link", IKCP_DEADLINK);
+    // 段最大重传次数(超过判定断链)
+    __publicField(this, "incr", 0);
+    // 拥塞窗口字节增量
+    // —— 四个核心队列 / 缓冲(对应 ikcp.c 的链表,这里用数组)——
+    __publicField(this, "snd_queue", []);
+    // 待发送(尚未进入发送窗口)
+    __publicField(this, "rcv_queue", []);
+    // 已就绪有序、待 recv 取走
+    __publicField(this, "snd_buf", []);
+    // 已发送、等待 ACK
+    __publicField(this, "rcv_buf", []);
+    // 已收到、等待重组(可能乱序)
+    // ack 列表:成对存放 (sn, ts),flush 时打包成 ACK 包发回
+    __publicField(this, "acklist", []);
+    __publicField(this, "ackcount", 0);
+    __publicField(this, "fastresend", 0);
+    // 快速重传触发阈值(跨越次数)
+    __publicField(this, "fastlimit", IKCP_FASTACK_LIMIT);
+    // 快速重传最大次数
+    __publicField(this, "nocwnd", 0);
+    // 是否关闭拥塞控制
+    __publicField(this, "stream", 0);
+    // 流模式(0 消息模式)
+    __publicField(this, "user");
+    // 透传给 output 的用户数据
+    __publicField(this, "output", null);
+    // flush 时复用的缓冲区,容量 (mtu + overhead) 足够放一个 MTU 包
+    __publicField(this, "buffer");
+    this.conv = u32(conv);
+    this.user = user;
+    this.mtu = IKCP_MTU_DEF;
+    this.mss = this.mtu - IKCP_OVERHEAD;
+    this.buffer = new Uint8Array((this.mtu + IKCP_OVERHEAD) * 3);
+  }
+  /* ----------------------- 创建 / 释放 / output ----------------------- */
+  /** 对应 ikcp_create:工厂方法 */
+  static create(conv, user) {
+    return new _IKCPCB(conv, user);
+  }
+  /** 对应 ikcp_release:释放资源(JS 下置空引用即可) */
+  release() {
+    this.snd_queue = [];
+    this.rcv_queue = [];
+    this.snd_buf = [];
+    this.rcv_buf = [];
+    this.acklist = [];
+    this.output = null;
+    this.nrcv_buf = this.nsnd_buf = this.nrcv_que = this.nsnd_que = 0;
+    this.ackcount = 0;
+  }
+  /** 对应 ikcp_setoutput:设置底层发送回调 */
+  setoutput(output) {
+    this.output = output;
+  }
+  /* ----------------------------- recv ----------------------------- */
+  /**
+   * 对应 ikcp_recv:从 rcv_queue 取出一条完整的应用层消息。
+   * 返回拼接好的 Uint8Array;无完整消息时返回 null。
+   *
+   * 调用方一般循环 recv 直到返回 null,把所有就绪消息取空。
+   */
+  recv() {
+    const peeksize = this.peeksize();
+    if (peeksize < 0) return null;
+    const recover = this.nrcv_que >= this.rcv_wnd;
+    const out = new Uint8Array(peeksize);
+    let n = 0;
+    let count = 0;
+    for (const seg of this.rcv_queue) {
+      out.set(seg.data, n);
+      n += seg.len;
+      count++;
+      if (seg.frg === 0) break;
+    }
+    if (count > 0) {
+      this.rcv_queue.splice(0, count);
+      this.nrcv_que -= count;
+    }
+    this._moveBufToQueue();
+    if (this.nrcv_que < this.rcv_wnd && recover) {
+      this.probe |= IKCP_ASK_TELL;
+    }
+    return out;
+  }
+  /**
+   * 对应 ikcp_peeksize:返回下一条完整消息的总字节数;无完整消息返回 -1。
+   */
+  peeksize() {
+    if (this.rcv_queue.length === 0) return -1;
+    const first = this.rcv_queue[0];
+    if (first.frg === 0) return first.len;
+    if (this.nrcv_que < first.frg + 1) return -1;
+    let length = 0;
+    for (const seg of this.rcv_queue) {
+      length += seg.len;
+      if (seg.frg === 0) break;
+    }
+    return length;
+  }
+  /* ----------------------------- send ----------------------------- */
+  /**
+   * 对应 ikcp_send:把上层数据切成若干 <= mss 的分片放进 snd_queue。
+   * 返回 0 成功,负值失败。
+   *
+   * 这里实现消息模式(stream=0):每次 send 是一条独立消息,frg 倒序标注分片。
+   * 同时实现 stream 模式的合并(stream=1 时尝试把数据追加到上一段)。
+   */
+  send(buffer) {
+    if (buffer.length === 0) return -1;
+    let offset = 0;
+    let len = buffer.length;
+    if (this.stream !== 0 && this.snd_queue.length > 0) {
+      const old = this.snd_queue[this.snd_queue.length - 1];
+      if (old.len < this.mss) {
+        const capacity = this.mss - old.len;
+        const extend = Math.min(len, capacity);
+        const merged = new Uint8Array(old.len + extend);
+        merged.set(old.data.subarray(0, old.len), 0);
+        merged.set(buffer.subarray(offset, offset + extend), old.len);
+        old.data = merged;
+        old.len = merged.length;
+        old.frg = 0;
+        offset += extend;
+        len -= extend;
+      }
+      if (len === 0) return 0;
+    }
+    let count;
+    if (len <= this.mss) count = 1;
+    else count = Math.floor((len + this.mss - 1) / this.mss);
+    if (count >= IKCP_WND_RCV) return -2;
+    if (count === 0) count = 1;
+    for (let i = 0; i < count; i++) {
+      const size = len > this.mss ? this.mss : len;
+      const seg = new IKCPSEG(size);
+      if (size > 0) seg.data.set(buffer.subarray(offset, offset + size));
+      seg.len = size;
+      seg.frg = this.stream === 0 ? count - i - 1 : 0;
+      this.snd_queue.push(seg);
+      this.nsnd_que++;
+      offset += size;
+      len -= size;
+    }
+    return 0;
+  }
+  /* --------------------------- RTT / RTO --------------------------- */
+  /** 对应 ikcp_update_ack:基于一次 RTT 样本更新 srtt / rttval / rto */
+  update_ack(rtt) {
+    if (this.rx_srtt === 0) {
+      this.rx_srtt = rtt;
+      this.rx_rttval = rtt >> 1;
+    } else {
+      let delta = rtt - this.rx_srtt;
+      if (delta < 0) delta = -delta;
+      this.rx_rttval = 3 * this.rx_rttval + delta >> 2;
+      this.rx_srtt = 7 * this.rx_srtt + rtt >> 3;
+      if (this.rx_srtt < 1) this.rx_srtt = 1;
+    }
+    const rto = this.rx_srtt + Math.max(this.interval, 4 * this.rx_rttval);
+    this.rx_rto = _ibound(this.rx_minrto, rto, IKCP_RTO_MAX);
+  }
+  /** 对应 ikcp_shrink_buf:根据 snd_buf 首段更新 snd_una */
+  shrink_buf() {
+    if (this.snd_buf.length > 0) {
+      this.snd_una = this.snd_buf[0].sn;
+    } else {
+      this.snd_una = this.snd_nxt;
+    }
+  }
+  /** 对应 ikcp_parse_ack:收到对端 ACK,移除 snd_buf 中已确认的段 */
+  parse_ack(sn) {
+    if (_itimediff(sn, this.snd_una) < 0 || _itimediff(sn, this.snd_nxt) >= 0) {
+      return;
+    }
+    for (let i = 0; i < this.snd_buf.length; i++) {
+      const seg = this.snd_buf[i];
+      if (sn === seg.sn) {
+        this.snd_buf.splice(i, 1);
+        this.nsnd_buf--;
+        break;
+      }
+      if (_itimediff(sn, seg.sn) < 0) break;
+    }
+  }
+  /** 对应 ikcp_parse_una:收到 una,移除所有 sn < una 的已确认段 */
+  parse_una(una) {
+    let count = 0;
+    for (const seg of this.snd_buf) {
+      if (_itimediff(una, seg.sn) > 0) count++;
+      else break;
+    }
+    if (count > 0) {
+      this.snd_buf.splice(0, count);
+      this.nsnd_buf -= count;
+    }
+  }
+  /** 对应 ikcp_parse_fastack:统计被跨越次数,用于快速重传 */
+  parse_fastack(sn, ts) {
+    if (_itimediff(sn, this.snd_una) < 0 || _itimediff(sn, this.snd_nxt) >= 0) {
+      return;
+    }
+    for (const seg of this.snd_buf) {
+      if (_itimediff(sn, seg.sn) < 0) break;
+      else if (sn !== seg.sn) {
+        if (_itimediff(ts, seg.ts) >= 0) {
+          seg.fastack++;
+        } else {
+          seg.fastack++;
+        }
+      }
+    }
+  }
+  /* ----------------------------- ack 列表 ----------------------------- */
+  /** 对应 ikcp_ack_push:暂存一个待回的 ACK(sn,ts) */
+  ack_push(sn, ts) {
+    this.acklist.push(sn, ts);
+    this.ackcount++;
+  }
+  /** 对应 ikcp_ack_get:取出第 p 个待回 ACK 的 (sn, ts) */
+  ack_get(p) {
+    return [this.acklist[p * 2], this.acklist[p * 2 + 1]];
+  }
+  /* ----------------------------- 接收缓冲 ----------------------------- */
+  /** 对应 ikcp_parse_data:把一个新到的 PUSH 段插入 rcv_buf(去重 + 有序插入) */
+  parse_data(newseg) {
+    const sn = newseg.sn;
+    if (_itimediff(sn, this.rcv_nxt + this.rcv_wnd) >= 0 || _itimediff(sn, this.rcv_nxt) < 0) {
+      return;
+    }
+    let insertPos = this.rcv_buf.length;
+    let repeat = false;
+    for (let i = this.rcv_buf.length - 1; i >= 0; i--) {
+      const seg = this.rcv_buf[i];
+      if (seg.sn === sn) {
+        repeat = true;
+        break;
+      }
+      if (_itimediff(sn, seg.sn) > 0) {
+        insertPos = i + 1;
+        break;
+      }
+      insertPos = i;
+    }
+    if (!repeat) {
+      this.rcv_buf.splice(insertPos, 0, newseg);
+      this.nrcv_buf++;
+    }
+    this._moveBufToQueue();
+  }
+  /** 把 rcv_buf 中 sn == rcv_nxt 的连续段顺次搬进 rcv_queue */
+  _moveBufToQueue() {
+    let moved = 0;
+    for (const seg of this.rcv_buf) {
+      if (seg.sn === this.rcv_nxt && this.nrcv_que < this.rcv_wnd) {
+        this.rcv_queue.push(seg);
+        this.nrcv_que++;
+        this.rcv_nxt = u32(this.rcv_nxt + 1);
+        moved++;
+      } else {
+        break;
+      }
+    }
+    if (moved > 0) {
+      this.rcv_buf.splice(0, moved);
+      this.nrcv_buf -= moved;
+    }
+  }
+  /* ----------------------------- input ----------------------------- */
+  /**
+   * 对应 ikcp_input:解析底层收到的一个或多个 KCP 包(可能粘在一起)。
+   * 返回 0 成功,负值表示数据非法。
+   */
+  input(data) {
+    const prev_una = this.snd_una;
+    let maxack = 0;
+    let latest_ts = 0;
+    let flag = 0;
+    if (data.length < IKCP_OVERHEAD) return -1;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let offset = 0;
+    while (true) {
+      if (data.length - offset < IKCP_OVERHEAD) break;
+      let conv, cmd, frg, wnd;
+      let ts, sn, una, len;
+      [conv, offset] = decode32u(view, offset);
+      if (conv !== this.conv) return -1;
+      [cmd, offset] = decode8u(view, offset);
+      [frg, offset] = decode8u(view, offset);
+      [wnd, offset] = decode16u(view, offset);
+      [ts, offset] = decode32u(view, offset);
+      [sn, offset] = decode32u(view, offset);
+      [una, offset] = decode32u(view, offset);
+      [len, offset] = decode32u(view, offset);
+      if (data.length - offset < len) return -2;
+      if (cmd !== IKCP_CMD_PUSH && cmd !== IKCP_CMD_ACK && cmd !== IKCP_CMD_WASK && cmd !== IKCP_CMD_WINS) {
+        return -3;
+      }
+      this.rmt_wnd = wnd;
+      this.parse_una(una);
+      this.shrink_buf();
+      if (cmd === IKCP_CMD_ACK) {
+        if (_itimediff(this.current, ts) >= 0) {
+          this.update_ack(_itimediff(this.current, ts));
+        }
+        this.parse_ack(sn);
+        this.shrink_buf();
+        if (flag === 0) {
+          flag = 1;
+          maxack = sn;
+          latest_ts = ts;
+        } else if (_itimediff(sn, maxack) > 0) {
+          maxack = sn;
+          latest_ts = ts;
+        }
+      } else if (cmd === IKCP_CMD_PUSH) {
+        if (_itimediff(sn, this.rcv_nxt + this.rcv_wnd) < 0) {
+          this.ack_push(sn, ts);
+          if (_itimediff(sn, this.rcv_nxt) >= 0) {
+            const seg = new IKCPSEG(len);
+            seg.conv = conv;
+            seg.cmd = cmd;
+            seg.frg = frg;
+            seg.wnd = wnd;
+            seg.ts = ts;
+            seg.sn = sn;
+            seg.una = una;
+            seg.len = len;
+            if (len > 0) {
+              seg.data.set(data.subarray(offset, offset + len));
+            }
+            this.parse_data(seg);
+          }
+        }
+      } else if (cmd === IKCP_CMD_WASK) {
+        this.probe |= IKCP_ASK_TELL;
+      } else ;
+      offset += len;
+    }
+    if (flag !== 0) {
+      this.parse_fastack(maxack, latest_ts);
+    }
+    if (_itimediff(this.snd_una, prev_una) > 0) {
+      if (this.cwnd < this.rmt_wnd) {
+        const mss = this.mss;
+        if (this.cwnd < this.ssthresh) {
+          this.cwnd++;
+          this.incr += mss;
+        } else {
+          if (this.incr < mss) this.incr = mss;
+          this.incr += Math.floor(mss * mss / this.incr) + Math.floor(mss / 16);
+          if ((this.cwnd + 1) * mss <= this.incr) {
+            this.cwnd = Math.floor((this.incr + mss - 1) / (mss > 0 ? mss : 1));
+          }
+        }
+        if (this.cwnd > this.rmt_wnd) {
+          this.cwnd = this.rmt_wnd;
+          this.incr = this.rmt_wnd * mss;
+        }
+      }
+    }
+    return 0;
+  }
+  /* ----------------------------- 窗口 ----------------------------- */
+  /** 对应 ikcp_wnd_unused:本端剩余可用接收窗口 */
+  wnd_unused() {
+    if (this.nrcv_que < this.rcv_wnd) {
+      return this.rcv_wnd - this.nrcv_que;
+    }
+    return 0;
+  }
+  /* ----------------------------- flush ----------------------------- */
+  /**
+   * 对应 ikcp_flush:把 ack、窗口探测、待发数据、需重传段统统编码发出。
+   * 这是 KCP 真正"产生网络包"的地方,由 update 周期性调用。
+   */
+  flush() {
+    if (this.updated === 0) return;
+    const current = this.current;
+    const buffer = this.buffer;
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let offset = 0;
+    const seg = new IKCPSEG(0);
+    seg.conv = this.conv;
+    seg.cmd = IKCP_CMD_ACK;
+    seg.frg = 0;
+    seg.wnd = this.wnd_unused();
+    seg.una = this.rcv_nxt;
+    seg.sn = 0;
+    seg.ts = 0;
+    seg.len = 0;
+    const flushBuffer = () => {
+      if (offset > 0) {
+        this.output?.(buffer.subarray(0, offset), this);
+        offset = 0;
+      }
+    };
+    const makeSpace = (need) => {
+      if (offset + need > this.mtu) flushBuffer();
+    };
+    for (let i = 0; i < this.ackcount; i++) {
+      makeSpace(IKCP_OVERHEAD);
+      const [sn, ts] = this.ack_get(i);
+      seg.sn = sn;
+      seg.ts = ts;
+      offset = this.encodeSeg(view, offset, seg);
+    }
+    this.ackcount = 0;
+    this.acklist = [];
+    if (this.rmt_wnd === 0) {
+      if (this.probe_wait === 0) {
+        this.probe_wait = IKCP_PROBE_INIT;
+        this.ts_probe = u32(this.current + this.probe_wait);
+      } else {
+        if (_itimediff(this.current, this.ts_probe) >= 0) {
+          if (this.probe_wait < IKCP_PROBE_INIT) this.probe_wait = IKCP_PROBE_INIT;
+          this.probe_wait += this.probe_wait >> 1;
+          if (this.probe_wait > IKCP_PROBE_LIMIT) this.probe_wait = IKCP_PROBE_LIMIT;
+          this.ts_probe = u32(this.current + this.probe_wait);
+          this.probe |= IKCP_ASK_SEND;
+        }
+      }
+    } else {
+      this.ts_probe = 0;
+      this.probe_wait = 0;
+    }
+    if (this.probe & IKCP_ASK_SEND) {
+      seg.cmd = IKCP_CMD_WASK;
+      makeSpace(IKCP_OVERHEAD);
+      seg.sn = 0;
+      seg.ts = 0;
+      offset = this.encodeSeg(view, offset, seg);
+    }
+    if (this.probe & IKCP_ASK_TELL) {
+      seg.cmd = IKCP_CMD_WINS;
+      makeSpace(IKCP_OVERHEAD);
+      seg.sn = 0;
+      seg.ts = 0;
+      offset = this.encodeSeg(view, offset, seg);
+    }
+    this.probe = 0;
+    let cwnd = Math.min(this.snd_wnd, this.rmt_wnd);
+    if (this.nocwnd === 0) cwnd = Math.min(this.cwnd, cwnd);
+    while (_itimediff(this.snd_nxt, u32(this.snd_una + cwnd)) < 0) {
+      if (this.snd_queue.length === 0) break;
+      const newseg = this.snd_queue.shift();
+      this.nsnd_que--;
+      newseg.conv = this.conv;
+      newseg.cmd = IKCP_CMD_PUSH;
+      newseg.wnd = seg.wnd;
+      newseg.ts = current;
+      newseg.sn = this.snd_nxt;
+      this.snd_nxt = u32(this.snd_nxt + 1);
+      newseg.una = this.rcv_nxt;
+      newseg.resendts = current;
+      newseg.rto = this.rx_rto;
+      newseg.fastack = 0;
+      newseg.xmit = 0;
+      this.snd_buf.push(newseg);
+      this.nsnd_buf++;
+    }
+    const resent = this.fastresend > 0 ? this.fastresend : 4294967295;
+    const rtomin = this.nodelayMode === 0 ? this.rx_rto >> 3 : 0;
+    let change = 0;
+    let lost = 0;
+    for (const segment of this.snd_buf) {
+      let needsend = false;
+      if (segment.xmit === 0) {
+        needsend = true;
+        segment.xmit++;
+        segment.rto = this.rx_rto;
+        segment.resendts = u32(current + segment.rto + rtomin);
+      } else if (_itimediff(current, segment.resendts) >= 0) {
+        needsend = true;
+        segment.xmit++;
+        this.xmit++;
+        if (this.nodelayMode === 0) {
+          segment.rto += Math.max(segment.rto, this.rx_rto);
+        } else {
+          const step = this.nodelayMode < 2 ? segment.rto : this.rx_rto;
+          segment.rto += step >> 1;
+        }
+        segment.resendts = u32(current + segment.rto);
+        lost = 1;
+      } else if (segment.fastack >= resent) {
+        if (segment.xmit <= this.fastlimit || this.fastlimit <= 0) {
+          needsend = true;
+          segment.xmit++;
+          segment.fastack = 0;
+          segment.resendts = u32(current + segment.rto);
+          change++;
+        }
+      }
+      if (needsend) {
+        segment.ts = current;
+        segment.wnd = seg.wnd;
+        segment.una = this.rcv_nxt;
+        const need = IKCP_OVERHEAD + segment.len;
+        makeSpace(need);
+        offset = this.encodeSeg(view, offset, segment);
+        if (segment.len > 0) {
+          buffer.set(segment.data.subarray(0, segment.len), offset);
+          offset += segment.len;
+        }
+        if (segment.xmit >= this.dead_link) {
+          this.state = -1;
+        }
+      }
+    }
+    flushBuffer();
+    if (change > 0) {
+      const inflight = u32(this.snd_nxt - this.snd_una);
+      this.ssthresh = inflight >> 1;
+      if (this.ssthresh < IKCP_THRESH_MIN) this.ssthresh = IKCP_THRESH_MIN;
+      this.cwnd = this.ssthresh + resent;
+      this.incr = this.cwnd * this.mss;
+    }
+    if (lost !== 0) {
+      this.ssthresh = cwnd >> 1;
+      if (this.ssthresh < IKCP_THRESH_MIN) this.ssthresh = IKCP_THRESH_MIN;
+      this.cwnd = 1;
+      this.incr = this.mss;
+    }
+    if (this.cwnd < 1) {
+      this.cwnd = 1;
+      this.incr = this.mss;
+    }
+  }
+  /** 把一个 SEG 的 24 字节包头写入 buffer,返回新 offset(不含 data) */
+  encodeSeg(view, offset, seg) {
+    offset = encode32u(view, offset, seg.conv);
+    offset = encode8u(view, offset, seg.cmd);
+    offset = encode8u(view, offset, seg.frg);
+    offset = encode16u(view, offset, seg.wnd);
+    offset = encode32u(view, offset, seg.ts);
+    offset = encode32u(view, offset, seg.sn);
+    offset = encode32u(view, offset, seg.una);
+    offset = encode32u(view, offset, seg.len);
+    return offset;
+  }
+  /* ----------------------------- update / check ----------------------------- */
+  /**
+   * 对应 ikcp_update:由调用方按 interval 周期性调用,内部到点触发 flush。
+   * current 为当前毫秒时间戳。
+   */
+  update(current) {
+    this.current = u32(current);
+    if (this.updated === 0) {
+      this.updated = 1;
+      this.ts_flush = this.current;
+    }
+    let slap = _itimediff(this.current, this.ts_flush);
+    if (slap >= 1e4 || slap < -1e4) {
+      this.ts_flush = this.current;
+      slap = 0;
+    }
+    if (slap >= 0) {
+      this.ts_flush = u32(this.ts_flush + this.interval);
+      if (_itimediff(this.current, this.ts_flush) >= 0) {
+        this.ts_flush = u32(this.current + this.interval);
+      }
+      this.flush();
+    }
+  }
+  /**
+   * 对应 ikcp_check:返回下一次必须调用 update 的时间戳(ms)。
+   * 调用方可据此节流:在该时刻之前无需频繁 update。
+   */
+  check(current) {
+    const cur = u32(current);
+    let ts_flush = this.ts_flush;
+    let tm_flush = 2147483647;
+    let tm_packet = 2147483647;
+    if (this.updated === 0) return cur;
+    if (_itimediff(cur, ts_flush) >= 1e4 || _itimediff(cur, ts_flush) < -1e4) {
+      ts_flush = cur;
+    }
+    if (_itimediff(cur, ts_flush) >= 0) return cur;
+    tm_flush = _itimediff(ts_flush, cur);
+    for (const seg of this.snd_buf) {
+      const diff = _itimediff(seg.resendts, cur);
+      if (diff <= 0) return cur;
+      if (diff < tm_packet) tm_packet = diff;
+    }
+    let minimal = tm_packet < tm_flush ? tm_packet : tm_flush;
+    if (minimal >= this.interval) minimal = this.interval;
+    return u32(cur + minimal);
+  }
+  /* ----------------------------- 配置 ----------------------------- */
+  /** 对应 ikcp_wndsize:设置发送 / 接收窗口大小 */
+  wndsize(sndwnd, rcvwnd) {
+    if (sndwnd > 0) this.snd_wnd = sndwnd;
+    if (rcvwnd > 0) this.rcv_wnd = Math.max(rcvwnd, IKCP_WND_RCV);
+    return 0;
+  }
+  /** 对应 ikcp_waitsnd:返回待发送 + 未确认的段数(供上层判断积压) */
+  waitsnd() {
+    return this.nsnd_buf + this.nsnd_que;
+  }
+  /**
+   * 对应 ikcp_nodelay:配置低延迟参数。
+   * @param nodelay 0 关闭(默认),1 启用(rto 最小值降到 30ms)
+   * @param interval flush 间隔(10~5000ms)
+   * @param resend 快速重传跨越阈值(>0 启用)
+   * @param nc 是否关闭拥塞控制(1 关闭)
+   */
+  nodelay(nodelay, interval, resend, nc) {
+    if (nodelay >= 0) {
+      this.nodelayMode = nodelay;
+      this.rx_minrto = nodelay !== 0 ? IKCP_RTO_NDL : IKCP_RTO_MIN;
+    }
+    if (interval >= 0) {
+      let it = interval;
+      if (it > 5e3) it = 5e3;
+      else if (it < 10) it = 10;
+      this.interval = it;
+    }
+    if (resend >= 0) this.fastresend = resend;
+    if (nc >= 0) this.nocwnd = nc;
+    return 0;
+  }
+  /** 对应 ikcp_setmtu:设置 MTU 并重建发送缓冲 */
+  setmtu(mtu) {
+    if (mtu < 50 || mtu < IKCP_OVERHEAD) return -1;
+    this.mtu = mtu;
+    this.mss = this.mtu - IKCP_OVERHEAD;
+    this.buffer = new Uint8Array((mtu + IKCP_OVERHEAD) * 3);
+    return 0;
+  }
+  /** 对应 ikcp_setinterval:单独设置 flush 间隔 */
+  setinterval(interval) {
+    let it = interval;
+    if (it > 5e3) it = 5e3;
+    else if (it < 10) it = 10;
+    this.interval = it;
+    return 0;
+  }
+  /** 对应 ikcp_getconv:从一个数据报里读出 conv(无需实例) */
+  static getconv(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return view.getUint32(0, true);
+  }
+};
+
+// src/net/KcpClient.ts
+var KcpClient = class {
+  constructor(config, transportFactory) {
+    __publicField(this, "url");
+    __publicField(this, "conv");
+    __publicField(this, "intervalMs");
+    __publicField(this, "cfgNodelay");
+    __publicField(this, "cfgResend");
+    __publicField(this, "cfgNc");
+    __publicField(this, "cfgSndWnd");
+    __publicField(this, "cfgRcvWnd");
+    __publicField(this, "transportFactory");
+    __publicField(this, "kcp", null);
+    __publicField(this, "transport", null);
+    __publicField(this, "updateTimer", null);
+    __publicField(this, "_state", "closed");
+    __publicField(this, "manualClose", false);
+    __publicField(this, "transportUnsubs", []);
+    __publicField(this, "pendingConnect", null);
+    __publicField(this, "reconnector");
+    __publicField(this, "textEncoder", new TextEncoder());
+    __publicField(this, "openListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "messageListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "errorListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "closeListeners", /* @__PURE__ */ new Set());
+    this.url = config.url;
+    this.conv = config.conv;
+    this.intervalMs = config.intervalMs ?? 10;
+    this.cfgNodelay = config.nodelay ? 1 : 0;
+    this.cfgResend = config.resend ?? 0;
+    this.cfgNc = config.nc ? 1 : 0;
+    this.cfgSndWnd = config.sndWnd;
+    this.cfgRcvWnd = config.rcvWnd;
+    this.transportFactory = transportFactory ?? ((url) => this.createDefaultTransport(url));
+    this.reconnector = new Reconnector({
+      autoReconnect: config.autoReconnect ?? true,
+      maxReconnect: config.maxReconnect ?? Infinity,
+      baseIntervalMs: config.reconnectIntervalMs ?? 1e3,
+      attempt: () => this.openTransport()
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  connect() {
+    if (this._state === "open") return Promise.resolve();
+    this.manualClose = false;
+    this.reconnector.revive();
+    return new Promise((resolve, reject) => {
+      this.pendingConnect = { resolve, reject };
+      this.openTransport().catch((e) => {
+        if (this.pendingConnect) {
+          this.pendingConnect.reject(e instanceof Error ? e : new Error(String(e)));
+          this.pendingConnect = null;
+        }
+        if (!this.manualClose) this.reconnector.schedule();
+      });
+    });
+  }
+  send(data) {
+    if (this._state !== "open" || !this.kcp) {
+      throw new Error("[KcpClient] \u8FDE\u63A5\u672A\u5C31\u7EEA,\u65E0\u6CD5\u53D1\u9001");
+    }
+    const bytes = typeof data === "string" ? this.textEncoder.encode(data) : new Uint8Array(data);
+    this.kcp.send(bytes);
+    this.kcp.update(this.now());
+  }
+  close() {
+    this.manualClose = true;
+    this.reconnector.cancel();
+    this.stopUpdateLoop();
+    if (this.transport && (this._state === "open" || this._state === "connecting")) {
+      this._state = "closing";
+      this.transport.close();
+    } else {
+      this.setClosed();
+    }
+  }
+  onOpen(cb) {
+    this.openListeners.add(cb);
+    return () => this.openListeners.delete(cb);
+  }
+  onMessage(cb) {
+    this.messageListeners.add(cb);
+    return () => this.messageListeners.delete(cb);
+  }
+  onError(cb) {
+    this.errorListeners.add(cb);
+    return () => this.errorListeners.delete(cb);
+  }
+  onClose(cb) {
+    this.closeListeners.add(cb);
+    return () => this.closeListeners.delete(cb);
+  }
+  /* --------------------------- 内部实现 --------------------------- */
+  /** 打开底层传输并初始化 KCP;Promise 在传输 open 时 resolve */
+  openTransport() {
+    this.teardownTransport();
+    this._state = "connecting";
+    return new Promise((resolve, reject) => {
+      let transport;
+      try {
+        transport = this.transportFactory(this.url);
+      } catch (e) {
+        this._state = "closed";
+        reject(e instanceof Error ? e : new Error(String(e)));
+        return;
+      }
+      this.transport = transport;
+      let settled = false;
+      this.transportUnsubs.push(
+        transport.onOpen(() => {
+          settled = true;
+          this.setupKcp();
+          this.startUpdateLoop();
+          this._state = "open";
+          this.reconnector.reset();
+          if (this.pendingConnect) {
+            this.pendingConnect.resolve();
+            this.pendingConnect = null;
+          }
+          this.emitOpen();
+          resolve();
+        })
+      );
+      this.transportUnsubs.push(
+        transport.onMessage((ab) => {
+          if (!this.kcp) return;
+          this.kcp.input(new Uint8Array(ab));
+          this.pump();
+        })
+      );
+      this.transportUnsubs.push(
+        transport.onError((err2) => {
+          this.emitError(err2);
+          if (!settled) {
+            settled = true;
+            reject(err2);
+          }
+        })
+      );
+      this.transportUnsubs.push(
+        transport.onClose(() => this.handleClose())
+      );
+    });
+  }
+  /** 初始化 KCP 控制块并接线 output、应用配置 */
+  setupKcp() {
+    const kcp = IKCPCB.create(this.conv, this);
+    kcp.setoutput((data) => {
+      if (!this.transport) return;
+      const copy = data.slice();
+      this.transport.send(copy.buffer);
+    });
+    kcp.nodelay(this.cfgNodelay, this.intervalMs, this.cfgResend, this.cfgNc);
+    if (this.cfgSndWnd !== void 0 || this.cfgRcvWnd !== void 0) {
+      kcp.wndsize(this.cfgSndWnd ?? 0, this.cfgRcvWnd ?? 0);
+    }
+    this.kcp = kcp;
+  }
+  /** 周期定时器:驱动 kcp.update 并把就绪消息吐给业务 */
+  startUpdateLoop() {
+    this.stopUpdateLoop();
+    this.updateTimer = setInterval(() => this.pump(), this.intervalMs);
+  }
+  stopUpdateLoop() {
+    if (this.updateTimer !== null) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = null;
+    }
+  }
+  /** 驱动 KCP 一拍:update(now) + 循环 recv() 把所有就绪消息发给业务 */
+  pump() {
+    if (!this.kcp) return;
+    this.kcp.update(this.now());
+    let msg;
+    while ((msg = this.kcp.recv()) !== null) {
+      const out = msg.slice().buffer;
+      this.emitMessage(out);
+    }
+  }
+  handleClose() {
+    this.stopUpdateLoop();
+    this.teardownTransport();
+    if (this.kcp) {
+      this.kcp.release();
+      this.kcp = null;
+    }
+    if (this.manualClose) {
+      this.setClosed();
+      return;
+    }
+    this._state = "closed";
+    this.emitClose();
+    this.reconnector.schedule();
+  }
+  setClosed() {
+    if (this.kcp) {
+      this.kcp.release();
+      this.kcp = null;
+    }
+    if (this._state === "closed") return;
+    this._state = "closed";
+    this.emitClose();
+  }
+  teardownTransport() {
+    for (const unsub of this.transportUnsubs) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.transportUnsubs = [];
+    this.transport = null;
+  }
+  /** 当前毫秒时间戳 */
+  now() {
+    return Date.now();
+  }
+  /**
+   * 默认传输实现:基于 PlatformContext 的 IPlatformSocket(WebSocket / wx.connectSocket)。
+   * binaryType=arraybuffer,把它当作 KCP 的"数据报"通道。
+   *
+   * Capacitor 原生 UDP 替换:实现一个同样满足 IKcpTransport 的类(send 走原生 UDP socket,
+   * onMessage 把收到的 datagram 转 ArrayBuffer 回调),通过构造参数 transportFactory 注入。
+   */
+  createDefaultTransport(url) {
+    const options = { url, binaryType: "arraybuffer" };
+    const socket = PlatformContext.current.net.createSocket(options);
+    return {
+      send: (data) => socket.send(data),
+      close: () => socket.close(),
+      onOpen: (cb) => socket.onOpen(cb),
+      onMessage: (cb) => socket.onMessage((data) => {
+        if (typeof data === "string") {
+          this.emitError(
+            new Error("[KcpClient] KCP \u901A\u9053\u6536\u5230\u975E\u4E8C\u8FDB\u5236(string)\u5E27,\u5DF2\u4E22\u5F03;KCP \u901A\u9053\u5E94\u4E3A ArrayBuffer")
+          );
+          return;
+        }
+        cb(data);
+      }),
+      onError: (cb) => socket.onError(cb),
+      onClose: (cb) => socket.onClose(() => cb())
+    };
+  }
+  emitOpen() {
+    for (const cb of this.openListeners) cb();
+  }
+  emitMessage(data) {
+    for (const cb of this.messageListeners) cb(data);
+  }
+  emitError(err2) {
+    for (const cb of this.errorListeners) cb(err2);
+  }
+  emitClose() {
+    for (const cb of this.closeListeners) cb();
+  }
+};
+
+// src/net/NetManager.ts
+var NetManager = class {
+  constructor(opts = {}) {
+    __publicField(this, "apiBaseURL");
+    /** defaultHttp 懒加载单例 */
+    __publicField(this, "_defaultHttp", null);
+    this.apiBaseURL = opts.apiBaseURL ?? "";
+  }
+  /** 创建一个独立的 HTTP 客户端;不传 config 时默认带上全局 apiBaseURL */
+  http(config) {
+    if (config) {
+      return new HttpClient({
+        baseURL: this.apiBaseURL,
+        ...config
+      });
+    }
+    return new HttpClient({ baseURL: this.apiBaseURL });
+  }
+  /** 创建 WebSocket 长连接客户端 */
+  websocket(config) {
+    return new WebSocketClient(config);
+  }
+  /** 创建 KCP 长连接客户端 */
+  kcp(config) {
+    return new KcpClient(config);
+  }
+  /** 框架级默认 HTTP 单例(读取构造时的 apiBaseURL) */
+  get defaultHttp() {
+    if (!this._defaultHttp) {
+      this._defaultHttp = new HttpClient({ baseURL: this.apiBaseURL });
+    }
+    return this._defaultHttp;
+  }
+};
+
+// src/services/EventBus.ts
+var EventBus = class {
+  constructor() {
+    /** 事件名 -> 订阅列表 */
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+  }
+  on(event, handler) {
+    const h = handler;
+    this.addSubscription(event, { original: h, actual: h });
+    return () => this.off(event, h);
+  }
+  once(event, handler) {
+    const original = handler;
+    const wrapper = (payload) => {
+      this.removeSubscription(event, original);
+      original(payload);
+    };
+    this.addSubscription(event, { original, actual: wrapper });
+    return () => this.off(event, original);
+  }
+  off(event, handler) {
+    this.removeSubscription(event, handler);
+  }
+  emit(event, payload) {
+    const subs = this.map.get(event);
+    if (!subs || subs.length === 0) return;
+    const snapshot = subs.slice();
+    for (const sub of snapshot) {
+      sub.actual(payload);
+    }
+  }
+  clear(event) {
+    if (event === void 0) {
+      this.map.clear();
+    } else {
+      this.map.delete(event);
+    }
+  }
+  /** 追加一条订阅 */
+  addSubscription(event, sub) {
+    const list = this.map.get(event);
+    if (list) {
+      list.push(sub);
+    } else {
+      this.map.set(event, [sub]);
+    }
+  }
+  /** 按原始 handler 移除订阅(只移除第一处匹配,与 on 多次注册语义对应) */
+  removeSubscription(event, original) {
+    const list = this.map.get(event);
+    if (!list) return;
+    const idx = list.findIndex((s) => s.original === original);
+    if (idx >= 0) {
+      list.splice(idx, 1);
+      if (list.length === 0) this.map.delete(event);
+    }
+  }
+};
+
+// src/types.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error: typeof error === "string" ? new Error(error) : error };
+}
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 1] = "Info";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  LogLevel2[LogLevel2["Silent"] = 4] = "Silent";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/services/Logger.ts
+var Logger = class _Logger {
+  /**
+   * @param production 是否生产环境(true 时起步级别 Warn)
+   * @param ref 内部共享级别容器(子 logger 复用根的引用,外部不传)
+   * @param tags 标签链(子 logger 内部传递,外部不传)
+   */
+  constructor(production = false, ref, tags = []) {
+    __publicField(this, "ref");
+    /** 标签前缀链,如 ['Net', 'Http'] => 输出 "[Net][Http]" */
+    __publicField(this, "tags");
+    this.ref = ref ?? { level: production ? 2 /* Warn */ : 0 /* Debug */ };
+    this.tags = tags;
+  }
+  get level() {
+    return this.ref.level;
+  }
+  set level(v) {
+    this.ref.level = v;
+  }
+  debug(...args) {
+    this.output(0 /* Debug */, args);
+  }
+  info(...args) {
+    this.output(1 /* Info */, args);
+  }
+  warn(...args) {
+    this.output(2 /* Warn */, args);
+  }
+  error(...args) {
+    this.output(3 /* Error */, args);
+  }
+  tag(label) {
+    return new _Logger(false, this.ref, [...this.tags, label]);
+  }
+  /** 级别过滤 + 前缀拼装 + 分流到 console 对应方法 */
+  output(level, args) {
+    if (level < this.ref.level) return;
+    const prefix = this.tags.length ? this.tags.map((t) => `[${t}]`).join("") : "";
+    const payload = prefix ? [prefix, ...args] : args;
+    switch (level) {
+      case 0 /* Debug */:
+        console.debug(...payload);
+        break;
+      case 1 /* Info */:
+        console.info(...payload);
+        break;
+      case 2 /* Warn */:
+        console.warn(...payload);
+        break;
+      case 3 /* Error */:
+        console.error(...payload);
+        break;
+    }
+  }
+};
+
+// src/services/ConfigService.ts
+var ConfigService = class {
+  constructor(config) {
+    __publicField(this, "_value");
+    this._value = deepFreeze({
+      ...config,
+      extra: config.extra ? { ...config.extra } : void 0
+    });
+  }
+  get value() {
+    return this._value;
+  }
+  /**
+   * 取配置值:
+   * 1) 命中顶层 AppConfig 字段(apiBaseURL/designWidth/...)直接返回
+   * 2) 否则尝试 extra[key]
+   * 3) 都没有则返回 fallback
+   */
+  get(key, fallback) {
+    const top = this._value[key];
+    if (top !== void 0) return top;
+    const extra = this._value.extra;
+    if (extra && key in extra) {
+      return extra[key];
+    }
+    return fallback;
+  }
+};
+function deepFreeze(obj) {
+  if (obj && typeof obj === "object") {
+    for (const v of Object.values(obj)) {
+      if (v && typeof v === "object" && !Object.isFrozen(v)) {
+        deepFreeze(v);
+      }
+    }
+    Object.freeze(obj);
+  }
+  return obj;
+}
+
+// src/services/StorageManager.ts
+var StorageManager = class {
+  constructor(prefix = "app:") {
+    /** 键前缀,隔离命名空间 */
+    __publicField(this, "prefix");
+    this.prefix = prefix;
+  }
+  get(key, fallback) {
+    try {
+      const raw = PlatformContext.current.storage.getItem(this.k(key));
+      if (raw === null || raw === void 0) return fallback;
+      return JSON.parse(raw);
+    } catch {
+      return fallback;
+    }
+  }
+  set(key, value) {
+    try {
+      const raw = JSON.stringify(value);
+      PlatformContext.current.storage.setItem(this.k(key), raw);
+    } catch {
+    }
+  }
+  remove(key) {
+    try {
+      PlatformContext.current.storage.removeItem(this.k(key));
+    } catch {
+    }
+  }
+  clear() {
+    try {
+      PlatformContext.current.storage.clear();
+    } catch {
+    }
+  }
+  /** 拼接命名空间前缀 */
+  k(key) {
+    return this.prefix + key;
+  }
+};
+
+// src/services/AudioManager.ts
+var AudioManager = class {
+  constructor() {
+    /** bootstrap 注入的 Phaser.Game,延迟绑定 */
+    __publicField(this, "game", null);
+    /** 当前播放的背景音乐实例 */
+    __publicField(this, "music", null);
+    __publicField(this, "musicVolume", 1);
+    __publicField(this, "sfxVolume", 1);
+    __publicField(this, "muted", false);
+  }
+  /** 由 bootstrap 在 Phaser.Game 创建后调用,完成绑定 */
+  bindGame(game) {
+    this.game = game;
+  }
+  playMusic(key, opts) {
+    const sound = this.game?.sound;
+    if (!sound) return;
+    this.stopMusic();
+    const volume = (opts?.volume ?? 1) * this.musicVolume;
+    const inst = sound.add(key, {
+      loop: opts?.loop ?? true,
+      volume,
+      mute: this.muted
+    });
+    inst.play();
+    this.music = inst;
+  }
+  stopMusic() {
+    if (this.music) {
+      this.music.stop();
+      this.music.destroy();
+      this.music = null;
+    }
+  }
+  playSfx(key, opts) {
+    const sound = this.game?.sound;
+    if (!sound) return;
+    const volume = (opts?.volume ?? 1) * this.sfxVolume;
+    sound.play(key, { volume, mute: this.muted });
+  }
+  setMusicVolume(v) {
+    this.musicVolume = clamp01(v);
+    const m = this.music;
+    m?.setVolume?.(this.musicVolume);
+  }
+  setSfxVolume(v) {
+    this.sfxVolume = clamp01(v);
+  }
+  muteAll(muted) {
+    this.muted = muted;
+    const sound = this.game?.sound;
+    if (sound) {
+      sound.mute = muted;
+    }
+  }
+};
+function clamp01(v) {
+  if (Number.isNaN(v)) return 0;
+  return Math.min(1, Math.max(0, v));
+}
+
+// src/services/AssetLoader.ts
+var AssetLoader = class {
+  constructor(baseUrl = "") {
+    /** 资源基址(相对路径会拼到它后面);默认空表示相对当前页面 */
+    __publicField(this, "baseUrl");
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  resolveUrl(path) {
+    if (/^https?:\/\//i.test(path) || /^data:/i.test(path)) return path;
+    if (!this.baseUrl) return path;
+    const p = path.replace(/^\/+/, "");
+    return p ? `${this.baseUrl}/${p}` : this.baseUrl;
+  }
+  async loadText(path) {
+    const resp = await this.request(path, "text");
+    return typeof resp.data === "string" ? resp.data : String(resp.data ?? "");
+  }
+  async loadJson(path) {
+    const resp = await this.request(path, "json");
+    if (typeof resp.data === "string") {
+      return JSON.parse(resp.data);
+    }
+    return resp.data;
+  }
+  async loadArrayBuffer(path) {
+    const resp = await this.request(path, "arraybuffer");
+    const data = resp.data;
+    if (data instanceof ArrayBuffer) return data;
+    if (ArrayBuffer.isView(data)) {
+      const view = data;
+      return view.buffer.slice(
+        view.byteOffset,
+        view.byteOffset + view.byteLength
+      );
+    }
+    throw new Error(`[AssetLoader] \u671F\u671B ArrayBuffer,\u5B9E\u9645\u6536\u5230: ${typeof data}`);
+  }
+  /** 统一发起平台层请求,失败时抛出携带 path 的清晰错误 */
+  async request(path, responseType) {
+    const url = this.resolveUrl(path);
+    const resp = await PlatformContext.current.net.request({
+      url,
+      method: "GET",
+      responseType
+    });
+    if (!resp.ok) {
+      throw new Error(`[AssetLoader] \u52A0\u8F7D\u5931\u8D25 ${resp.status}: ${url}`);
+    }
+    return resp;
+  }
+};
+
+// src/services/AdsManager.ts
+var AdsManager = class {
+  /**
+   * @param opts 默认广告位配置(由 bootstrap 从 config.ads 传入,可缺省)
+   */
+  constructor(opts = {}) {
+    /** 激励视频默认广告位 id(调用未传 id 时回退到它) */
+    __publicField(this, "defaultRewardedUnitId");
+    /** 插屏默认广告位 id(调用未传 id 时回退到它) */
+    __publicField(this, "defaultInterstitialUnitId");
+    this.defaultRewardedUnitId = opts.rewardedUnitId;
+    this.defaultInterstitialUnitId = opts.interstitialUnitId;
+  }
+  /** 取当前平台广告能力,可能为 undefined */
+  get impl() {
+    return PlatformContext.current.ads;
+  }
+  get available() {
+    return this.impl !== void 0;
+  }
+  async preloadRewarded(adUnitId) {
+    const ads = this.impl;
+    if (!ads) return;
+    try {
+      await ads.preloadRewarded(adUnitId ?? this.defaultRewardedUnitId);
+    } catch {
+    }
+  }
+  async showRewarded(adUnitId) {
+    const ads = this.impl;
+    if (!ads) return false;
+    try {
+      const result = await ads.showRewarded(adUnitId ?? this.defaultRewardedUnitId);
+      return result === "completed";
+    } catch {
+      return false;
+    }
+  }
+  async showInterstitial(adUnitId) {
+    const ads = this.impl;
+    if (!ads) return "failed";
+    try {
+      return await ads.showInterstitial(adUnitId ?? this.defaultInterstitialUnitId);
+    } catch {
+      return "failed";
+    }
+  }
+};
+
+// src/services/PaymentManager.ts
+var PaymentManager = class {
+  get impl() {
+    return PlatformContext.current.payment;
+  }
+  get available() {
+    return this.impl !== void 0;
+  }
+  async purchase(productId, extra) {
+    const payment = this.impl;
+    if (!payment) {
+      throw new PlatformUnsupportedError(
+        PlatformContext.current.info.name,
+        "payment.purchase"
+      );
+    }
+    return payment.purchase(productId, extra);
+  }
+  async restore() {
+    const payment = this.impl;
+    if (!payment || !payment.restore) return [];
+    try {
+      return await payment.restore();
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/services/AnalyticsManager.ts
+var AnalyticsManager = class {
+  constructor() {
+    __publicField(this, "userId");
+    __publicField(this, "backendClient");
+    __publicField(this, "reportPath", "/analytics/track");
+    __publicField(this, "backendEnabled", false);
+    __publicField(this, "onError");
+  }
+  /**
+   * 由 bootstrap 注入自有后端上报能力(在 NetManager 就绪后调用)。
+   *
+   * 职责拆分(D4):
+   * - configureBackend 负责"装配通道"——注入 HTTP client、reportPath、错误回调;
+   *   是否真正启用由 opts.enabled 决定(bootstrap 通常先以 enabled:false 装配)。
+   * - enableBackend(IAnalyticsManager 正式接口)负责"启用开关"——在通道已装配后
+   *   把 backendEnabled 置真,供 bootstrap 据 config.analytics.backendEnabled 或业务运行时调用。
+   */
+  configureBackend(opts) {
+    this.backendClient = opts.client;
+    if (opts.reportPath) this.reportPath = opts.reportPath;
+    this.backendEnabled = opts.enabled ?? Boolean(opts.client);
+    this.onError = opts.onError;
+  }
+  /**
+   * 启用自有后端上报(IAnalyticsManager 正式接口)。
+   * 需先经 configureBackend 注入 client;未注入 client 时仅置开关、无实际上报(reportToBackend 会短路)。
+   * @param opts.reportPath 可选,覆盖上报路径
+   */
+  enableBackend(opts) {
+    if (opts?.reportPath) this.reportPath = opts.reportPath;
+    this.backendEnabled = true;
+  }
+  get platformImpl() {
+    return PlatformContext.current.analytics;
+  }
+  track(event, params) {
+    const enriched = {
+      ...params ?? {},
+      ...this.userId ? { userId: this.userId } : {},
+      ts: Date.now()
+    };
+    try {
+      this.platformImpl?.reportEvent(event, enriched);
+    } catch {
+    }
+    this.reportToBackend(event, enriched);
+  }
+  setUserId(id) {
+    this.userId = id;
+    try {
+      this.platformImpl?.reportEvent("set_user_id", { userId: id });
+    } catch {
+    }
+  }
+  /** 异步上报到自有后端,失败静默(可经 onError 观测) */
+  reportToBackend(event, params) {
+    if (!this.backendEnabled || !this.backendClient) return;
+    this.backendClient.post(this.reportPath, { event, params }).catch((e) => {
+      const err2 = e instanceof Error ? e : new Error(String(e));
+      this.onError?.(err2);
+    });
+  }
+};
+
+// src/services/AccountService.ts
+var AccountService = class {
+  get impl() {
+    return PlatformContext.current.auth;
+  }
+  async login() {
+    const auth = this.impl;
+    if (!auth) {
+      throw new PlatformUnsupportedError(
+        PlatformContext.current.info.name,
+        "auth.login"
+      );
+    }
+    return auth.login();
+  }
+  /**
+   * 获取用户公开信息(昵称 / 头像)。D5。
+   *
+   * 委托平台 auth.getProfile();无 auth 能力时返回 null(**不抛**)——
+   * getProfile 是可选信息,平台不支持或用户拒绝授权应静默降级,
+   * 业务据此展示默认头像/昵称,而非阻断流程(与 login 不可静默不同)。
+   */
+  async getProfile() {
+    const auth = this.impl;
+    if (!auth) return null;
+    return auth.getProfile();
+  }
+};
+
+// src/services/SceneManager.ts
+var SceneManager = class {
+  constructor() {
+    /** bootstrap 注入的 Phaser.Game,延迟绑定 */
+    __publicField(this, "game", null);
+  }
+  /** 由 bootstrap 在 Phaser.Game 创建后调用 */
+  bindGame(game) {
+    this.game = game;
+  }
+  goto(key, data) {
+    const manager = this.game?.scene;
+    if (!manager) {
+      console.warn("[SceneManager] Phaser.Game \u5C1A\u672A\u5C31\u7EEA,goto \u88AB\u5FFD\u7565:", key);
+      return;
+    }
+    for (const scene of manager.getScenes(true)) {
+      const sceneKey = scene.scene.key;
+      if (sceneKey !== key) {
+        manager.stop(sceneKey);
+      }
+    }
+    manager.start(key, asSceneData(data));
+  }
+  push(key, data) {
+    const manager = this.game?.scene;
+    if (!manager) {
+      console.warn("[SceneManager] Phaser.Game \u5C1A\u672A\u5C31\u7EEA,push \u88AB\u5FFD\u7565:", key);
+      return;
+    }
+    if (manager.isActive(key)) {
+      manager.bringToTop(key);
+      return;
+    }
+    manager.run(key, asSceneData(data));
+    manager.bringToTop(key);
+  }
+  pop(key) {
+    const manager = this.game?.scene;
+    if (!manager) {
+      console.warn("[SceneManager] Phaser.Game \u5C1A\u672A\u5C31\u7EEA,pop \u88AB\u5FFD\u7565:", key);
+      return;
+    }
+    if (manager.isActive(key) || manager.isPaused(key) || manager.isSleeping(key)) {
+      manager.stop(key);
+    }
+  }
+};
+function asSceneData(data) {
+  if (data === void 0 || data === null) return void 0;
+  if (typeof data === "object") return data;
+  return { value: data };
+}
+
+// src/i18n/I18n.ts
+var I18n = class {
+  constructor(opts = {}) {
+    /** 当前语言(已归一) */
+    __publicField(this, "_locale");
+    /** 兜底语言(已归一) */
+    __publicField(this, "fallbackLocale");
+    /** 语言包:locale → (key → 文案) */
+    __publicField(this, "bundles", /* @__PURE__ */ new Map());
+    this.fallbackLocale = normalizeLocale(opts.fallbackLocale ?? "en-US");
+    this._locale = normalizeLocale(opts.locale ?? this.fallbackLocale);
+  }
+  /** 当前语言(归一后的 xx-XX 形态) */
+  get locale() {
+    return this._locale;
+  }
+  /** 切换当前语言(入参自动归一) */
+  setLocale(locale) {
+    this._locale = normalizeLocale(locale);
+  }
+  /**
+   * 合并注册一段语言包。多次对同一 locale 调用会浅合并(后注册覆盖同名 key),
+   * 便于按模块分包加载(如先注册通用包,再注册某场景专属包)。
+   * locale 入参自动归一。
+   */
+  addBundle(locale, dict) {
+    const norm = normalizeLocale(locale);
+    const existing = this.bundles.get(norm);
+    if (existing) {
+      Object.assign(existing, dict);
+    } else {
+      this.bundles.set(norm, { ...dict });
+    }
+  }
+  /**
+   * 取文案。
+   * 查找顺序:当前 locale → fallback locale → 返回 key 本身(并 warn)。
+   * 命中后用 params 做 {name} 占位替换。
+   *
+   * @param key    文案键
+   * @param params 占位参数,如 t('hello', { name: 'Tom' }) 替换 "{name}"
+   */
+  t(key, params) {
+    const template = this.lookup(key);
+    if (template === void 0) {
+      App.log.warn(`[I18n] \u7F3A\u5931\u6587\u6848 key='${key}'(locale='${this._locale}')`);
+      return key;
+    }
+    return params ? interpolate(template, params) : template;
+  }
+  /** 当前 locale 或 fallback locale 中是否存在该 key */
+  has(key) {
+    return this.lookup(key) !== void 0;
+  }
+  /* ------------------------------ 内部 ------------------------------ */
+  /**
+   * 按"当前 locale → fallback locale"顺序查找原始模板,均无则 undefined。
+   * 不在此 warn(由 t 决定是否 warn,has 不应产生噪声日志)。
+   */
+  lookup(key) {
+    const cur = this.bundles.get(this._locale);
+    if (cur && key in cur) return cur[key];
+    if (this.fallbackLocale !== this._locale) {
+      const fb = this.bundles.get(this.fallbackLocale);
+      if (fb && key in fb) return fb[key];
+    }
+    return void 0;
+  }
+};
+function interpolate(template, params) {
+  return template.replace(/\{(\w+)\}/g, (match, name) => {
+    const v = params[name];
+    return v === void 0 ? match : String(v);
+  });
+}
+function normalizeLocale(raw) {
+  if (!raw || typeof raw !== "string") return "en-US";
+  const parts2 = raw.trim().replace(/_/g, "-").split("-").filter(Boolean);
+  if (parts2.length === 0) return "en-US";
+  const lang = parts2[0].toLowerCase();
+  const rest = parts2.slice(1);
+  let script;
+  let region;
+  for (const seg of rest) {
+    if (/^[a-z]{4}$/i.test(seg)) {
+      script = seg.toLowerCase();
+    } else if (/^[a-z]{2}$/i.test(seg) || /^\d{3}$/.test(seg)) {
+      region = seg.toUpperCase();
+    }
+  }
+  if (!region && script) {
+    if (lang === "zh") {
+      region = script === "hant" ? "TW" : "CN";
+    }
+  }
+  return region ? `${lang}-${region}` : lang;
+}
+
+// src/save/SaveManager.ts
+function deepClone(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+function checksum(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+var SaveManager = class {
+  constructor() {
+    /** 已注册的存档槽,按 key 去重 */
+    __publicField(this, "slots", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 注册一个存档槽。返回的 SaveSlot 即业务读写存档的唯一入口。
+   * @template T 存档数据结构
+   */
+  register(opts) {
+    const existing = this.slots.get(opts.key);
+    if (existing) {
+      App.log.warn(
+        `[SaveManager] \u5B58\u6863\u69FD '${opts.key}' \u5DF2\u6CE8\u518C,\u5FFD\u7565\u91CD\u590D\u6CE8\u518C(\u6CBF\u7528\u9996\u6B21\u914D\u7F6E)`
+      );
+      return existing;
+    }
+    const slot = new SaveSlotImpl(opts);
+    this.slots.set(opts.key, slot);
+    return slot;
+  }
+};
+var SaveSlotImpl = class {
+  constructor(opts) {
+    /** 存储键 */
+    __publicField(this, "key");
+    /** 当前版本 */
+    __publicField(this, "_version");
+    /** 默认值(只读源,对外永远给深拷贝) */
+    __publicField(this, "defaults");
+    /** 迁移函数(可选) */
+    __publicField(this, "migrate");
+    this.key = opts.key;
+    this._version = opts.version;
+    this.defaults = opts.defaults;
+    this.migrate = opts.migrate;
+  }
+  get version() {
+    return this._version;
+  }
+  load() {
+    const record = App.storage.get(this.key);
+    if (!this.isValidRecordShape(record)) {
+      return deepClone(this.defaults);
+    }
+    if (!this.verify(record)) {
+      App.log.warn(
+        `[SaveManager] \u5B58\u6863 '${this.key}' \u6821\u9A8C\u5931\u8D25(\u53EF\u80FD\u88AB\u7BE1\u6539\u6216\u635F\u574F),\u56DE\u9000\u9ED8\u8BA4\u503C`
+      );
+      return deepClone(this.defaults);
+    }
+    if (record.v === this._version) {
+      return record.data;
+    }
+    if (record.v > this._version) {
+      App.log.warn(
+        `[SaveManager] \u5B58\u6863 '${this.key}' \u7248\u672C(${record.v})\u9AD8\u4E8E\u5F53\u524D(${this._version}),\u7591\u4F3C\u6E38\u620F\u7248\u672C\u56DE\u9000,\u56DE\u9000\u9ED8\u8BA4\u503C`
+      );
+      return deepClone(this.defaults);
+    }
+    return this.runMigration(record.data, record.v);
+  }
+  save(data) {
+    const record = this.buildRecord(data);
+    App.storage.set(this.key, record);
+  }
+  patch(partial) {
+    const current = this.load();
+    const merged = { ...current, ...partial };
+    this.save(merged);
+  }
+  reset() {
+    this.save(deepClone(this.defaults));
+  }
+  /* ------------------------------ 内部 ------------------------------ */
+  /** 把 data 包装成落盘记录(算校验和) */
+  buildRecord(data) {
+    return {
+      v: this._version,
+      data,
+      sum: this.computeSum(data)
+    };
+  }
+  /** 对 data 计算校验和:序列化失败时回退空串(verify 时也会算到一致值) */
+  computeSum(data) {
+    let serialized;
+    try {
+      serialized = JSON.stringify(data) ?? "";
+    } catch {
+      serialized = "";
+    }
+    return checksum(serialized);
+  }
+  /** 校验记录:重算 data 的校验和与存档中 sum 是否一致 */
+  verify(record) {
+    return this.computeSum(record.data) === record.sum;
+  }
+  /** 运行迁移:有 migrate 则升级并写回,无 migrate 则 warn 回退 defaults */
+  runMigration(oldData, oldVersion) {
+    if (!this.migrate) {
+      App.log.warn(
+        `[SaveManager] \u5B58\u6863 '${this.key}' \u7248\u672C\u843D\u540E(${oldVersion} \u2192 ${this._version})\u4F46\u672A\u63D0\u4F9B migrate,\u56DE\u9000\u9ED8\u8BA4\u503C`
+      );
+      const fresh = deepClone(this.defaults);
+      this.save(fresh);
+      return fresh;
+    }
+    try {
+      const migrated = this.migrate(oldData, oldVersion);
+      this.save(migrated);
+      App.log.info(
+        `[SaveManager] \u5B58\u6863 '${this.key}' \u5DF2\u8FC1\u79FB(${oldVersion} \u2192 ${this._version})`
+      );
+      return migrated;
+    } catch (e) {
+      App.log.warn(
+        `[SaveManager] \u5B58\u6863 '${this.key}' \u8FC1\u79FB\u5931\u8D25,\u56DE\u9000\u9ED8\u8BA4\u503C:`,
+        e instanceof Error ? e.message : String(e)
+      );
+      const fresh = deepClone(this.defaults);
+      this.save(fresh);
+      return fresh;
+    }
+  }
+  /** 粗校验记录形状:必须是带数字 v、字符串 sum、含 data 字段的对象 */
+  isValidRecordShape(record) {
+    if (record === null || typeof record !== "object") return false;
+    const r = record;
+    return typeof r.v === "number" && typeof r.sum === "string" && "data" in r;
+  }
+};
+
+// src/config/ConfigTable.ts
+var ConfigTable = class {
+  /**
+   * @param rows 已构造好的行集合
+   * @param primaryKey 主键字段名(默认 'id'),用于建立索引
+   */
+  constructor(rows, primaryKey = "id") {
+    /** 主键(string|number 统一转 string 作为 Map key) -> 行数据 */
+    __publicField(this, "index", /* @__PURE__ */ new Map());
+    for (const row of rows) {
+      const key = row[primaryKey];
+      if (key === void 0 || key === null) {
+        continue;
+      }
+      this.index.set(String(key), row);
+    }
+  }
+  /** 按主键取一行;不存在返回 undefined */
+  get(id) {
+    return this.index.get(String(id));
+  }
+  /** 返回全部行(顺序为插入顺序) */
+  all() {
+    return Array.from(this.index.values());
+  }
+  /** 是否存在某主键 */
+  has(id) {
+    return this.index.has(String(id));
+  }
+  /** 行数 */
+  get size() {
+    return this.index.size;
+  }
+};
+
+// src/config/ConfigTableManager.ts
+var ConfigTableManager = class {
+  constructor() {
+    /** 表名 -> 已建好的配置表(用 unknown 擦除元素类型,get<T> 时再断言) */
+    __publicField(this, "tables", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 按名加载并缓存一张配置表。已缓存则直接返回缓存,不重复请求。
+   *
+   * @param name 表名(后续 get/has/unload 的键)
+   * @param path 资源路径(交给 App.assets.loadJson)
+   * @param primaryKey 主键字段名,默认 'id'
+   */
+  async load(name, path, primaryKey = "id") {
+    const cached = this.tables.get(name);
+    if (cached) return cached;
+    const data = await App.assets.loadJson(path);
+    const rows = this.normalize(data, primaryKey);
+    const table = new ConfigTable(rows, primaryKey);
+    this.tables.set(name, table);
+    return table;
+  }
+  /**
+   * 取已加载的表;未加载抛出清晰错误(提示先 load)。
+   */
+  get(name) {
+    const table = this.tables.get(name);
+    if (!table) {
+      throw new Error(
+        `[ConfigTableManager] \u914D\u7F6E\u8868 "${name}" \u5C1A\u672A\u52A0\u8F7D\u3002\u8BF7\u5148\u8C03\u7528 load("${name}", path) \u540E\u518D get\u3002`
+      );
+    }
+    return table;
+  }
+  /** 是否已加载某表 */
+  has(name) {
+    return this.tables.has(name);
+  }
+  /** 卸载某表缓存(下次 load 会重新请求);返回是否确有该表 */
+  unload(name) {
+    return this.tables.delete(name);
+  }
+  /**
+   * 把数组或字典两种形态归一化成行数组。
+   * - 数组:直接使用。
+   * - 字典:取所有值;若某值缺主键,则用字典 key 回填(便于字典形态省略 id)。
+   */
+  normalize(data, primaryKey) {
+    if (Array.isArray(data)) {
+      return data;
+    }
+    const rows = [];
+    for (const [key, value] of Object.entries(data)) {
+      const row = value;
+      if (row !== null && typeof row === "object" && (row[primaryKey] === void 0 || row[primaryKey] === null)) {
+        row[primaryKey] = key;
+      }
+      rows.push(value);
+    }
+    return rows;
+  }
+};
+
+// src/module/BaseModule.ts
+var BaseModule = class {
+  /** App 门面:模块内访问网络/存储/事件等的统一入口 */
+  get app() {
+    return App;
+  }
+  /**
+   * 初始化。ModuleRegistry.initAll 按注册顺序调用,可返回 Promise 以等待
+   * 异步初始化(读存档、拉服务端配置等)完成后再初始化下一个模块。
+   * 默认空实现,子类按需覆写。
+   */
+  init() {
+  }
+  /**
+   * 释放。ModuleRegistry.disposeAll 调用,清理订阅 / 定时器 / 缓存等。
+   * 默认空实现,子类按需覆写。
+   */
+  dispose() {
+  }
+};
+
+// src/module/ModuleRegistry.ts
+var ModuleRegistry = class {
+  constructor() {
+    /** name → 模块实例 */
+    __publicField(this, "modules", /* @__PURE__ */ new Map());
+    /** 注册顺序(initAll 正序、disposeAll 逆序据此遍历) */
+    __publicField(this, "order", []);
+  }
+  /**
+   * 注册一个模块。name 重复将抛错(避免静默覆盖导致取到错误实例)。
+   */
+  register(module) {
+    const name = module.name;
+    if (!name) {
+      throw new Error("[ModuleRegistry] \u6A21\u5757\u7F3A\u5C11 name,\u65E0\u6CD5\u6CE8\u518C\u3002");
+    }
+    if (this.modules.has(name)) {
+      throw new Error(`[ModuleRegistry] \u6A21\u5757\u540D\u91CD\u590D\u6CE8\u518C: ${name}`);
+    }
+    this.modules.set(name, module);
+    this.order.push(name);
+  }
+  /**
+   * 按注册顺序依次初始化所有模块,await 异步 init。
+   * 串行(非并行)以尊重模块间的初始化依赖顺序。
+   */
+  async initAll() {
+    for (const name of this.order) {
+      const module = this.modules.get(name);
+      if (module) {
+        await module.init();
+      }
+    }
+  }
+  /**
+   * 释放所有模块。按逆注册顺序释放(后注册者先释放),
+   * 单个模块 dispose 抛错不阻断其余模块释放。
+   */
+  disposeAll() {
+    for (let i = this.order.length - 1; i >= 0; i--) {
+      const module = this.modules.get(this.order[i]);
+      if (!module) continue;
+      try {
+        module.dispose();
+      } catch (e) {
+        console.warn(`[ModuleRegistry] \u6A21\u5757 ${module.name} dispose \u5931\u8D25:`, e?.message ?? e);
+      }
+    }
+    this.modules.clear();
+    this.order.length = 0;
+  }
+  /**
+   * 按 name 取模块,取不到抛清晰错误(避免业务拿到 undefined 后在更深处崩溃)。
+   * 泛型 T 便于直接拿到具体模块类型,无需手动断言。
+   */
+  get(name) {
+    const module = this.modules.get(name);
+    if (!module) {
+      throw new Error(
+        `[ModuleRegistry] \u672A\u627E\u5230\u6A21\u5757: ${name}\u3002\u8BF7\u786E\u8BA4\u5DF2 register(new XxxModule()) \u4E14 name \u4E00\u81F4\u3002`
+      );
+    }
+    return module;
+  }
+  /** 指定 name 的模块是否已注册 */
+  has(name) {
+    return this.modules.has(name);
+  }
+  /** 已注册模块数量 */
+  get size() {
+    return this.modules.size;
+  }
+};
+var BasePanel = class extends Phaser4.GameObjects.Container {
+  constructor(scene) {
+    super(scene, 0, 0);
+    /** 打开本面板时所属的 key(由 PanelManager 在创建后注入,用于自我关闭) */
+    __publicField(this, "_key", "");
+    /** 管理本面板的 PanelManager(由其在创建后注入) */
+    __publicField(this, "_manager", null);
+    /** open 时透传进来的业务数据 */
+    __publicField(this, "_data");
+    /** 关闭时需要逐一执行的清理句柄(订阅、定时器等) */
+    __publicField(this, "disposers", []);
+    /** 防止重复关闭 */
+    __publicField(this, "closing", false);
+  }
+  /** App 门面:面板内访问网络/音频/存储/事件等的统一入口 */
+  get app() {
+    return App;
+  }
+  /**
+   * open 时传入的业务数据(子类在 onCreate/onShow 中读取)。
+   * 注意:Phaser.Container 自身的 `data` 字段是其内置 DataManager,
+   * 故业务数据用 `panelData` 暴露,避免与基类字段冲突。
+   */
+  get panelData() {
+    return this._data;
+  }
+  /** 本面板的注册 key */
+  get key() {
+    return this._key;
+  }
+  /* ----------------------------- 生命周期 ----------------------------- */
+  /**
+   * 构建 UI。子类覆写,在此创建并 add 所有子对象。
+   * 可返回 Promise(异步加载资源/数据时),PanelManager 会 await 后再 onShow。
+   * @param data open 时透传的业务数据(等价于 this.data)
+   */
+  onCreate(_data) {
+  }
+  /** 显示时回调(入场动画 / 数据刷新)。子类按需覆写。 */
+  onShow() {
+  }
+  /** 隐藏时回调(退场动画)。子类按需覆写。在 onClose 之前调用。 */
+  onHide() {
+  }
+  /**
+   * 释放回调。默认实现:执行全部 bind 登记的清理 + 销毁容器。
+   * 子类如需自定义释放逻辑,覆写后请调用 super.onClose() 以保证基础清理执行。
+   */
+  onClose() {
+    this.runDisposers();
+    if (!this.destroyed) {
+      this.destroy(true);
+    }
+  }
+  /* ----------------------------- 对外能力 ----------------------------- */
+  /**
+   * 登记一个需在面板关闭时自动撤销的句柄(事件订阅返回的 Unsubscribe、
+   * 自定义清理函数等)。基类 onClose 会统一执行,业务无需手动记账。
+   */
+  bind(unsub) {
+    this.disposers.push(unsub);
+  }
+  /** 关闭自己(委托给 PanelManager 走完整的 onHide → onClose → 出栈)。 */
+  close() {
+    if (this.closing) return;
+    if (this._manager) {
+      this._manager.close(this._key);
+    } else {
+      this.__hide();
+      this.__close();
+    }
+  }
+  /* ----------------------------- 辅助 UI ----------------------------- */
+  /**
+   * 添加一层覆盖全屏的半透明遮罩(放在面板最底层),点击可选触发关闭。
+   * 以设计稿尺寸铺满;遮罩本身加入容器,随面板一起销毁。
+   * @param opts.color 遮罩颜色(默认黑)
+   * @param opts.alpha 不透明度(默认 0.6)
+   * @param opts.closeOnClick 点击遮罩是否关闭面板(默认 false)
+   */
+  addDim(opts) {
+    const w = this.designWidth;
+    const h = this.designHeight;
+    const color = opts?.color ?? 0;
+    const alpha = opts?.alpha ?? 0.6;
+    const dim = this.scene.make.graphics({}, false);
+    dim.fillStyle(color, alpha);
+    dim.fillRect(0, 0, w, h);
+    if (opts?.closeOnClick) {
+      dim.setInteractive(new Phaser4.Geom.Rectangle(0, 0, w, h), Phaser4.Geom.Rectangle.Contains);
+      dim.on(Phaser4.Input.Events.POINTER_UP, () => this.close());
+    }
+    this.addAt(dim, 0);
+    return dim;
+  }
+  /**
+   * 把一个子对象放到设计稿正中(以设计稿坐标系)。
+   * 仅设置坐标,不负责 add(由调用方决定何时 add 进容器)。
+   */
+  centerChild(child) {
+    child.setPosition(this.designWidth / 2, this.designHeight / 2);
+  }
+  /** 设计稿宽度(来自 App.config) */
+  get designWidth() {
+    return this.app.config.value.designWidth;
+  }
+  /** 设计稿高度(来自 App.config) */
+  get designHeight() {
+    return this.app.config.value.designHeight;
+  }
+  /* --------------------- 仅供 PanelManager 调用的内部钩子 --------------------- */
+  /**
+   * PanelManager 创建面板后注入归属信息。下划线前缀表示"框架内部使用",业务勿调。
+   */
+  __attach(manager, key, data) {
+    this._manager = manager;
+    this._key = key;
+    this._data = data;
+  }
+  /** 触发 onCreate(可能异步)。仅 PanelManager 调用。 */
+  __create() {
+    return this.onCreate(this._data);
+  }
+  /** 触发 onShow。仅 PanelManager 调用。 */
+  __show() {
+    this.onShow();
+  }
+  /** 触发 onHide。仅 PanelManager 调用。 */
+  __hide() {
+    this.onHide();
+  }
+  /** 触发 onClose(释放)。仅 PanelManager 调用,带防重入。 */
+  __close() {
+    if (this.closing) return;
+    this.closing = true;
+    this.onClose();
+  }
+  /** 逐一执行并清空已登记的清理句柄(单个失败不影响其余)。 */
+  runDisposers() {
+    for (const dispose of this.disposers) {
+      try {
+        dispose();
+      } catch (e) {
+        this.app.log.tag("Panel").warn("\u9762\u677F\u6E05\u7406\u53E5\u67C4\u6267\u884C\u5931\u8D25", e?.message ?? e);
+      }
+    }
+    this.disposers.length = 0;
+  }
+  /** 容器是否已被销毁(Phaser 销毁后 scene 引用会被清空) */
+  get destroyed() {
+    return this.scene == null;
+  }
+};
+
+// src/ui/panel/layers.ts
+var Layers = {
+  /** 场景背景层 */
+  Scene: 0,
+  /** 实体层(角色、道具、子弹等) */
+  Entity: 100,
+  /** 常驻 HUD 层 */
+  Hud: 1e3,
+  /** 弹出面板层(PanelManager 管理) */
+  Panel: 2e3,
+  /** 轻提示 / Toast 层 */
+  Toast: 3e3,
+  /** 加载 / 转场遮罩层 */
+  Loading: 4e3,
+  /** 新手引导层(最顶) */
+  Guide: 5e3
+};
+
+// src/ui/panel/PanelManager.ts
+var PanelManager = class {
+  constructor() {
+    /** key → 构造器 */
+    __publicField(this, "registry", /* @__PURE__ */ new Map());
+    /** 打开中的面板栈(后进者在数组尾,即栈顶) */
+    __publicField(this, "stack", []);
+    /** bootstrap 注入的 Phaser.Game,用于取当前活动场景 */
+    __publicField(this, "game", null);
+  }
+  /** 由 bootstrap 在 Phaser.Game 创建后调用 */
+  bindGame(game) {
+    this.game = game;
+  }
+  register(key, ctor) {
+    if (this.registry.has(key)) {
+      console.warn(`[PanelManager] \u9762\u677F key \u91CD\u590D\u6CE8\u518C,\u540E\u8005\u8986\u76D6\u524D\u8005: ${key}`);
+    }
+    this.registry.set(key, ctor);
+  }
+  /**
+   * 打开面板。流程:
+   *   取栈顶活动场景 → new 面板 → 加入场景显示列表 → setDepth(Layers.Panel + 栈深)
+   *   → await onCreate → onShow → 压栈
+   * 若同 key 已打开,直接返回已有实例(不重复创建)。
+   */
+  async open(key, data) {
+    const existing = this.find(key);
+    if (existing) {
+      return existing.panel;
+    }
+    const ctor = this.registry.get(key);
+    if (!ctor) {
+      throw new Error(`[PanelManager] \u672A\u6CE8\u518C\u7684\u9762\u677F key: ${key}\u3002\u8BF7\u5148 register('${key}', SomePanel)\u3002`);
+    }
+    const scene = this.activeScene();
+    if (!scene) {
+      throw new Error(
+        `[PanelManager] \u6CA1\u6709\u53EF\u7528\u7684\u6D3B\u52A8\u573A\u666F,\u65E0\u6CD5\u6253\u5F00\u9762\u677F ${key}\u3002\u8BF7\u786E\u8BA4\u5DF2 bindGame \u4E14\u81F3\u5C11\u6709\u4E00\u4E2A\u573A\u666F\u5728\u8FD0\u884C\u3002`
+      );
+    }
+    const panel = new ctor(scene);
+    panel.__attach(this, key, data);
+    scene.add.existing(panel);
+    panel.setDepth(Layers.Panel + this.stack.length);
+    this.stack.push({ key, panel });
+    await panel.__create();
+    panel.__show();
+    return panel;
+  }
+  close(key) {
+    const idx = this.stack.findIndex((e) => e.key === key);
+    if (idx < 0) return;
+    const [entry] = this.stack.splice(idx, 1);
+    this.teardown(entry.panel);
+    this.reindexDepth();
+  }
+  closeTop() {
+    const top = this.stack[this.stack.length - 1];
+    if (!top) return;
+    this.stack.pop();
+    this.teardown(top.panel);
+  }
+  closeAll() {
+    while (this.stack.length > 0) {
+      const entry = this.stack.pop();
+      this.teardown(entry.panel);
+    }
+  }
+  isOpen(key) {
+    return this.find(key) !== void 0;
+  }
+  /** 当前打开的面板数量 */
+  get stackSize() {
+    return this.stack.length;
+  }
+  /* ------------------------------ 内部 ------------------------------ */
+  /** 执行一个面板的 onHide → onClose(释放) */
+  teardown(panel) {
+    panel.__hide();
+    panel.__close();
+  }
+  /** 关闭非栈顶面板后,按当前栈顺序重排剩余面板的 depth */
+  reindexDepth() {
+    for (let i = 0; i < this.stack.length; i++) {
+      this.stack[i].panel.setDepth(Layers.Panel + i);
+    }
+  }
+  find(key) {
+    return this.stack.find((e) => e.key === key);
+  }
+  /**
+   * 取"当前活动场景"作为面板宿主:用 game.scene.getScenes(true)(运行中的场景)
+   * 的最上层(数组末尾,渲染序最高)那个。
+   *
+   * 扩展点:若业务需要把面板固定挂到某个专用 UI 场景(而非当前场景),
+   * 可在此处改为按指定 sceneKey 取场景,或给 open 增加 targetScene 参数后在此分发。
+   */
+  activeScene() {
+    const manager = this.game?.scene;
+    if (!manager) return null;
+    const actives = manager.getScenes(true);
+    if (actives.length === 0) return null;
+    return actives[actives.length - 1];
+  }
+};
+
+// src/bootstrap.ts
+var _game = null;
+async function startGame(opts) {
+  const { platform, config, scenes } = opts;
+  PlatformContext.set(platform);
+  await platform.init();
+  const net = new NetManager({ apiBaseURL: config.apiBaseURL });
+  const events = new EventBus();
+  const log = new Logger(config.production);
+  const configService = new ConfigService(config);
+  const storage = new StorageManager();
+  const audio = new AudioManager();
+  const assets = new AssetLoader();
+  const ads = new AdsManager(config.ads);
+  const payment = new PaymentManager();
+  const analytics = new AnalyticsManager();
+  const account = new AccountService();
+  const sceneManager = new SceneManager();
+  const tables = new ConfigTableManager();
+  const save = new SaveManager();
+  const modules = new ModuleRegistry();
+  const panelManager = new PanelManager();
+  const i18n = new I18n({
+    locale: normalizeLocale(config.defaultLocale ?? platform.info.system.language),
+    fallbackLocale: config.i18n?.fallbackLocale ?? "en-US"
+  });
+  const lifecycle = platform.lifecycle;
+  analytics.configureBackend({
+    client: net.defaultHttp,
+    // D4:装配阶段默认关闭,下面据 config.analytics.backendEnabled 决定是否启用;平台原生埋点不受影响
+    enabled: false,
+    reportPath: config.analytics?.reportPath,
+    onError: (e) => log.tag("Analytics").warn("\u540E\u7AEF\u4E0A\u62A5\u5931\u8D25", e.message)
+  });
+  if (config.analytics?.backendEnabled) {
+    analytics.enableBackend({ reportPath: config.analytics.reportPath });
+  }
+  const parts2 = {
+    platform,
+    net,
+    events,
+    log,
+    config: configService,
+    audio,
+    storage,
+    assets,
+    ads,
+    payment,
+    analytics,
+    account,
+    scenes: sceneManager,
+    i18n,
+    save,
+    tables,
+    panels: panelManager,
+    modules,
+    lifecycle
+  };
+  __initApp(parts2);
+  if (opts.setup) {
+    await opts.setup(App);
+  }
+  log.info(`[bootstrap] \u5E73\u53F0 ${platform.info.name} \u521D\u59CB\u5316\u5B8C\u6210,\u542F\u52A8 Phaser`);
+  _game = await createPhaserGame(config, scenes);
+  audio.bindGame(_game);
+  sceneManager.bindGame(_game);
+  panelManager.bindGame(_game);
+  await App.modules.initAll();
+  log.info("[bootstrap] \u6E38\u620F\u542F\u52A8\u5B8C\u6210");
+}
+function createPhaserGame(config, scenes) {
+  return new Promise((resolve) => {
+    const gameConfig = {
+      type: Phaser4.AUTO,
+      // 透明背景占位;业务场景自行绘制背景
+      backgroundColor: "#1f2937",
+      scale: {
+        // FIT:按设计分辨率等比缩放铺满容器(保持比例,留黑边);CENTER_BOTH:居中
+        mode: Phaser4.Scale.FIT,
+        autoCenter: Phaser4.Scale.CENTER_BOTH,
+        width: config.designWidth,
+        height: config.designHeight
+      },
+      scene: scenes
+      // 微信等无 DOM 平台由 weapp-adapter 提供 canvas;有 DOM 平台 Phaser 自动建 canvas
+    };
+    const game = new Phaser4.Game(gameConfig);
+    game.events.once(Phaser4.Core.Events.READY, () => resolve(game));
+  });
+}
+
+// src/schedule/Scheduler.ts
+var HandleImpl = class {
+  /**
+   * @param dispose 真正的底层清理(clearTimeout/clearInterval/标记 nextTick 失效)
+   * @param onCancel 通知 Scheduler 从跟踪集合移除
+   */
+  constructor(dispose, onCancel) {
+    __publicField(this, "dispose", dispose);
+    __publicField(this, "onCancel", onCancel);
+    __publicField(this, "cancelled", false);
+  }
+  cancel() {
+    if (this.cancelled) return;
+    this.cancelled = true;
+    this.dispose();
+    this.onCancel(this);
+  }
+  /** 是否已取消(供 nextTick 在 microtask 触发前自检) */
+  get isCancelled() {
+    return this.cancelled;
+  }
+};
+var Scheduler = class {
+  constructor() {
+    /** 所有未结束的句柄;clearAll 时统一取消 */
+    __publicField(this, "handles", /* @__PURE__ */ new Set());
+  }
+  /** 延迟 ms 后执行一次 fn */
+  delay(ms, fn) {
+    let handle;
+    const timer = setTimeout(() => {
+      this.handles.delete(handle);
+      fn();
+    }, ms);
+    handle = new HandleImpl(
+      () => clearTimeout(timer),
+      (h) => this.handles.delete(h)
+    );
+    this.handles.add(handle);
+    return handle;
+  }
+  /** 每隔 ms 周期执行 fn,直到 cancel/clearAll */
+  interval(ms, fn) {
+    let handle;
+    const timer = setInterval(() => {
+      fn();
+    }, ms);
+    handle = new HandleImpl(
+      () => clearInterval(timer),
+      (h) => this.handles.delete(h)
+    );
+    this.handles.add(handle);
+    return handle;
+  }
+  /** 下一个微任务(或 setTimeout 0)执行一次 fn */
+  nextTick(fn) {
+    let handle;
+    const hasMicrotask = typeof queueMicrotask === "function" || typeof Promise !== "undefined";
+    if (hasMicrotask) {
+      handle = new HandleImpl(
+        // microtask 无法真正撤销,靠 isCancelled 标志在触发时短路
+        () => {
+        },
+        (h) => this.handles.delete(h)
+      );
+      const run = () => {
+        if (handle.isCancelled) return;
+        this.handles.delete(handle);
+        fn();
+      };
+      if (typeof queueMicrotask === "function") {
+        queueMicrotask(run);
+      } else {
+        Promise.resolve().then(run);
+      }
+    } else {
+      const timer = setTimeout(() => {
+        this.handles.delete(handle);
+        fn();
+      }, 0);
+      handle = new HandleImpl(
+        () => clearTimeout(timer),
+        (h) => this.handles.delete(h)
+      );
+    }
+    this.handles.add(handle);
+    return handle;
+  }
+  /** 取消单个句柄(等价于 handle.cancel(),幂等) */
+  clear(handle) {
+    handle.cancel();
+  }
+  /** 取消并清空所有句柄 */
+  clearAll() {
+    for (const h of Array.from(this.handles)) {
+      h.cancel();
+    }
+    this.handles.clear();
+  }
+};
+
+// src/scene/BaseScene.ts
+var BaseScene = class extends Phaser4.Scene {
+  /**
+   * E4 构造时挂上场景生命周期清理钩子。
+   *
+   * Phaser 场景实例可被复用(stop → start 重启):重启时不会再走 constructor,
+   * 但会再次触发 create。因此清理逻辑必须在每次 SHUTDOWN 都执行,并在执行后
+   * 重新登记(re-arm),保证下一轮生命周期同样被覆盖;DESTROY(实例被移除)只需一次。
+   */
+  constructor(config) {
+    super(config);
+    /* --------------------------- 自动清理 / 调度 --------------------------- */
+    /**
+     * 场景级定时器(E4)。
+     * 业务在场景内用 this.scheduler.delay/interval/nextTick 启动定时,
+     * 场景 shutdown / destroy 时框架自动 clearAll(),避免"幽灵回调"。
+     */
+    __publicField(this, "scheduler", new Scheduler());
+    /**
+     * 需在场景关闭时清理的订阅句柄登记表(E4)。
+     * 收集 App.events.on / socket.onMessage / platform.lifecycle.onShow 等返回的 Unsubscribe,
+     * 场景 shutdown / destroy 时统一执行并清空,避免订阅泄漏。
+     */
+    __publicField(this, "_bindings", []);
+    /** 清理钩子是否已注册(防止同一实例重复注册) */
+    __publicField(this, "_cleanupArmed", false);
+    this.armCleanupHooks();
+  }
+  /** App 门面:业务在场景内访问网络/音频/存储等的统一入口 */
+  get app() {
+    return App;
+  }
+  /**
+   * 登记需在场景关闭时清理的订阅(E4)。
+   * @param unsub App.events.on / socket.onMessage 等返回的 Unsubscribe
+   *
+   * 用法:this.bind(this.app.events.on('xxx', handler));
+   */
+  bind(unsub) {
+    this._bindings.push(unsub);
+  }
+  /** 注册 SHUTDOWN / DESTROY 清理钩子;SHUTDOWN 用 once + 自重注册以覆盖场景重启 */
+  armCleanupHooks() {
+    if (this._cleanupArmed) return;
+    this._cleanupArmed = true;
+    const onShutdown = () => {
+      this.runCleanup();
+      this.events.once(Phaser4.Scenes.Events.SHUTDOWN, onShutdown);
+    };
+    this.events.once(Phaser4.Scenes.Events.SHUTDOWN, onShutdown);
+    this.events.once(Phaser4.Scenes.Events.DESTROY, () => this.runCleanup());
+  }
+  /** 执行全部清理:解绑所有 bind 的订阅 + 清空场景调度器,并重置登记表 */
+  runCleanup() {
+    for (const unsub of this._bindings) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this._bindings.length = 0;
+    this.scheduler.clearAll();
+  }
+  /* --------------------------- 设计分辨率 --------------------------- */
+  /** 设计稿宽度(来自 App.config) */
+  get designWidth() {
+    return this.app.config.value.designWidth;
+  }
+  /** 设计稿高度(来自 App.config) */
+  get designHeight() {
+    return this.app.config.value.designHeight;
+  }
+  /** 设计稿水平中心 X */
+  get centerX() {
+    return this.designWidth / 2;
+  }
+  /** 设计稿垂直中心 Y */
+  get centerY() {
+    return this.designHeight / 2;
+  }
+  /* ----------------------------- 安全区 ----------------------------- */
+  /** 当前平台安全区(刘海/胶囊规避用),来自 App.platform.info.safeArea */
+  get safeArea() {
+    return this.app.platform.info.safeArea;
+  }
+  get safeTop() {
+    return this.safeArea.top;
+  }
+  get safeBottom() {
+    return this.safeArea.bottom;
+  }
+  get safeLeft() {
+    return this.safeArea.left;
+  }
+  get safeRight() {
+    return this.safeArea.right;
+  }
+  /**
+   * 安全区内的可用矩形(以设计稿坐标系表示)。
+   * 业务把关键 UI(返回按钮、顶栏)摆进这个矩形内即可避开遮挡。
+   */
+  get safeRect() {
+    return {
+      x: this.safeLeft,
+      y: this.safeTop,
+      width: this.designWidth - this.safeLeft - this.safeRight,
+      height: this.designHeight - this.safeTop - this.safeBottom
+    };
+  }
+  /* ----------------------------- 工具 ----------------------------- */
+  /**
+   * 计算把内容(srcW × srcH)等比缩放以"填满"目标框(dstW × dstH)的缩放系数。
+   * 用于背景图铺满、保持比例的图标缩放等。
+   */
+  scaleToFill(srcW, srcH, dstW, dstH) {
+    return Math.max(dstW / srcW, dstH / srcH);
+  }
+  /**
+   * 计算把内容等比缩放以"放进"目标框(不裁切)的缩放系数。
+   */
+  scaleToFit(srcW, srcH, dstW, dstH) {
+    return Math.min(dstW / srcW, dstH / srcH);
+  }
+};
+var DEFAULTS = {
+  width: 240,
+  height: 88,
+  backgroundColor: 3900150,
+  backgroundColorActive: 2450411,
+  radius: 16,
+  textColor: "#ffffff",
+  fontSize: 32,
+  fontFamily: "sans-serif"
+};
+var Button = class extends Phaser4.GameObjects.Container {
+  constructor(scene, config) {
+    super(scene, config.x ?? 0, config.y ?? 0);
+    __publicField(this, "bg");
+    __publicField(this, "label");
+    __publicField(this, "style");
+    __publicField(this, "onClick");
+    /** 是否禁用 */
+    __publicField(this, "_disabled", false);
+    /** 指针是否在按下且仍停留在按钮内 */
+    __publicField(this, "pressed", false);
+    this.style = {
+      width: config.width ?? DEFAULTS.width,
+      height: config.height ?? DEFAULTS.height,
+      backgroundColor: config.backgroundColor ?? DEFAULTS.backgroundColor,
+      backgroundColorActive: config.backgroundColorActive ?? DEFAULTS.backgroundColorActive,
+      radius: config.radius ?? DEFAULTS.radius,
+      textColor: config.textColor ?? DEFAULTS.textColor,
+      fontSize: config.fontSize ?? DEFAULTS.fontSize,
+      fontFamily: config.fontFamily ?? DEFAULTS.fontFamily
+    };
+    this.onClick = config.onClick;
+    this.bg = scene.make.graphics({}, false);
+    this.drawBackground(this.style.backgroundColor);
+    this.add(this.bg);
+    this.label = scene.make.text(
+      {
+        x: 0,
+        y: 0,
+        text: config.text,
+        style: {
+          color: this.style.textColor,
+          fontSize: `${this.style.fontSize}px`,
+          fontFamily: this.style.fontFamily
+        }
+      },
+      false
+    );
+    this.label.setOrigin(0.5, 0.5);
+    this.add(this.label);
+    this.setSize(this.style.width, this.style.height);
+    this.setInteractive(
+      new Phaser4.Geom.Rectangle(
+        -this.style.width / 2,
+        -this.style.height / 2,
+        this.style.width,
+        this.style.height
+      ),
+      Phaser4.Geom.Rectangle.Contains
+    );
+    this.bindEvents();
+    scene.add.existing(this);
+  }
+  /** 设置/更新按钮文案 */
+  setText(text) {
+    this.label.setText(text);
+    return this;
+  }
+  /** 设置禁用态:禁用时变灰且不响应点击 */
+  setDisabled(disabled) {
+    this._disabled = disabled;
+    this.setAlpha(disabled ? 0.5 : 1);
+    if (disabled) {
+      this.disableInteractive();
+      this.pressed = false;
+      this.drawBackground(this.style.backgroundColor);
+      this.setScale(1);
+    } else {
+      this.setInteractive();
+    }
+    return this;
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  /** 绘制圆角背景(以中心为原点) */
+  drawBackground(color) {
+    const { width, height, radius } = this.style;
+    this.bg.clear();
+    this.bg.fillStyle(color, 1);
+    this.bg.fillRoundedRect(-width / 2, -height / 2, width, height, radius);
+  }
+  /** 绑定指针交互:悬停/按下/抬起,实现按下态与点击触发 */
+  bindEvents() {
+    this.on(Phaser4.Input.Events.POINTER_OVER, () => {
+      if (this._disabled) return;
+      this.drawBackground(this.style.backgroundColorActive);
+    });
+    this.on(Phaser4.Input.Events.POINTER_OUT, () => {
+      if (this._disabled) return;
+      this.pressed = false;
+      this.drawBackground(this.style.backgroundColor);
+      this.setScale(1);
+    });
+    this.on(Phaser4.Input.Events.POINTER_DOWN, () => {
+      if (this._disabled) return;
+      this.pressed = true;
+      this.drawBackground(this.style.backgroundColorActive);
+      this.setScale(0.96);
+    });
+    this.on(Phaser4.Input.Events.POINTER_UP, () => {
+      if (this._disabled) return;
+      this.setScale(1);
+      this.drawBackground(this.style.backgroundColor);
+      if (this.pressed) {
+        this.pressed = false;
+        this.onClick?.();
+      }
+    });
+  }
+};
+
+// src/store/Store.ts
+function deepClone2(value) {
+  const sc = globalThis.structuredClone;
+  if (typeof sc === "function") {
+    return sc(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function createStore(initial) {
+  const initialSnapshot = deepClone2(initial);
+  let state = deepClone2(initial);
+  const subscribers = /* @__PURE__ */ new Set();
+  function notify() {
+    const snapshot = state;
+    for (const fn of Array.from(subscribers)) {
+      fn(snapshot);
+    }
+  }
+  function get() {
+    return state;
+  }
+  function set(patch) {
+    const delta = typeof patch === "function" ? patch(state) : patch;
+    state = Object.assign({}, state, delta);
+    notify();
+  }
+  function subscribe(fn) {
+    subscribers.add(fn);
+    return () => {
+      subscribers.delete(fn);
+    };
+  }
+  function select(selector, fn, equals = Object.is) {
+    let prev = selector(state);
+    const listener = (s) => {
+      const next = selector(s);
+      if (!equals(next, prev)) {
+        const old = prev;
+        prev = next;
+        fn(next, old);
+      }
+    };
+    return subscribe(listener);
+  }
+  function reset() {
+    state = deepClone2(initialSnapshot);
+    notify();
+  }
+  return { get, set, subscribe, select, reset };
+}
+
+// src/event/TypedEventBus.ts
+var TypedEventBus = class {
+  constructor() {
+    /** 事件名 → 订阅列表 */
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 订阅事件,返回取消订阅句柄。
+   */
+  on(event, handler) {
+    const h = handler;
+    this.add(event, { original: h, actual: h });
+    return () => this.off(event, handler);
+  }
+  /**
+   * 订阅一次:触发后自动解绑。返回的句柄也可在触发前手动取消。
+   */
+  once(event, handler) {
+    const original = handler;
+    const wrapper = (payload) => {
+      this.remove(event, original);
+      original(payload);
+    };
+    this.add(event, { original, actual: wrapper });
+    return () => this.off(event, handler);
+  }
+  /**
+   * 取消订阅:按原始 handler 匹配移除(只移除第一处匹配,与多次 on 的语义对应)。
+   */
+  off(event, handler) {
+    this.remove(event, handler);
+  }
+  /**
+   * 触发事件。payload 类型由 TMap[K] 约束;void 事件可省略第二参。
+   */
+  emit(event, payload) {
+    const subs = this.map.get(event);
+    if (!subs || subs.length === 0) return;
+    const snapshot = subs.slice();
+    for (const sub of snapshot) {
+      sub.actual(payload);
+    }
+  }
+  /**
+   * 清空订阅:传 event 只清该事件,不传清空全部。
+   */
+  clear(event) {
+    if (event === void 0) {
+      this.map.clear();
+    } else {
+      this.map.delete(event);
+    }
+  }
+  /* ------------------------------ 内部 ------------------------------ */
+  add(event, sub) {
+    const list = this.map.get(event);
+    if (list) {
+      list.push(sub);
+    } else {
+      this.map.set(event, [sub]);
+    }
+  }
+  remove(event, original) {
+    const list = this.map.get(event);
+    if (!list) return;
+    const idx = list.findIndex((s) => s.original === original);
+    if (idx >= 0) {
+      list.splice(idx, 1);
+      if (list.length === 0) this.map.delete(event);
+    }
+  }
+};
+function createTypedEventBus() {
+  return new TypedEventBus();
+}
+
+// src/pool/ObjectPool.ts
+var ObjectPool = class {
+  /**
+   * @param factory 创建新对象的工厂函数
+   * @param opts.reset 归还时重置对象状态的回调
+   * @param opts.initial 初始预创建数量
+   * @param opts.max 空闲队列上限(超出归还时丢弃);默认不限制
+   */
+  constructor(factory, opts) {
+    /** 创建新对象的工厂 */
+    __publicField(this, "factory");
+    /** 归还时的重置回调(清状态),可选 */
+    __publicField(this, "resetFn");
+    /** 空闲队列上限;超出则丢弃归还对象。<=0 视为不限制 */
+    __publicField(this, "maxSize");
+    /** 空闲对象栈(后进先出,缓存友好) */
+    __publicField(this, "free", []);
+    /** 已创建对象总数(含借出与空闲;被丢弃后相应减少) */
+    __publicField(this, "created", 0);
+    this.factory = factory;
+    this.resetFn = opts?.reset;
+    this.maxSize = opts?.max ?? Infinity;
+    const initial = opts?.initial ?? 0;
+    if (initial > 0) this.preallocate(initial);
+  }
+  /** 已创建对象总数(借出 + 空闲) */
+  get size() {
+    return this.created;
+  }
+  /** 当前空闲(可被 acquire 直接复用)的对象数 */
+  get available() {
+    return this.free.length;
+  }
+  /** 借出一个对象:优先复用空闲对象,无则新建 */
+  acquire() {
+    const o = this.free.pop();
+    if (o !== void 0) return o;
+    const created = this.factory();
+    this.created++;
+    return created;
+  }
+  /**
+   * 归还一个对象。先 reset,再视空闲上限决定放回或丢弃。
+   * 丢弃时该对象不再由池持有,created 相应减少。
+   */
+  release(o) {
+    if (this.resetFn) this.resetFn(o);
+    if (this.free.length >= this.maxSize) {
+      if (this.created > 0) this.created--;
+      return;
+    }
+    this.free.push(o);
+  }
+  /** 预创建 n 个空闲对象 */
+  preallocate(n) {
+    for (let i = 0; i < n; i++) {
+      this.free.push(this.factory());
+      this.created++;
+    }
+  }
+  /** 清空空闲队列并把已创建总数归零(池放弃所有持有) */
+  clear() {
+    this.free.length = 0;
+    this.created = 0;
+  }
+};
+
+// src/error/FrameworkError.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["Unknown"] = 0] = "Unknown";
+  ErrorCode2[ErrorCode2["Network"] = 1] = "Network";
+  ErrorCode2[ErrorCode2["Timeout"] = 2] = "Timeout";
+  ErrorCode2[ErrorCode2["HttpStatus"] = 3] = "HttpStatus";
+  ErrorCode2[ErrorCode2["SocketClosed"] = 4] = "SocketClosed";
+  ErrorCode2[ErrorCode2["Storage"] = 5] = "Storage";
+  ErrorCode2[ErrorCode2["PlatformUnsupported"] = 6] = "PlatformUnsupported";
+  ErrorCode2[ErrorCode2["Payment"] = 7] = "Payment";
+  ErrorCode2[ErrorCode2["Ads"] = 8] = "Ads";
+  ErrorCode2[ErrorCode2["Config"] = 9] = "Config";
+  ErrorCode2[ErrorCode2["Save"] = 10] = "Save";
+  return ErrorCode2;
+})(ErrorCode || {});
+var FrameworkError = class _FrameworkError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    /** 错误分类码 */
+    __publicField(this, "code");
+    /** 原始底层异常(第三方/原生错误),可选 */
+    __publicField(this, "cause");
+    this.name = "FrameworkError";
+    Object.setPrototypeOf(this, _FrameworkError.prototype);
+    this.code = code;
+    this.cause = cause;
+  }
+  /* ----------------------- 静态便捷工厂 ----------------------- */
+  static network(message, cause) {
+    return new _FrameworkError(1 /* Network */, message, cause);
+  }
+  static timeout(message, cause) {
+    return new _FrameworkError(2 /* Timeout */, message, cause);
+  }
+  static httpStatus(message, cause) {
+    return new _FrameworkError(3 /* HttpStatus */, message, cause);
+  }
+  static socketClosed(message, cause) {
+    return new _FrameworkError(4 /* SocketClosed */, message, cause);
+  }
+  static storage(message, cause) {
+    return new _FrameworkError(5 /* Storage */, message, cause);
+  }
+  static platformUnsupported(message, cause) {
+    return new _FrameworkError(6 /* PlatformUnsupported */, message, cause);
+  }
+  static payment(message, cause) {
+    return new _FrameworkError(7 /* Payment */, message, cause);
+  }
+  static ads(message, cause) {
+    return new _FrameworkError(8 /* Ads */, message, cause);
+  }
+  static config(message, cause) {
+    return new _FrameworkError(9 /* Config */, message, cause);
+  }
+  static save(message, cause) {
+    return new _FrameworkError(10 /* Save */, message, cause);
+  }
+  static unknown(message, cause) {
+    return new _FrameworkError(0 /* Unknown */, message, cause);
+  }
+};
+function isFrameworkError(e) {
+  return e instanceof FrameworkError;
+}
+
+// src/net/message/MessageChannel.ts
+var MessageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MessageError";
+  }
+};
+var JsonCodec = class {
+  encode(env) {
+    return JSON.stringify(env);
+  }
+  decode(raw) {
+    if (typeof raw !== "string") {
+      throw new MessageError("[JsonCodec] \u4EC5\u652F\u6301 string \u6D88\u606F,\u6536\u5230\u4E8C\u8FDB\u5236\u8BF7\u6539\u7528\u4E8C\u8FDB\u5236 codec");
+    }
+    const obj = JSON.parse(raw);
+    if (!obj || typeof obj.type !== "string") {
+      throw new MessageError("[JsonCodec] \u975E\u6CD5\u6D88\u606F:\u7F3A\u5C11 type \u5B57\u6BB5");
+    }
+    return {
+      type: obj.type,
+      seq: typeof obj.seq === "number" ? obj.seq : void 0,
+      payload: obj.payload
+    };
+  }
+};
+var MessageChannel = class {
+  constructor(socket, opts = {}) {
+    __publicField(this, "socket");
+    __publicField(this, "codec");
+    __publicField(this, "requestTimeoutMs");
+    /** 递增请求序号(从 1 开始,0 留作"无 seq"语义之外的保留) */
+    __publicField(this, "seqCounter", 0);
+    /** 等待响应的请求:seq → pending */
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+    /** 按 type 路由的服务端推送监听器:type → 处理器集合 */
+    __publicField(this, "typeListeners", /* @__PURE__ */ new Map());
+    /** 重连(非首次 open)监听器 */
+    __publicField(this, "reconnectListeners", /* @__PURE__ */ new Set());
+    /** 是否已发生过首次 open(用于区分"首连"与"重连") */
+    __publicField(this, "opened", false);
+    /** 已注册到 socket 的事件取消句柄,close 时统一清理 */
+    __publicField(this, "socketUnsubs", []);
+    /** 是否已 close(关闭后拒绝新请求 / 不再派发) */
+    __publicField(this, "closed", false);
+    this.socket = socket;
+    this.codec = opts.codec ?? new JsonCodec();
+    this.requestTimeoutMs = opts.requestTimeoutMs ?? 1e4;
+    this.bindSocket();
+  }
+  /* ------------------------------ 公开 API ------------------------------ */
+  /** 建立连接(委托底层 socket.connect) */
+  connect() {
+    if (this.closed) {
+      return Promise.reject(new MessageError("[MessageChannel] \u901A\u9053\u5DF2\u5173\u95ED,\u65E0\u6CD5 connect"));
+    }
+    return this.socket.connect();
+  }
+  /**
+   * 发送请求并等待同 seq 响应。
+   * @template TRes 期望响应 payload 类型
+   * @param type    消息类型
+   * @param payload 请求负载
+   * @returns 服务端响应的 payload(按 TRes 断言)
+   * @throws MessageError 超时 / 通道已关闭 / 发送失败
+   */
+  request(type, payload) {
+    if (this.closed) {
+      return Promise.reject(new MessageError("[MessageChannel] \u901A\u9053\u5DF2\u5173\u95ED,\u65E0\u6CD5 request"));
+    }
+    const seq = this.nextSeq();
+    const env = { type, seq, payload };
+    return new Promise((resolve, reject) => {
+      const timer = this.requestTimeoutMs > 0 ? setTimeout(() => {
+        this.pending.delete(seq);
+        reject(
+          new MessageError(
+            `[MessageChannel] \u8BF7\u6C42\u8D85\u65F6(type='${type}', seq=${seq}, timeout=${this.requestTimeoutMs}ms)`
+          )
+        );
+      }, this.requestTimeoutMs) : null;
+      this.pending.set(seq, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        this.socket.send(this.codec.encode(env));
+      } catch (e) {
+        this.clearPending(seq);
+        reject(
+          new MessageError(
+            `[MessageChannel] \u53D1\u9001\u5931\u8D25(type='${type}'):` + (e instanceof Error ? e.message : String(e))
+          )
+        );
+      }
+    });
+  }
+  /** 发送单向消息(不带 seq,不等响应) */
+  send(type, payload) {
+    if (this.closed) {
+      throw new MessageError("[MessageChannel] \u901A\u9053\u5DF2\u5173\u95ED,\u65E0\u6CD5 send");
+    }
+    const env = { type, payload };
+    this.socket.send(this.codec.encode(env));
+  }
+  /**
+   * 订阅某类型的服务端推送(无 seq 的消息,或带 seq 但无匹配 pending 的消息)。
+   * @template T 推送 payload 类型
+   * @returns 取消订阅句柄
+   */
+  on(type, handler) {
+    let set = this.typeListeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.typeListeners.set(type, set);
+    }
+    const h = handler;
+    set.add(h);
+    return () => {
+      const s = this.typeListeners.get(type);
+      if (s) {
+        s.delete(h);
+        if (s.size === 0) this.typeListeners.delete(type);
+      }
+    };
+  }
+  /**
+   * 订阅"重连成功"事件:socket 首次 open 后,再次 open 时触发。
+   * 业务在此重新鉴权 / 重新订阅 / 补偿状态。
+   * @returns 取消订阅句柄
+   */
+  onReconnect(fn) {
+    this.reconnectListeners.add(fn);
+    return () => this.reconnectListeners.delete(fn);
+  }
+  /**
+   * 关闭通道:关闭底层 socket、解绑事件、拒绝所有未决请求、清空监听器。
+   * 关闭后本通道不可再用(再次 connect/request/send 会抛错)。
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const [seq, p] of this.pending) {
+      if (p.timer !== null) clearTimeout(p.timer);
+      p.reject(new MessageError(`[MessageChannel] \u901A\u9053\u5173\u95ED,\u8BF7\u6C42\u88AB\u53D6\u6D88(seq=${seq})`));
+    }
+    this.pending.clear();
+    for (const unsub of this.socketUnsubs) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.socketUnsubs.length = 0;
+    this.typeListeners.clear();
+    this.reconnectListeners.clear();
+    try {
+      this.socket.close();
+    } catch {
+    }
+  }
+  /* ------------------------------ 内部 ------------------------------ */
+  /** 接线底层 socket 的 open / message 事件 */
+  bindSocket() {
+    this.socketUnsubs.push(
+      this.socket.onOpen(() => this.handleOpen())
+    );
+    this.socketUnsubs.push(
+      this.socket.onMessage((raw) => this.handleMessage(raw))
+    );
+  }
+  /** socket open:首次记为"已连",之后每次都视为"重连"并触发 onReconnect */
+  handleOpen() {
+    if (!this.opened) {
+      this.opened = true;
+      return;
+    }
+    for (const fn of this.reconnectListeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }
+  /** 收到底层数据:解码 → 有 seq 命中 pending 则 resolve,否则按 type 派发 */
+  handleMessage(raw) {
+    if (this.closed) return;
+    let env;
+    try {
+      env = this.codec.decode(raw);
+    } catch {
+      return;
+    }
+    if (typeof env.seq === "number") {
+      const p = this.pending.get(env.seq);
+      if (p) {
+        this.clearPending(env.seq);
+        p.resolve(env.payload);
+        return;
+      }
+    }
+    const set = this.typeListeners.get(env.type);
+    if (set && set.size > 0) {
+      for (const handler of set) {
+        try {
+          handler(env.payload);
+        } catch {
+        }
+      }
+    }
+  }
+  /** 取下一个请求序号 */
+  nextSeq() {
+    this.seqCounter += 1;
+    return this.seqCounter;
+  }
+  /** 清理某个 pending(清超时定时器并从表中移除) */
+  clearPending(seq) {
+    const p = this.pending.get(seq);
+    if (p) {
+      if (p.timer !== null) clearTimeout(p.timer);
+      this.pending.delete(seq);
+    }
+  }
+};
+
+export { App, BaseModule, BasePanel, BaseScene, Button, ConfigTable, ConfigTableManager, ErrorCode, FrameworkError, HttpClient, HttpError, I18n, JsonCodec, KcpClient, Layers, LogLevel, MessageChannel, MessageError, ModuleRegistry, NetManager, ObjectPool, PanelManager, PlatformContext, SaveManager, Scheduler, TypedEventBus, WebSocketClient, createStore, createTypedEventBus, err, isFrameworkError, normalizeLocale, ok, startGame };