@esengine/server 4.3.0 → 4.5.0

package/dist/chunk-NWZLKNGV.js

@@ -0,0 +1,2045 @@
+import { createLogger } from './chunk-I4QQSQ72.js';
+import { __name, __publicField } from './chunk-T626JPC7.js';
+import * as path from 'path';
+import { createServer as createServer$1 } from 'http';
+import { serve } from '@esengine/rpc/server';
+import { rpc } from '@esengine/rpc';
+import * as fs from 'fs';
+import { pathToFileURL } from 'url';
+
+// src/room/RoomManager.ts
+var logger = createLogger("Room");
+var _RoomManager = class _RoomManager {
+  constructor(sendFn, sendBinaryFn) {
+    /**
+     * @zh 房间类型定义映射
+     * @en Room type definitions map
+     */
+    __publicField(this, "_definitions", /* @__PURE__ */ new Map());
+    /**
+     * @zh 房间实例映射
+     * @en Room instances map
+     */
+    __publicField(this, "_rooms", /* @__PURE__ */ new Map());
+    /**
+     * @zh 玩家到房间的映射
+     * @en Player to room mapping
+     */
+    __publicField(this, "_playerToRoom", /* @__PURE__ */ new Map());
+    /**
+     * @zh 下一个房间 ID 计数器
+     * @en Next room ID counter
+     */
+    __publicField(this, "_nextRoomId", 1);
+    /**
+     * @zh 消息发送函数
+     * @en Message send function
+     */
+    __publicField(this, "_sendFn");
+    /**
+     * @zh 二进制发送函数
+     * @en Binary send function
+     */
+    __publicField(this, "_sendBinaryFn");
+    this._sendFn = sendFn;
+    this._sendBinaryFn = sendBinaryFn;
+  }
+  /**
+   * @zh 注册房间类型
+   * @en Define room type
+   */
+  define(name, roomClass) {
+    this._definitions.set(name, {
+      roomClass
+    });
+  }
+  /**
+   * @zh 创建房间
+   * @en Create room
+   *
+   * @param name - 房间类型名称 | Room type name
+   * @param options - 房间配置 | Room options
+   * @returns 房间实例或 null | Room instance or null
+   */
+  async create(name, options) {
+    const room = await this._createRoomInstance(name, options);
+    if (room) {
+      await this._onRoomCreated(name, room);
+      logger.info(`Created: ${name} (${room.id})`);
+    }
+    return room;
+  }
+  /**
+   * @zh 房间创建后的回调
+   * @en Callback after room is created
+   *
+   * @param _name - 房间类型名称 | Room type name
+   * @param _room - 房间实例 | Room instance
+   */
+  async _onRoomCreated(_name, _room) {
+  }
+  /**
+   * @zh 加入或创建房间
+   * @en Join or create room
+   *
+   * @param name - 房间类型名称 | Room type name
+   * @param playerId - 玩家 ID | Player ID
+   * @param conn - 玩家连接 | Player connection
+   * @param options - 房间配置 | Room options
+   * @returns 房间和玩家实例或 null | Room and player instance or null
+   */
+  async joinOrCreate(name, playerId, conn, options) {
+    let room = this._findAvailableRoom(name);
+    if (!room) {
+      room = await this.create(name, options);
+      if (!room) return null;
+    }
+    const player = await room._addPlayer(playerId, conn);
+    if (!player) return null;
+    this._onPlayerJoined(playerId, room.id, player);
+    logger.info(`Player ${playerId} joined ${room.id}`);
+    return {
+      room,
+      player
+    };
+  }
+  /**
+   * @zh 加入指定房间
+   * @en Join specific room
+   *
+   * @param roomId - 房间 ID | Room ID
+   * @param playerId - 玩家 ID | Player ID
+   * @param conn - 玩家连接 | Player connection
+   * @returns 房间和玩家实例或 null | Room and player instance or null
+   */
+  async joinById(roomId, playerId, conn) {
+    const room = this._rooms.get(roomId);
+    if (!room) return null;
+    const player = await room._addPlayer(playerId, conn);
+    if (!player) return null;
+    this._onPlayerJoined(playerId, room.id, player);
+    logger.info(`Player ${playerId} joined ${room.id}`);
+    return {
+      room,
+      player
+    };
+  }
+  /**
+   * @zh 玩家离开
+   * @en Player leave
+   *
+   * @param playerId - 玩家 ID | Player ID
+   * @param reason - 离开原因 | Leave reason
+   */
+  async leave(playerId, reason) {
+    const roomId = this._playerToRoom.get(playerId);
+    if (!roomId) return;
+    const room = this._rooms.get(roomId);
+    if (room) {
+      await room._removePlayer(playerId, reason);
+    }
+    this._onPlayerLeft(playerId, roomId);
+    logger.info(`Player ${playerId} left ${roomId}`);
+  }
+  /**
+   * @zh 处理消息
+   * @en Handle message
+   */
+  handleMessage(playerId, type, data) {
+    const roomId = this._playerToRoom.get(playerId);
+    if (!roomId) return;
+    const room = this._rooms.get(roomId);
+    if (room) {
+      room._handleMessage(type, data, playerId);
+    }
+  }
+  /**
+   * @zh 获取房间
+   * @en Get room
+   */
+  getRoom(roomId) {
+    return this._rooms.get(roomId);
+  }
+  /**
+   * @zh 获取玩家所在房间
+   * @en Get player's room
+   */
+  getPlayerRoom(playerId) {
+    const roomId = this._playerToRoom.get(playerId);
+    return roomId ? this._rooms.get(roomId) : void 0;
+  }
+  /**
+   * @zh 获取所有房间
+   * @en Get all rooms
+   */
+  getRooms() {
+    return Array.from(this._rooms.values());
+  }
+  /**
+   * @zh 获取指定类型的所有房间
+   * @en Get all rooms of a type
+   */
+  getRoomsByType(name) {
+    const def = this._definitions.get(name);
+    if (!def) return [];
+    return Array.from(this._rooms.values()).filter((room) => room instanceof def.roomClass);
+  }
+  /**
+   * @zh 查找可用房间
+   * @en Find available room
+   *
+   * @param name - 房间类型名称 | Room type name
+   * @returns 可用房间或 null | Available room or null
+   */
+  _findAvailableRoom(name) {
+    const def = this._definitions.get(name);
+    if (!def) return null;
+    for (const room of this._rooms.values()) {
+      if (room instanceof def.roomClass && !room.isFull && !room.isLocked && !room.isDisposed) {
+        return room;
+      }
+    }
+    return null;
+  }
+  /**
+   * @zh 生成房间 ID
+   * @en Generate room ID
+   *
+   * @returns 新的房间 ID | New room ID
+   */
+  _generateRoomId() {
+    return `room_${this._nextRoomId++}`;
+  }
+  /**
+   * @zh 获取房间定义
+   * @en Get room definition
+   *
+   * @param name - 房间类型名称 | Room type name
+   * @returns 房间定义或 undefined | Room definition or undefined
+   */
+  _getDefinition(name) {
+    return this._definitions.get(name);
+  }
+  /**
+   * @zh 内部创建房间实例
+   * @en Internal create room instance
+   *
+   * @param name - 房间类型名称 | Room type name
+   * @param options - 房间配置 | Room options
+   * @param roomId - 可选的房间 ID（用于分布式恢复） | Optional room ID (for distributed recovery)
+   * @returns 房间实例或 null | Room instance or null
+   */
+  async _createRoomInstance(name, options, roomId) {
+    const def = this._definitions.get(name);
+    if (!def) {
+      logger.warn(`Room type not found: ${name}`);
+      return null;
+    }
+    const finalRoomId = roomId ?? this._generateRoomId();
+    const room = new def.roomClass();
+    room._init({
+      id: finalRoomId,
+      sendFn: this._sendFn,
+      sendBinaryFn: this._sendBinaryFn,
+      broadcastFn: /* @__PURE__ */ __name((type, data) => {
+        for (const player of room.players) {
+          player.send(type, data);
+        }
+      }, "broadcastFn"),
+      disposeFn: /* @__PURE__ */ __name(() => {
+        this._onRoomDisposed(finalRoomId);
+      }, "disposeFn")
+    });
+    this._rooms.set(finalRoomId, room);
+    await room._create(options);
+    return room;
+  }
+  /**
+   * @zh 房间销毁回调
+   * @en Room disposed callback
+   *
+   * @param roomId - 房间 ID | Room ID
+   */
+  _onRoomDisposed(roomId) {
+    this._rooms.delete(roomId);
+  }
+  /**
+   * @zh 玩家加入房间后的回调
+   * @en Callback after player joins room
+   *
+   * @param playerId - 玩家 ID | Player ID
+   * @param roomId - 房间 ID | Room ID
+   * @param player - 玩家实例 | Player instance
+   */
+  _onPlayerJoined(playerId, roomId, _player) {
+    this._playerToRoom.set(playerId, roomId);
+  }
+  /**
+   * @zh 玩家离开房间后的回调
+   * @en Callback after player leaves room
+   *
+   * @param playerId - 玩家 ID | Player ID
+   * @param _roomId - 房间 ID | Room ID
+   */
+  _onPlayerLeft(playerId, _roomId) {
+    this._playerToRoom.delete(playerId);
+  }
+};
+__name(_RoomManager, "RoomManager");
+var RoomManager = _RoomManager;
+
+// src/http/router.ts
+var logger2 = createLogger("HTTP");
+function parseRoutePath(path3) {
+  const paramNames = [];
+  const isStatic = !path3.includes(":");
+  if (isStatic) {
+    return {
+      pattern: new RegExp(`^${escapeRegex(path3)}$`),
+      paramNames,
+      isStatic: true
+    };
+  }
+  const segments = path3.split("/").map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      paramNames.push(paramName);
+      return "([^/]+)";
+    }
+    return escapeRegex(segment);
+  });
+  return {
+    pattern: new RegExp(`^${segments.join("/")}$`),
+    paramNames,
+    isStatic: false
+  };
+}
+__name(parseRoutePath, "parseRoutePath");
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegex, "escapeRegex");
+function matchRoute(routes, path3, method) {
+  for (const route of routes) {
+    if (!route.isStatic) continue;
+    if (route.method !== "*" && route.method !== method) continue;
+    if (route.pattern.test(path3)) {
+      return {
+        route,
+        params: {}
+      };
+    }
+  }
+  for (const route of routes) {
+    if (route.isStatic) continue;
+    if (route.method !== "*" && route.method !== method) continue;
+    const match = path3.match(route.pattern);
+    if (match) {
+      const params = {};
+      route.paramNames.forEach((name, index) => {
+        params[name] = decodeURIComponent(match[index + 1]);
+      });
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+}
+__name(matchRoute, "matchRoute");
+async function createRequest(req, params = {}) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  let body = null;
+  if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") {
+    body = await parseBody(req);
+  }
+  const ip = req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.socket?.remoteAddress || "unknown";
+  return {
+    raw: req,
+    method: req.method ?? "GET",
+    path: url.pathname,
+    params,
+    query,
+    headers: req.headers,
+    body,
+    ip
+  };
+}
+__name(createRequest, "createRequest");
+function parseBody(req) {
+  return new Promise((resolve2) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      const rawBody = Buffer.concat(chunks).toString("utf-8");
+      if (!rawBody) {
+        resolve2(null);
+        return;
+      }
+      const contentType = req.headers["content-type"] ?? "";
+      if (contentType.includes("application/json")) {
+        try {
+          resolve2(JSON.parse(rawBody));
+        } catch {
+          resolve2(rawBody);
+        }
+      } else if (contentType.includes("application/x-www-form-urlencoded")) {
+        const params = new URLSearchParams(rawBody);
+        const result = {};
+        params.forEach((value, key) => {
+          result[key] = value;
+        });
+        resolve2(result);
+      } else {
+        resolve2(rawBody);
+      }
+    });
+    req.on("error", () => {
+      resolve2(null);
+    });
+  });
+}
+__name(parseBody, "parseBody");
+function createResponse(res) {
+  let statusCode = 200;
+  let ended = false;
+  const response = {
+    raw: res,
+    status(code) {
+      statusCode = code;
+      return response;
+    },
+    header(name, value) {
+      if (!ended) {
+        res.setHeader(name, value);
+      }
+      return response;
+    },
+    json(data) {
+      if (ended) return;
+      ended = true;
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.statusCode = statusCode;
+      res.end(JSON.stringify(data));
+    },
+    text(data) {
+      if (ended) return;
+      ended = true;
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.statusCode = statusCode;
+      res.end(data);
+    },
+    error(code, message) {
+      if (ended) return;
+      ended = true;
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.statusCode = code;
+      res.end(JSON.stringify({
+        error: message
+      }));
+    }
+  };
+  return response;
+}
+__name(createResponse, "createResponse");
+function createOriginWhitelist(origins) {
+  const whitelist = {};
+  for (const origin of origins) {
+    whitelist[origin] = true;
+  }
+  return whitelist;
+}
+__name(createOriginWhitelist, "createOriginWhitelist");
+function applyCors(res, req, cors) {
+  const credentials = cors.credentials ?? false;
+  if (typeof cors.origin === "string" && cors.origin !== "*") {
+    res.setHeader("Access-Control-Allow-Origin", cors.origin);
+    if (credentials) {
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+  } else if (Array.isArray(cors.origin)) {
+    const requestOrigin = req.headers.origin;
+    if (typeof requestOrigin === "string") {
+      const whitelist = createOriginWhitelist(cors.origin);
+      if (requestOrigin in whitelist) {
+        res.setHeader("Access-Control-Allow-Origin", requestOrigin);
+        if (credentials) {
+          res.setHeader("Access-Control-Allow-Credentials", "true");
+        }
+      }
+    }
+  } else if (!credentials) {
+    if (cors.origin === "*" || cors.origin === true) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    }
+  }
+  res.setHeader("Access-Control-Allow-Methods", cors.methods?.join(", ") ?? "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", cors.allowedHeaders?.join(", ") ?? "Content-Type, Authorization");
+  if (cors.maxAge) {
+    res.setHeader("Access-Control-Max-Age", String(cors.maxAge));
+  }
+}
+__name(applyCors, "applyCors");
+async function executeMiddlewares(middlewares, req, res, finalHandler) {
+  let index = 0;
+  const next = /* @__PURE__ */ __name(async () => {
+    if (index < middlewares.length) {
+      const middleware = middlewares[index++];
+      await middleware(req, res, next);
+    } else {
+      await finalHandler();
+    }
+  }, "next");
+  await next();
+}
+__name(executeMiddlewares, "executeMiddlewares");
+async function executeWithTimeout(handler, timeoutMs, res) {
+  let resolved = false;
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => {
+      if (!resolved) {
+        reject(new Error("Request timeout"));
+      }
+    }, timeoutMs);
+  });
+  try {
+    await Promise.race([
+      handler().then(() => {
+        resolved = true;
+      }),
+      timeoutPromise
+    ]);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Request timeout") {
+      if (!res.writableEnded) {
+        res.statusCode = 408;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({
+          error: "Request Timeout"
+        }));
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+__name(executeWithTimeout, "executeWithTimeout");
+function isHandlerDefinition(value) {
+  return typeof value === "object" && value !== null && "handler" in value && typeof value.handler === "function";
+}
+__name(isHandlerDefinition, "isHandlerDefinition");
+function isRouteMethods(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const methods = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS"
+  ];
+  return Object.keys(value).some((key) => methods.includes(key));
+}
+__name(isRouteMethods, "isRouteMethods");
+function extractHandler(methodHandler) {
+  if (isHandlerDefinition(methodHandler)) {
+    return {
+      handler: methodHandler.handler,
+      middlewares: methodHandler.middlewares ?? [],
+      timeout: methodHandler.timeout
+    };
+  }
+  return {
+    handler: methodHandler,
+    middlewares: [],
+    timeout: void 0
+  };
+}
+__name(extractHandler, "extractHandler");
+function createHttpRouter(routes, options = {}) {
+  const globalMiddlewares = options.middlewares ?? [];
+  const globalTimeout = options.timeout;
+  const parsedRoutes = [];
+  for (const [path3, handlerOrMethods] of Object.entries(routes)) {
+    const { pattern, paramNames, isStatic } = parseRoutePath(path3);
+    if (typeof handlerOrMethods === "function") {
+      parsedRoutes.push({
+        method: "*",
+        path: path3,
+        handler: handlerOrMethods,
+        pattern,
+        paramNames,
+        middlewares: [],
+        timeout: void 0,
+        isStatic
+      });
+    } else if (isRouteMethods(handlerOrMethods)) {
+      for (const [method, methodHandler] of Object.entries(handlerOrMethods)) {
+        if (methodHandler !== void 0) {
+          const { handler, middlewares, timeout } = extractHandler(methodHandler);
+          parsedRoutes.push({
+            method,
+            path: path3,
+            handler,
+            pattern,
+            paramNames,
+            middlewares,
+            timeout,
+            isStatic
+          });
+        }
+      }
+    } else if (isHandlerDefinition(handlerOrMethods)) {
+      const { handler, middlewares, timeout } = extractHandler(handlerOrMethods);
+      parsedRoutes.push({
+        method: "*",
+        path: path3,
+        handler,
+        pattern,
+        paramNames,
+        middlewares,
+        timeout,
+        isStatic
+      });
+    }
+  }
+  const corsOptions = options.cors === true ? {
+    origin: "*"
+  } : options.cors === false ? null : options.cors ?? null;
+  return /* @__PURE__ */ __name(async function handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path3 = url.pathname;
+    const method = req.method ?? "GET";
+    if (corsOptions) {
+      applyCors(res, req, corsOptions);
+      if (method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return true;
+      }
+    }
+    const match = matchRoute(parsedRoutes, path3, method);
+    if (!match) {
+      return false;
+    }
+    const { route, params } = match;
+    try {
+      const httpReq = await createRequest(req, params);
+      const httpRes = createResponse(res);
+      const allMiddlewares = [
+        ...globalMiddlewares,
+        ...route.middlewares
+      ];
+      const timeout = route.timeout ?? globalTimeout;
+      const finalHandler = /* @__PURE__ */ __name(async () => {
+        await route.handler(httpReq, httpRes);
+      }, "finalHandler");
+      const executeHandler = /* @__PURE__ */ __name(async () => {
+        if (allMiddlewares.length > 0) {
+          await executeMiddlewares(allMiddlewares, httpReq, httpRes, finalHandler);
+        } else {
+          await finalHandler();
+        }
+      }, "executeHandler");
+      if (timeout && timeout > 0) {
+        await executeWithTimeout(executeHandler, timeout, res);
+      } else {
+        await executeHandler();
+      }
+      return true;
+    } catch (error) {
+      logger2.error("Route handler error:", error);
+      if (!res.writableEnded) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+          error: "Internal Server Error"
+        }));
+      }
+      return true;
+    }
+  }, "handleRequest");
+}
+__name(createHttpRouter, "createHttpRouter");
+
+// src/distributed/DistributedRoomManager.ts
+var logger3 = createLogger("DistributedRoom");
+var _DistributedRoomManager = class _DistributedRoomManager extends RoomManager {
+  /**
+   * @zh 创建分布式房间管理器
+   * @en Create distributed room manager
+   *
+   * @param adapter - 分布式适配器 | Distributed adapter
+   * @param config - 配置 | Configuration
+   * @param sendFn - 消息发送函数 | Message send function
+   * @param sendBinaryFn - 二进制发送函数 | Binary send function
+   */
+  constructor(adapter, config, sendFn, sendBinaryFn) {
+    super(sendFn, sendBinaryFn);
+    __publicField(this, "_adapter");
+    __publicField(this, "_config");
+    __publicField(this, "_serverId");
+    __publicField(this, "_heartbeatTimer", null);
+    __publicField(this, "_snapshotTimer", null);
+    __publicField(this, "_subscriptions", []);
+    __publicField(this, "_isShuttingDown", false);
+    this._adapter = adapter;
+    this._serverId = config.serverId;
+    this._config = {
+      serverId: config.serverId,
+      serverAddress: config.serverAddress,
+      serverPort: config.serverPort,
+      heartbeatInterval: config.heartbeatInterval ?? 5e3,
+      snapshotInterval: config.snapshotInterval ?? 3e4,
+      migrationTimeout: config.migrationTimeout ?? 1e4,
+      enableFailover: config.enableFailover ?? true,
+      capacity: config.capacity ?? 100,
+      metadata: config.metadata ?? {}
+    };
+  }
+  /**
+   * @zh 获取服务器 ID
+   * @en Get server ID
+   */
+  get serverId() {
+    return this._serverId;
+  }
+  /**
+   * @zh 获取分布式适配器
+   * @en Get distributed adapter
+   */
+  get adapter() {
+    return this._adapter;
+  }
+  /**
+   * @zh 获取配置
+   * @en Get configuration
+   */
+  get config() {
+    return this._config;
+  }
+  // =========================================================================
+  // 生命周期 | Lifecycle
+  // =========================================================================
+  /**
+   * @zh 启动分布式房间管理器
+   * @en Start distributed room manager
+   */
+  async start() {
+    if (!this._adapter.isConnected()) {
+      await this._adapter.connect();
+    }
+    await this._registerServer();
+    await this._subscribeToEvents();
+    this._startHeartbeat();
+    if (this._config.snapshotInterval > 0) {
+      this._startSnapshotTimer();
+    }
+    logger3.info(`Distributed room manager started: ${this._serverId}`);
+  }
+  /**
+   * @zh 停止分布式房间管理器
+   * @en Stop distributed room manager
+   *
+   * @param graceful - 是否优雅关闭（等待玩家退出）| Whether to gracefully shutdown (wait for players)
+   */
+  async stop(graceful = true) {
+    this._isShuttingDown = true;
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+    if (this._snapshotTimer) {
+      clearInterval(this._snapshotTimer);
+      this._snapshotTimer = null;
+    }
+    for (const unsub of this._subscriptions) {
+      unsub();
+    }
+    this._subscriptions = [];
+    if (graceful) {
+      await this._adapter.updateServer(this._serverId, {
+        status: "draining"
+      });
+      await this._saveAllSnapshots();
+    }
+    await this._adapter.unregisterServer(this._serverId);
+    logger3.info(`Distributed room manager stopped: ${this._serverId}`);
+  }
+  // =========================================================================
+  // 房间操作覆盖 | Room Operation Overrides
+  // =========================================================================
+  /**
+   * @zh 房间创建后注册到分布式系统
+   * @en Register room to distributed system after creation
+   */
+  async _onRoomCreated(name, room) {
+    const registration = {
+      roomId: room.id,
+      roomType: name,
+      serverId: this._serverId,
+      serverAddress: `${this._config.serverAddress}:${this._config.serverPort}`,
+      playerCount: room.players.length,
+      maxPlayers: room.maxPlayers,
+      isLocked: room.isLocked,
+      metadata: {},
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this._adapter.registerRoom(registration);
+    logger3.debug(`Registered room: ${room.id}`);
+  }
+  /**
+   * @zh 房间销毁时从分布式系统注销
+   * @en Unregister room from distributed system when disposed
+   */
+  _onRoomDisposed(roomId) {
+    super._onRoomDisposed(roomId);
+    this._adapter.unregisterRoom(roomId).catch((err) => {
+      logger3.error(`Failed to unregister room ${roomId}:`, err);
+    });
+    this._adapter.deleteSnapshot(roomId).catch((err) => {
+      logger3.error(`Failed to delete snapshot for ${roomId}:`, err);
+    });
+  }
+  /**
+   * @zh 玩家加入后更新分布式房间信息
+   * @en Update distributed room info after player joins
+   */
+  _onPlayerJoined(playerId, roomId, player) {
+    super._onPlayerJoined(playerId, roomId, player);
+    const room = this._rooms.get(roomId);
+    if (room) {
+      this._adapter.updateRoom(roomId, {
+        playerCount: room.players.length,
+        updatedAt: Date.now()
+      }).catch((err) => {
+        logger3.error(`Failed to update room ${roomId}:`, err);
+      });
+    }
+  }
+  /**
+   * @zh 玩家离开后更新分布式房间信息
+   * @en Update distributed room info after player leaves
+   */
+  _onPlayerLeft(playerId, roomId) {
+    super._onPlayerLeft(playerId, roomId);
+    const room = this._rooms.get(roomId);
+    if (room) {
+      this._adapter.updateRoom(roomId, {
+        playerCount: room.players.length,
+        updatedAt: Date.now()
+      }).catch((err) => {
+        logger3.error(`Failed to update room ${roomId}:`, err);
+      });
+    }
+  }
+  // =========================================================================
+  // 分布式路由 | Distributed Routing
+  // =========================================================================
+  /**
+   * @zh 路由玩家到合适的房间/服务器
+   * @en Route player to appropriate room/server
+   *
+   * @param request - 路由请求 | Routing request
+   * @returns 路由结果 | Routing result
+   */
+  async route(request) {
+    if (request.roomId) {
+      return this._routeToRoom(request.roomId);
+    }
+    if (request.roomType) {
+      return this._routeByType(request.roomType, request.query);
+    }
+    return {
+      type: "unavailable",
+      reason: "No room type or room ID specified"
+    };
+  }
+  /**
+   * @zh 加入或创建房间（分布式版本）
+   * @en Join or create room (distributed version)
+   *
+   * @zh 此方法会：
+   * 1. 先在分布式注册表中查找可用房间
+   * 2. 如果找到其他服务器的房间，返回重定向
+   * 3. 如果找到本地房间或需要创建，在本地处理
+   * @en This method will:
+   * 1. First search for available room in distributed registry
+   * 2. If room found on another server, return redirect
+   * 3. If local room found or creation needed, handle locally
+   */
+  async joinOrCreateDistributed(name, playerId, conn, options) {
+    const lockKey = `joinOrCreate:${name}`;
+    const locked = await this._adapter.acquireLock(lockKey, 5e3);
+    if (!locked) {
+      await this._sleep(100);
+      return this.joinOrCreateDistributed(name, playerId, conn, options);
+    }
+    try {
+      const availableRoom = await this._adapter.findAvailableRoom(name);
+      if (availableRoom) {
+        if (availableRoom.serverId === this._serverId) {
+          return super.joinOrCreate(name, playerId, conn, options);
+        } else {
+          return {
+            redirect: availableRoom.serverAddress
+          };
+        }
+      }
+      return super.joinOrCreate(name, playerId, conn, options);
+    } finally {
+      await this._adapter.releaseLock(lockKey);
+    }
+  }
+  // =========================================================================
+  // 状态管理 | State Management
+  // =========================================================================
+  /**
+   * @zh 保存房间状态快照
+   * @en Save room state snapshot
+   *
+   * @param roomId - 房间 ID | Room ID
+   */
+  async saveSnapshot(roomId) {
+    const room = this._rooms.get(roomId);
+    if (!room) return;
+    const def = this._getDefinitionByRoom(room);
+    if (!def) return;
+    const snapshot = {
+      roomId: room.id,
+      roomType: def.name,
+      state: room.state ?? {},
+      players: room.players.map((p) => ({
+        id: p.id,
+        data: p.data ?? {}
+      })),
+      version: Date.now(),
+      timestamp: Date.now()
+    };
+    await this._adapter.saveSnapshot(snapshot);
+    logger3.debug(`Saved snapshot for room: ${roomId}`);
+  }
+  /**
+   * @zh 从快照恢复房间
+   * @en Restore room from snapshot
+   *
+   * @param roomId - 房间 ID | Room ID
+   * @returns 是否成功恢复 | Whether restore was successful
+   */
+  async restoreFromSnapshot(roomId) {
+    const snapshot = await this._adapter.loadSnapshot(roomId);
+    if (!snapshot) return false;
+    const room = await this._createRoomInstance(snapshot.roomType, {
+      state: snapshot.state
+    }, snapshot.roomId);
+    if (!room) return false;
+    await this._onRoomCreated(snapshot.roomType, room);
+    logger3.info(`Restored room from snapshot: ${roomId}`);
+    return true;
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  /**
+   * @zh 注册服务器到分布式系统
+   * @en Register server to distributed system
+   */
+  async _registerServer() {
+    const registration = {
+      serverId: this._serverId,
+      address: this._config.serverAddress,
+      port: this._config.serverPort,
+      roomCount: this._rooms.size,
+      playerCount: this._countTotalPlayers(),
+      capacity: this._config.capacity,
+      status: "online",
+      lastHeartbeat: Date.now(),
+      metadata: this._config.metadata
+    };
+    await this._adapter.registerServer(registration);
+  }
+  /**
+   * @zh 订阅分布式事件
+   * @en Subscribe to distributed events
+   */
+  async _subscribeToEvents() {
+    if (this._config.enableFailover) {
+      const unsub = await this._adapter.subscribe("server:offline", (event) => {
+        this._handleServerOffline(event);
+      });
+      this._subscriptions.push(unsub);
+    }
+    const roomMsgUnsub = await this._adapter.subscribe("room:message", (event) => {
+      this._handleRoomMessage(event);
+    });
+    this._subscriptions.push(roomMsgUnsub);
+  }
+  /**
+   * @zh 启动心跳定时器
+   * @en Start heartbeat timer
+   */
+  _startHeartbeat() {
+    this._heartbeatTimer = setInterval(async () => {
+      try {
+        await this._adapter.heartbeat(this._serverId);
+        await this._adapter.updateServer(this._serverId, {
+          roomCount: this._rooms.size,
+          playerCount: this._countTotalPlayers()
+        });
+      } catch (err) {
+        logger3.error("Heartbeat failed:", err);
+      }
+    }, this._config.heartbeatInterval);
+  }
+  /**
+   * @zh 启动快照定时器
+   * @en Start snapshot timer
+   */
+  _startSnapshotTimer() {
+    this._snapshotTimer = setInterval(async () => {
+      await this._saveAllSnapshots();
+    }, this._config.snapshotInterval);
+  }
+  /**
+   * @zh 保存所有房间快照
+   * @en Save all room snapshots
+   */
+  async _saveAllSnapshots() {
+    const promises = [];
+    for (const roomId of this._rooms.keys()) {
+      promises.push(this.saveSnapshot(roomId));
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+   * @zh 路由到指定房间
+   * @en Route to specific room
+   */
+  async _routeToRoom(roomId) {
+    if (this._rooms.has(roomId)) {
+      return {
+        type: "local",
+        roomId
+      };
+    }
+    const registration = await this._adapter.getRoom(roomId);
+    if (!registration) {
+      return {
+        type: "unavailable",
+        reason: "Room not found"
+      };
+    }
+    if (registration.serverId === this._serverId) {
+      return {
+        type: "local",
+        roomId
+      };
+    }
+    return {
+      type: "redirect",
+      serverAddress: registration.serverAddress,
+      roomId
+    };
+  }
+  /**
+   * @zh 按类型路由
+   * @en Route by type
+   */
+  async _routeByType(roomType, _query) {
+    const availableRoom = await this._adapter.findAvailableRoom(roomType);
+    if (!availableRoom) {
+      return {
+        type: "create",
+        roomId: void 0
+      };
+    }
+    if (availableRoom.serverId === this._serverId) {
+      return {
+        type: "local",
+        roomId: availableRoom.roomId
+      };
+    }
+    return {
+      type: "redirect",
+      serverAddress: availableRoom.serverAddress,
+      roomId: availableRoom.roomId
+    };
+  }
+  /**
+   * @zh 处理服务器离线事件
+   * @en Handle server offline event
+   */
+  _handleServerOffline(event) {
+    if (this._isShuttingDown) return;
+    if (!this._config.enableFailover) return;
+    const offlineServerId = event.serverId;
+    if (offlineServerId === this._serverId) return;
+    logger3.info(`Server offline detected: ${offlineServerId}`);
+    this._tryRecoverRoomsFromServer(offlineServerId).catch((err) => {
+      logger3.error(`Failed to recover rooms from ${offlineServerId}:`, err);
+    });
+  }
+  /**
+   * @zh 尝试从离线服务器恢复房间
+   * @en Try to recover rooms from offline server
+   */
+  async _tryRecoverRoomsFromServer(offlineServerId) {
+    if (this._rooms.size >= this._config.capacity) {
+      logger3.warn(`Cannot recover rooms: server at capacity (${this._rooms.size}/${this._config.capacity})`);
+      return;
+    }
+    const rooms = await this._adapter.queryRooms({
+      serverId: offlineServerId
+    });
+    if (rooms.length === 0) {
+      logger3.info(`No rooms to recover from ${offlineServerId}`);
+      return;
+    }
+    logger3.info(`Attempting to recover ${rooms.length} rooms from ${offlineServerId}`);
+    for (const roomReg of rooms) {
+      if (this._rooms.size >= this._config.capacity) {
+        logger3.warn("Reached capacity during recovery, stopping");
+        break;
+      }
+      const lockKey = `failover:${roomReg.roomId}`;
+      const acquired = await this._adapter.acquireLock(lockKey, this._config.migrationTimeout);
+      if (!acquired) {
+        continue;
+      }
+      try {
+        const success = await this.restoreFromSnapshot(roomReg.roomId);
+        if (success) {
+          logger3.info(`Successfully recovered room ${roomReg.roomId}`);
+          await this._adapter.publish({
+            type: "room:migrated",
+            serverId: this._serverId,
+            roomId: roomReg.roomId,
+            payload: {
+              fromServer: offlineServerId,
+              toServer: this._serverId
+            },
+            timestamp: Date.now()
+          });
+        }
+      } finally {
+        await this._adapter.releaseLock(lockKey);
+      }
+    }
+  }
+  /**
+   * @zh 处理跨服务器房间消息
+   * @en Handle cross-server room message
+   */
+  _handleRoomMessage(event) {
+    if (!event.roomId) return;
+    const room = this._rooms.get(event.roomId);
+    if (!room) return;
+    const payload = event.payload;
+    if (payload.playerId) {
+      room._handleMessage(payload.messageType, payload.data, payload.playerId);
+    }
+  }
+  /**
+   * @zh 统计总玩家数
+   * @en Count total players
+   */
+  _countTotalPlayers() {
+    let count = 0;
+    for (const room of this._rooms.values()) {
+      count += room.players.length;
+    }
+    return count;
+  }
+  /**
+   * @zh 根据房间实例获取定义
+   * @en Get definition by room instance
+   */
+  _getDefinitionByRoom(room) {
+    for (const [name, def] of this._definitions) {
+      if (room instanceof def.roomClass) {
+        return {
+          name
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * @zh 休眠指定时间
+   * @en Sleep for specified time
+   */
+  _sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  /**
+   * @zh 向其他服务器的房间发送消息
+   * @en Send message to room on another server
+   *
+   * @param roomId - 房间 ID | Room ID
+   * @param messageType - 消息类型 | Message type
+   * @param data - 消息数据 | Message data
+   * @param playerId - 发送者玩家 ID（可选）| Sender player ID (optional)
+   */
+  async sendToRemoteRoom(roomId, messageType, data, playerId) {
+    await this._adapter.sendToRoom(roomId, messageType, data, playerId);
+  }
+  /**
+   * @zh 获取所有在线服务器
+   * @en Get all online servers
+   */
+  async getServers() {
+    return this._adapter.getServers();
+  }
+  /**
+   * @zh 查询分布式房间
+   * @en Query distributed rooms
+   */
+  async queryDistributedRooms(query) {
+    return this._adapter.queryRooms(query);
+  }
+};
+__name(_DistributedRoomManager, "DistributedRoomManager");
+var DistributedRoomManager = _DistributedRoomManager;
+
+// src/distributed/adapters/MemoryAdapter.ts
+var _MemoryAdapter = class _MemoryAdapter {
+  constructor(config = {}) {
+    __publicField(this, "_config");
+    __publicField(this, "_connected", false);
+    // 存储
+    __publicField(this, "_servers", /* @__PURE__ */ new Map());
+    __publicField(this, "_rooms", /* @__PURE__ */ new Map());
+    __publicField(this, "_snapshots", /* @__PURE__ */ new Map());
+    __publicField(this, "_locks", /* @__PURE__ */ new Map());
+    // 事件订阅
+    __publicField(this, "_subscribers", /* @__PURE__ */ new Map());
+    __publicField(this, "_subscriberId", 0);
+    // TTL 检查定时器
+    __publicField(this, "_ttlCheckTimer", null);
+    this._config = {
+      serverTtl: 15e3,
+      enableTtlCheck: true,
+      ttlCheckInterval: 5e3,
+      ...config
+    };
+  }
+  // =========================================================================
+  // 生命周期 | Lifecycle
+  // =========================================================================
+  async connect() {
+    if (this._connected) return;
+    this._connected = true;
+    if (this._config.enableTtlCheck) {
+      this._ttlCheckTimer = setInterval(() => this._checkServerTtl(), this._config.ttlCheckInterval);
+    }
+  }
+  async disconnect() {
+    if (!this._connected) return;
+    if (this._ttlCheckTimer) {
+      clearInterval(this._ttlCheckTimer);
+      this._ttlCheckTimer = null;
+    }
+    this._connected = false;
+    this._servers.clear();
+    this._rooms.clear();
+    this._snapshots.clear();
+    this._locks.clear();
+    this._subscribers.clear();
+  }
+  isConnected() {
+    return this._connected;
+  }
+  // =========================================================================
+  // 服务器注册 | Server Registry
+  // =========================================================================
+  async registerServer(server) {
+    this._ensureConnected();
+    this._servers.set(server.serverId, {
+      ...server,
+      lastHeartbeat: Date.now()
+    });
+    await this.publish({
+      type: "server:online",
+      serverId: server.serverId,
+      payload: server,
+      timestamp: Date.now()
+    });
+  }
+  async unregisterServer(serverId) {
+    this._ensureConnected();
+    const server = this._servers.get(serverId);
+    if (!server) return;
+    this._servers.delete(serverId);
+    for (const [roomId, room] of this._rooms) {
+      if (room.serverId === serverId) {
+        this._rooms.delete(roomId);
+      }
+    }
+    await this.publish({
+      type: "server:offline",
+      serverId,
+      payload: {
+        serverId
+      },
+      timestamp: Date.now()
+    });
+  }
+  async heartbeat(serverId) {
+    this._ensureConnected();
+    const server = this._servers.get(serverId);
+    if (server) {
+      server.lastHeartbeat = Date.now();
+    }
+  }
+  async getServers() {
+    this._ensureConnected();
+    return Array.from(this._servers.values()).filter((s) => s.status === "online");
+  }
+  async getServer(serverId) {
+    this._ensureConnected();
+    return this._servers.get(serverId) ?? null;
+  }
+  async updateServer(serverId, updates) {
+    this._ensureConnected();
+    const server = this._servers.get(serverId);
+    if (server) {
+      Object.assign(server, updates);
+    }
+  }
+  // =========================================================================
+  // 房间注册 | Room Registry
+  // =========================================================================
+  async registerRoom(room) {
+    this._ensureConnected();
+    this._rooms.set(room.roomId, {
+      ...room
+    });
+    const server = this._servers.get(room.serverId);
+    if (server) {
+      server.roomCount = this._countRoomsByServer(room.serverId);
+    }
+    await this.publish({
+      type: "room:created",
+      serverId: room.serverId,
+      roomId: room.roomId,
+      payload: {
+        roomType: room.roomType
+      },
+      timestamp: Date.now()
+    });
+  }
+  async unregisterRoom(roomId) {
+    this._ensureConnected();
+    const room = this._rooms.get(roomId);
+    if (!room) return;
+    this._rooms.delete(roomId);
+    this._snapshots.delete(roomId);
+    const server = this._servers.get(room.serverId);
+    if (server) {
+      server.roomCount = this._countRoomsByServer(room.serverId);
+    }
+    await this.publish({
+      type: "room:disposed",
+      serverId: room.serverId,
+      roomId,
+      payload: {},
+      timestamp: Date.now()
+    });
+  }
+  async updateRoom(roomId, updates) {
+    this._ensureConnected();
+    const room = this._rooms.get(roomId);
+    if (!room) return;
+    Object.assign(room, updates, {
+      updatedAt: Date.now()
+    });
+    await this.publish({
+      type: "room:updated",
+      serverId: room.serverId,
+      roomId,
+      payload: updates,
+      timestamp: Date.now()
+    });
+  }
+  async getRoom(roomId) {
+    this._ensureConnected();
+    return this._rooms.get(roomId) ?? null;
+  }
+  async queryRooms(query) {
+    this._ensureConnected();
+    let results = Array.from(this._rooms.values());
+    if (query.roomType) {
+      results = results.filter((r) => r.roomType === query.roomType);
+    }
+    if (query.hasSpace) {
+      results = results.filter((r) => r.playerCount < r.maxPlayers);
+    }
+    if (query.notLocked) {
+      results = results.filter((r) => !r.isLocked);
+    }
+    if (query.metadata) {
+      results = results.filter((r) => {
+        for (const [key, value] of Object.entries(query.metadata)) {
+          if (r.metadata[key] !== value) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (query.offset) {
+      results = results.slice(query.offset);
+    }
+    if (query.limit) {
+      results = results.slice(0, query.limit);
+    }
+    return results;
+  }
+  async findAvailableRoom(roomType) {
+    const rooms = await this.queryRooms({
+      roomType,
+      hasSpace: true,
+      notLocked: true,
+      limit: 1
+    });
+    return rooms[0] ?? null;
+  }
+  async getRoomsByServer(serverId) {
+    this._ensureConnected();
+    return Array.from(this._rooms.values()).filter((r) => r.serverId === serverId);
+  }
+  // =========================================================================
+  // 房间状态 | Room State
+  // =========================================================================
+  async saveSnapshot(snapshot) {
+    this._ensureConnected();
+    this._snapshots.set(snapshot.roomId, {
+      ...snapshot
+    });
+  }
+  async loadSnapshot(roomId) {
+    this._ensureConnected();
+    return this._snapshots.get(roomId) ?? null;
+  }
+  async deleteSnapshot(roomId) {
+    this._ensureConnected();
+    this._snapshots.delete(roomId);
+  }
+  // =========================================================================
+  // 发布/订阅 | Pub/Sub
+  // =========================================================================
+  async publish(event) {
+    this._ensureConnected();
+    const wildcardHandlers = this._subscribers.get("*") ?? /* @__PURE__ */ new Set();
+    const typeHandlers = this._subscribers.get(event.type) ?? /* @__PURE__ */ new Set();
+    for (const handler of wildcardHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Event handler error:", error);
+      }
+    }
+    for (const handler of typeHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Event handler error:", error);
+      }
+    }
+  }
+  async subscribe(pattern, handler) {
+    this._ensureConnected();
+    if (!this._subscribers.has(pattern)) {
+      this._subscribers.set(pattern, /* @__PURE__ */ new Set());
+    }
+    this._subscribers.get(pattern).add(handler);
+    return () => {
+      const handlers = this._subscribers.get(pattern);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this._subscribers.delete(pattern);
+        }
+      }
+    };
+  }
+  async sendToRoom(roomId, messageType, data, playerId) {
+    this._ensureConnected();
+    const room = this._rooms.get(roomId);
+    if (!room) return;
+    await this.publish({
+      type: "room:message",
+      serverId: room.serverId,
+      roomId,
+      payload: {
+        messageType,
+        data,
+        playerId
+      },
+      timestamp: Date.now()
+    });
+  }
+  // =========================================================================
+  // 分布式锁 | Distributed Lock
+  // =========================================================================
+  async acquireLock(key, ttlMs) {
+    this._ensureConnected();
+    const now = Date.now();
+    const existing = this._locks.get(key);
+    if (existing && existing.expireAt > now) {
+      return false;
+    }
+    const owner = `lock_${++this._subscriberId}`;
+    this._locks.set(key, {
+      owner,
+      expireAt: now + ttlMs
+    });
+    return true;
+  }
+  async releaseLock(key) {
+    this._ensureConnected();
+    this._locks.delete(key);
+  }
+  async extendLock(key, ttlMs) {
+    this._ensureConnected();
+    const lock = this._locks.get(key);
+    if (!lock) return false;
+    lock.expireAt = Date.now() + ttlMs;
+    return true;
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  _ensureConnected() {
+    if (!this._connected) {
+      throw new Error("MemoryAdapter is not connected");
+    }
+  }
+  _countRoomsByServer(serverId) {
+    let count = 0;
+    for (const room of this._rooms.values()) {
+      if (room.serverId === serverId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async _checkServerTtl() {
+    const now = Date.now();
+    const expiredServers = [];
+    for (const [serverId, server] of this._servers) {
+      if (server.status === "online" && now - server.lastHeartbeat > this._config.serverTtl) {
+        server.status = "offline";
+        expiredServers.push(serverId);
+      }
+    }
+    for (const serverId of expiredServers) {
+      await this.publish({
+        type: "server:offline",
+        serverId,
+        payload: {
+          serverId,
+          reason: "heartbeat_timeout"
+        },
+        timestamp: now
+      });
+    }
+  }
+  // =========================================================================
+  // 测试辅助方法 | Test Helper Methods
+  // =========================================================================
+  /**
+   * @zh 清除所有数据（仅用于测试）
+   * @en Clear all data (for testing only)
+   */
+  _clear() {
+    this._servers.clear();
+    this._rooms.clear();
+    this._snapshots.clear();
+    this._locks.clear();
+  }
+  /**
+   * @zh 获取内部状态（仅用于测试）
+   * @en Get internal state (for testing only)
+   */
+  _getState() {
+    return {
+      servers: this._servers,
+      rooms: this._rooms,
+      snapshots: this._snapshots
+    };
+  }
+};
+__name(_MemoryAdapter, "MemoryAdapter");
+var MemoryAdapter = _MemoryAdapter;
+var logger4 = createLogger("Server");
+function fileNameToHandlerName(fileName) {
+  const baseName = fileName.replace(/\.(ts|js|mts|mjs)$/, "");
+  return baseName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(fileNameToHandlerName, "fileNameToHandlerName");
+function scanDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files = [];
+  const entries = fs.readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name)) {
+      if (entry.name.startsWith("_") || entry.name.startsWith("index.")) {
+        continue;
+      }
+      files.push(path.join(dir, entry.name));
+    }
+  }
+  return files;
+}
+__name(scanDirectory, "scanDirectory");
+async function loadApiHandlers(apiDir) {
+  const files = scanDirectory(apiDir);
+  const handlers = [];
+  for (const filePath of files) {
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const definition = module.default;
+      if (definition && typeof definition.handler === "function") {
+        const name = fileNameToHandlerName(path.basename(filePath));
+        handlers.push({
+          name,
+          path: filePath,
+          definition
+        });
+      }
+    } catch (err) {
+      logger4.warn(`Failed to load API handler: ${filePath}`, err);
+    }
+  }
+  return handlers;
+}
+__name(loadApiHandlers, "loadApiHandlers");
+async function loadMsgHandlers(msgDir) {
+  const files = scanDirectory(msgDir);
+  const handlers = [];
+  for (const filePath of files) {
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const definition = module.default;
+      if (definition && typeof definition.handler === "function") {
+        const name = fileNameToHandlerName(path.basename(filePath));
+        handlers.push({
+          name,
+          path: filePath,
+          definition
+        });
+      }
+    } catch (err) {
+      logger4.warn(`Failed to load msg handler: ${filePath}`, err);
+    }
+  }
+  return handlers;
+}
+__name(loadMsgHandlers, "loadMsgHandlers");
+function scanDirectoryRecursive(dir, baseDir = dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files = [];
+  const entries = fs.readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...scanDirectoryRecursive(fullPath, baseDir));
+    } else if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name)) {
+      if (entry.name.startsWith("_") || entry.name.startsWith("index.")) {
+        continue;
+      }
+      const relativePath = path.relative(baseDir, fullPath);
+      files.push({
+        filePath: fullPath,
+        relativePath
+      });
+    }
+  }
+  return files;
+}
+__name(scanDirectoryRecursive, "scanDirectoryRecursive");
+function filePathToRoute(relativePath, prefix) {
+  let route = relativePath.replace(/\.(ts|js|mts|mjs)$/, "").replace(/\\/g, "/").replace(/\[(\w+)\]/g, ":$1");
+  if (!route.startsWith("/")) {
+    route = "/" + route;
+  }
+  const fullRoute = prefix.endsWith("/") ? prefix.slice(0, -1) + route : prefix + route;
+  return fullRoute;
+}
+__name(filePathToRoute, "filePathToRoute");
+async function loadHttpHandlers(httpDir, prefix = "/api") {
+  const files = scanDirectoryRecursive(httpDir);
+  const handlers = [];
+  for (const { filePath, relativePath } of files) {
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(fileUrl);
+      const definition = module.default;
+      if (definition && typeof definition.handler === "function") {
+        const route = filePathToRoute(relativePath, prefix);
+        const method = definition.method ?? "POST";
+        handlers.push({
+          route,
+          method,
+          path: filePath,
+          definition
+        });
+      }
+    } catch (err) {
+      logger4.warn(`Failed to load HTTP handler: ${filePath}`, err);
+    }
+  }
+  return handlers;
+}
+__name(loadHttpHandlers, "loadHttpHandlers");
+
+// src/core/server.ts
+var DEFAULT_CONFIG = {
+  port: 3e3,
+  apiDir: "src/api",
+  msgDir: "src/msg",
+  httpDir: "src/http",
+  httpPrefix: "/api",
+  tickRate: 20
+};
+async function createServer(config = {}) {
+  const opts = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  const cwd = process.cwd();
+  const logger5 = createLogger("Server");
+  const apiHandlers = await loadApiHandlers(path.resolve(cwd, opts.apiDir));
+  const msgHandlers = await loadMsgHandlers(path.resolve(cwd, opts.msgDir));
+  const httpDir = config.httpDir ?? opts.httpDir;
+  const httpPrefix = config.httpPrefix ?? opts.httpPrefix;
+  const httpHandlers = await loadHttpHandlers(path.resolve(cwd, httpDir), httpPrefix);
+  if (apiHandlers.length > 0) {
+    logger5.info(`Loaded ${apiHandlers.length} API handlers`);
+  }
+  if (msgHandlers.length > 0) {
+    logger5.info(`Loaded ${msgHandlers.length} message handlers`);
+  }
+  if (httpHandlers.length > 0) {
+    logger5.info(`Loaded ${httpHandlers.length} HTTP handlers`);
+  }
+  const mergedHttpRoutes = {};
+  for (const handler of httpHandlers) {
+    const existingRoute = mergedHttpRoutes[handler.route];
+    if (existingRoute && typeof existingRoute !== "function") {
+      existingRoute[handler.method] = handler.definition.handler;
+    } else {
+      mergedHttpRoutes[handler.route] = {
+        [handler.method]: handler.definition.handler
+      };
+    }
+  }
+  if (config.http) {
+    for (const [route, handlerOrMethods] of Object.entries(config.http)) {
+      if (typeof handlerOrMethods === "function") {
+        mergedHttpRoutes[route] = handlerOrMethods;
+      } else {
+        const existing = mergedHttpRoutes[route];
+        if (existing && typeof existing !== "function") {
+          Object.assign(existing, handlerOrMethods);
+        } else {
+          mergedHttpRoutes[route] = handlerOrMethods;
+        }
+      }
+    }
+  }
+  const hasHttpRoutes = Object.keys(mergedHttpRoutes).length > 0;
+  const distributedConfig = config.distributed;
+  const isDistributed = distributedConfig?.enabled ?? false;
+  const apiDefs = {
+    // 内置 API
+    JoinRoom: rpc.api(),
+    LeaveRoom: rpc.api()
+  };
+  const msgDefs = {
+    // 内置消息（房间消息透传）
+    RoomMessage: rpc.msg(),
+    // 分布式重定向消息
+    $redirect: rpc.msg()
+  };
+  for (const handler of apiHandlers) {
+    apiDefs[handler.name] = rpc.api();
+  }
+  for (const handler of msgHandlers) {
+    msgDefs[handler.name] = rpc.msg();
+  }
+  const protocol = rpc.define({
+    api: apiDefs,
+    msg: msgDefs
+  });
+  let currentTick = 0;
+  let tickInterval = null;
+  let rpcServer = null;
+  let httpServer = null;
+  const sendFn = /* @__PURE__ */ __name((conn, type, data) => {
+    rpcServer?.send(conn, "RoomMessage", {
+      type,
+      data
+    });
+  }, "sendFn");
+  const sendBinaryFn = /* @__PURE__ */ __name((conn, data) => {
+    if (conn && typeof conn.sendBinary === "function") {
+      conn.sendBinary(data);
+    }
+  }, "sendBinaryFn");
+  let roomManager;
+  let distributedManager = null;
+  if (isDistributed && distributedConfig) {
+    const adapter = distributedConfig.adapter ?? new MemoryAdapter();
+    distributedManager = new DistributedRoomManager(adapter, {
+      serverId: distributedConfig.serverId,
+      serverAddress: distributedConfig.serverAddress,
+      serverPort: distributedConfig.serverPort ?? opts.port,
+      heartbeatInterval: distributedConfig.heartbeatInterval,
+      snapshotInterval: distributedConfig.snapshotInterval,
+      enableFailover: distributedConfig.enableFailover,
+      capacity: distributedConfig.capacity
+    }, sendFn, sendBinaryFn);
+    roomManager = distributedManager;
+    logger5.info(`Distributed mode enabled (serverId: ${distributedConfig.serverId})`);
+  } else {
+    roomManager = new RoomManager(sendFn, sendBinaryFn);
+  }
+  const apiMap = {};
+  for (const handler of apiHandlers) {
+    apiMap[handler.name] = handler;
+  }
+  const msgMap = {};
+  for (const handler of msgHandlers) {
+    msgMap[handler.name] = handler;
+  }
+  const gameServer = {
+    get connections() {
+      return rpcServer?.connections ?? [];
+    },
+    get tick() {
+      return currentTick;
+    },
+    get rooms() {
+      return roomManager;
+    },
+    /**
+     * @zh 注册房间类型
+     * @en Define room type
+     */
+    define(name, roomClass) {
+      roomManager.define(name, roomClass);
+    },
+    async start() {
+      const apiHandlersObj = {};
+      apiHandlersObj["JoinRoom"] = async (input, conn) => {
+        const { roomType, roomId, options } = input;
+        if (roomId) {
+          const result = await roomManager.joinById(roomId, conn.id, conn);
+          if (!result) {
+            throw new Error("Failed to join room");
+          }
+          return {
+            roomId: result.room.id,
+            playerId: result.player.id
+          };
+        }
+        if (roomType) {
+          if (distributedManager) {
+            const result2 = await distributedManager.joinOrCreateDistributed(roomType, conn.id, conn, options);
+            if (!result2) {
+              throw new Error("Failed to join or create room");
+            }
+            if ("redirect" in result2) {
+              rpcServer?.send(conn, "$redirect", {
+                address: result2.redirect,
+                roomType
+              });
+              return {
+                redirect: result2.redirect
+              };
+            }
+            return {
+              roomId: result2.room.id,
+              playerId: result2.player.id
+            };
+          }
+          const result = await roomManager.joinOrCreate(roomType, conn.id, conn, options);
+          if (!result) {
+            throw new Error("Failed to join or create room");
+          }
+          return {
+            roomId: result.room.id,
+            playerId: result.player.id
+          };
+        }
+        throw new Error("roomType or roomId required");
+      };
+      apiHandlersObj["LeaveRoom"] = async (_input, conn) => {
+        await roomManager.leave(conn.id);
+        return {
+          success: true
+        };
+      };
+      for (const [name, handler] of Object.entries(apiMap)) {
+        apiHandlersObj[name] = async (input, conn) => {
+          const ctx = {
+            conn,
+            server: gameServer
+          };
+          const definition = handler.definition;
+          if (definition.schema) {
+            const result = definition.schema.validate(input);
+            if (!result.success) {
+              const pathStr = result.error.path.length > 0 ? ` at "${result.error.path.join(".")}"` : "";
+              throw new Error(`Validation failed${pathStr}: ${result.error.message}`);
+            }
+            return handler.definition.handler(result.data, ctx);
+          }
+          return handler.definition.handler(input, ctx);
+        };
+      }
+      const msgHandlersObj = {};
+      msgHandlersObj["RoomMessage"] = async (data, conn) => {
+        const { type, data: payload } = data;
+        roomManager.handleMessage(conn.id, type, payload);
+      };
+      for (const [name, handler] of Object.entries(msgMap)) {
+        msgHandlersObj[name] = async (data, conn) => {
+          const ctx = {
+            conn,
+            server: gameServer
+          };
+          const definition = handler.definition;
+          if (definition.schema) {
+            const result = definition.schema.validate(data);
+            if (!result.success) {
+              const pathStr = result.error.path.length > 0 ? ` at "${result.error.path.join(".")}"` : "";
+              logger5.warn(`Message validation failed for ${name}${pathStr}: ${result.error.message}`);
+              return;
+            }
+            await handler.definition.handler(result.data, ctx);
+            return;
+          }
+          await handler.definition.handler(data, ctx);
+        };
+      }
+      if (hasHttpRoutes) {
+        const httpRouter = createHttpRouter(mergedHttpRoutes, {
+          cors: config.cors ?? true
+        });
+        httpServer = createServer$1(async (req, res) => {
+          const handled = await httpRouter(req, res);
+          if (!handled) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+              error: "Not Found"
+            }));
+          }
+        });
+        rpcServer = serve(protocol, {
+          server: httpServer,
+          createConnData: /* @__PURE__ */ __name(() => ({}), "createConnData"),
+          onStart: /* @__PURE__ */ __name(() => {
+            logger5.info(`Started on http://localhost:${opts.port}`);
+            opts.onStart?.(opts.port);
+          }, "onStart"),
+          onConnect: /* @__PURE__ */ __name(async (conn) => {
+            await config.onConnect?.(conn);
+          }, "onConnect"),
+          onDisconnect: /* @__PURE__ */ __name(async (conn) => {
+            await roomManager?.leave(conn.id, "disconnected");
+            await config.onDisconnect?.(conn);
+          }, "onDisconnect"),
+          api: apiHandlersObj,
+          msg: msgHandlersObj
+        });
+        await rpcServer.start();
+        await new Promise((resolve2) => {
+          httpServer.listen(opts.port, () => resolve2());
+        });
+      } else {
+        rpcServer = serve(protocol, {
+          port: opts.port,
+          createConnData: /* @__PURE__ */ __name(() => ({}), "createConnData"),
+          onStart: /* @__PURE__ */ __name((p) => {
+            logger5.info(`Started on ws://localhost:${p}`);
+            opts.onStart?.(p);
+          }, "onStart"),
+          onConnect: /* @__PURE__ */ __name(async (conn) => {
+            await config.onConnect?.(conn);
+          }, "onConnect"),
+          onDisconnect: /* @__PURE__ */ __name(async (conn) => {
+            await roomManager?.leave(conn.id, "disconnected");
+            await config.onDisconnect?.(conn);
+          }, "onDisconnect"),
+          api: apiHandlersObj,
+          msg: msgHandlersObj
+        });
+        await rpcServer.start();
+      }
+      if (distributedManager) {
+        await distributedManager.start();
+      }
+      if (opts.tickRate > 0) {
+        tickInterval = setInterval(() => {
+          currentTick++;
+        }, 1e3 / opts.tickRate);
+      }
+    },
+    async stop() {
+      if (tickInterval) {
+        clearInterval(tickInterval);
+        tickInterval = null;
+      }
+      if (distributedManager) {
+        await distributedManager.stop(true);
+      }
+      if (rpcServer) {
+        await rpcServer.stop();
+        rpcServer = null;
+      }
+      if (httpServer) {
+        await new Promise((resolve2, reject) => {
+          httpServer.close((err) => {
+            if (err) reject(err);
+            else resolve2();
+          });
+        });
+        httpServer = null;
+      }
+    },
+    broadcast(name, data) {
+      rpcServer?.broadcast(name, data);
+    },
+    send(conn, name, data) {
+      rpcServer?.send(conn, name, data);
+    }
+  };
+  return gameServer;
+}
+__name(createServer, "createServer");
+
+export { DistributedRoomManager, MemoryAdapter, RoomManager, createHttpRouter, createServer };
+//# sourceMappingURL=chunk-NWZLKNGV.js.map
+//# sourceMappingURL=chunk-NWZLKNGV.js.map