@esengine/server 4.4.0 → 4.5.1

package/dist/chunk-M7VONMZJ.js

@@ -1,938 +0,0 @@
-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/http/router.ts
-var logger = 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) {
-      logger.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");
-var logger2 = 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) {
-      logger2.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) {
-      logger2.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) {
-      logger2.warn(`Failed to load HTTP handler: ${filePath}`, err);
-    }
-  }
-  return handlers;
-}
-__name(loadHttpHandlers, "loadHttpHandlers");
-
-// src/room/RoomManager.ts
-var logger3 = createLogger("Room");
-var _RoomManager = class _RoomManager {
-  constructor(sendFn) {
-    __publicField(this, "_definitions", /* @__PURE__ */ new Map());
-    __publicField(this, "_rooms", /* @__PURE__ */ new Map());
-    __publicField(this, "_playerToRoom", /* @__PURE__ */ new Map());
-    __publicField(this, "_nextRoomId", 1);
-    __publicField(this, "_sendFn");
-    this._sendFn = sendFn;
-  }
-  /**
-   * @zh 注册房间类型
-   * @en Define room type
-   */
-  define(name, roomClass) {
-    this._definitions.set(name, {
-      roomClass
-    });
-  }
-  /**
-   * @zh 创建房间
-   * @en Create room
-   */
-  async create(name, options) {
-    const def = this._definitions.get(name);
-    if (!def) {
-      logger3.warn(`Room type not found: ${name}`);
-      return null;
-    }
-    const roomId = this._generateRoomId();
-    const room = new def.roomClass();
-    room._init({
-      id: roomId,
-      sendFn: this._sendFn,
-      broadcastFn: /* @__PURE__ */ __name((type, data) => {
-        for (const player of room.players) {
-          player.send(type, data);
-        }
-      }, "broadcastFn"),
-      disposeFn: /* @__PURE__ */ __name(() => {
-        this._rooms.delete(roomId);
-      }, "disposeFn")
-    });
-    this._rooms.set(roomId, room);
-    await room._create(options);
-    logger3.info(`Created: ${name} (${roomId})`);
-    return room;
-  }
-  /**
-   * @zh 加入或创建房间
-   * @en Join or create room
-   */
-  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._playerToRoom.set(playerId, room.id);
-    logger3.info(`Player ${playerId} joined ${room.id}`);
-    return {
-      room,
-      player
-    };
-  }
-  /**
-   * @zh 加入指定房间
-   * @en Join specific room
-   */
-  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._playerToRoom.set(playerId, room.id);
-    logger3.info(`Player ${playerId} joined ${room.id}`);
-    return {
-      room,
-      player
-    };
-  }
-  /**
-   * @zh 玩家离开
-   * @en Player leave
-   */
-  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._playerToRoom.delete(playerId);
-    logger3.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);
-  }
-  _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;
-  }
-  _generateRoomId() {
-    return `room_${this._nextRoomId++}`;
-  }
-};
-__name(_RoomManager, "RoomManager");
-var RoomManager = _RoomManager;
-
-// 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 logger4 = 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) {
-    logger4.info(`Loaded ${apiHandlers.length} API handlers`);
-  }
-  if (msgHandlers.length > 0) {
-    logger4.info(`Loaded ${msgHandlers.length} message handlers`);
-  }
-  if (httpHandlers.length > 0) {
-    logger4.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 apiDefs = {
-    // 内置 API
-    JoinRoom: rpc.api(),
-    LeaveRoom: rpc.api()
-  };
-  const msgDefs = {
-    // 内置消息（房间消息透传）
-    RoomMessage: 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 roomManager = new RoomManager((conn, type, data) => {
-    rpcServer?.send(conn, "RoomMessage", {
-      type,
-      data
-    });
-  });
-  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) {
-          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
-          };
-          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
-          };
-          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(() => {
-            logger4.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) => {
-            logger4.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 (opts.tickRate > 0) {
-        tickInterval = setInterval(() => {
-          currentTick++;
-        }, 1e3 / opts.tickRate);
-      }
-    },
-    async stop() {
-      if (tickInterval) {
-        clearInterval(tickInterval);
-        tickInterval = null;
-      }
-      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 { createHttpRouter, createServer };
-//# sourceMappingURL=chunk-M7VONMZJ.js.map
-//# sourceMappingURL=chunk-M7VONMZJ.js.map