@quake2ts/server 0.0.739 → 0.0.741

package/dist/index.js

@@ -1,1543 +0,0 @@
-// src/net/nodeWsDriver.ts
-import WebSocket from "ws";
-var WebSocketNetDriver = class {
-  constructor() {
-    this.socket = null;
-    this.messageCallback = null;
-    this.closeCallback = null;
-    this.errorCallback = null;
-  }
-  async connect(url) {
-    return new Promise((resolve2, reject) => {
-      try {
-        this.socket = new WebSocket(url);
-        this.socket.binaryType = "arraybuffer";
-        this.socket.onopen = () => {
-          resolve2();
-        };
-        this.socket.onerror = (event) => {
-          const error = new Error("WebSocket connection error " + event.message);
-          if (this.errorCallback) {
-            this.errorCallback(error);
-          }
-          reject(error);
-        };
-        this.socket.onclose = () => {
-          if (this.closeCallback) {
-            this.closeCallback();
-          }
-          this.socket = null;
-        };
-        this.socket.onmessage = (event) => {
-          if (this.messageCallback) {
-            if (event.data instanceof ArrayBuffer) {
-              this.messageCallback(new Uint8Array(event.data));
-            } else if (Buffer.isBuffer(event.data)) {
-              this.messageCallback(new Uint8Array(event.data));
-            } else if (Array.isArray(event.data)) {
-              const totalLength = event.data.reduce((acc, buf) => acc + buf.length, 0);
-              const result = new Uint8Array(totalLength);
-              let offset = 0;
-              for (const buf of event.data) {
-                result.set(buf, offset);
-                offset += buf.length;
-              }
-              this.messageCallback(result);
-            } else {
-              console.warn("Received non-binary message from server", typeof event.data);
-            }
-          }
-        };
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
-  // Method to attach an existing socket (server-side incoming connection)
-  attach(socket) {
-    this.socket = socket;
-    this.socket.binaryType = "arraybuffer";
-    this.socket.onclose = () => {
-      if (this.closeCallback) this.closeCallback();
-      this.socket = null;
-    };
-    this.socket.onerror = (event) => {
-      if (this.errorCallback) this.errorCallback(new Error(event.message));
-    };
-    this.socket.onmessage = (event) => {
-      if (this.messageCallback) {
-        if (event.data instanceof ArrayBuffer) {
-          this.messageCallback(new Uint8Array(event.data));
-        } else if (Buffer.isBuffer(event.data)) {
-          this.messageCallback(new Uint8Array(event.data));
-        } else if (Array.isArray(event.data)) {
-          const totalLength = event.data.reduce((acc, buf) => acc + buf.length, 0);
-          const result = new Uint8Array(totalLength);
-          let offset = 0;
-          for (const buf of event.data) {
-            result.set(buf, offset);
-            offset += buf.length;
-          }
-          this.messageCallback(result);
-        }
-      }
-    };
-  }
-  disconnect() {
-    if (this.socket) {
-      this.socket.close();
-      this.socket = null;
-    }
-  }
-  send(data) {
-    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-      this.socket.send(data);
-    } else {
-      console.warn("Attempted to send data on closed or connecting socket");
-    }
-  }
-  onMessage(callback) {
-    this.messageCallback = callback;
-  }
-  onClose(callback) {
-    this.closeCallback = callback;
-  }
-  onError(callback) {
-    this.errorCallback = callback;
-  }
-  isConnected() {
-    return this.socket !== null && this.socket.readyState === WebSocket.OPEN;
-  }
-};
-
-// src/dedicated.ts
-import { createGame, MulticastType, Solid } from "@quake2ts/game";
-
-// src/client.ts
-import { UPDATE_BACKUP, NetChan } from "@quake2ts/shared";
-var ClientState = /* @__PURE__ */ ((ClientState2) => {
-  ClientState2[ClientState2["Free"] = 0] = "Free";
-  ClientState2[ClientState2["Zombie"] = 1] = "Zombie";
-  ClientState2[ClientState2["Connected"] = 2] = "Connected";
-  ClientState2[ClientState2["Spawned"] = 3] = "Spawned";
-  ClientState2[ClientState2["Active"] = 4] = "Active";
-  return ClientState2;
-})(ClientState || {});
-function createClient(index, net) {
-  const frames = [];
-  for (let i = 0; i < UPDATE_BACKUP; i++) {
-    frames.push({
-      areaBytes: 0,
-      areaBits: new Uint8Array(0),
-      // Size depends on map areas
-      playerState: createEmptyPlayerState(),
-      numEntities: 0,
-      firstEntity: 0,
-      sentTime: 0,
-      entities: [],
-      packetCRC: 0
-    });
-  }
-  const netchan = new NetChan();
-  netchan.setup(Math.floor(Math.random() * 65536));
-  return {
-    index,
-    state: 2 /* Connected */,
-    net,
-    netchan,
-    userInfo: "",
-    lastFrame: 0,
-    lastCmd: createEmptyUserCommand(),
-    commandMsec: 0,
-    frameLatency: [],
-    ping: 0,
-    messageSize: [],
-    rate: 25e3,
-    // Default rate
-    suppressCount: 0,
-    edict: null,
-    name: `Player ${index}`,
-    messageLevel: 0,
-    datagram: new Uint8Array(0),
-    frames,
-    downloadSize: 0,
-    downloadCount: 0,
-    lastMessage: 0,
-    lastConnect: Date.now(),
-    challenge: 0,
-    messageQueue: [],
-    lastPacketEntities: [],
-    commandQueue: [],
-    lastCommandTime: 0,
-    commandCount: 0
-  };
-}
-function createEmptyUserCommand() {
-  return {
-    msec: 0,
-    buttons: 0,
-    angles: { x: 0, y: 0, z: 0 },
-    forwardmove: 0,
-    sidemove: 0,
-    upmove: 0,
-    sequence: 0,
-    lightlevel: 0,
-    impulse: 0
-  };
-}
-function createEmptyPlayerState() {
-  return {
-    origin: { x: 0, y: 0, z: 0 },
-    velocity: { x: 0, y: 0, z: 0 },
-    viewAngles: { x: 0, y: 0, z: 0 },
-    onGround: false,
-    waterLevel: 0,
-    watertype: 0,
-    mins: { x: -16, y: -16, z: -24 },
-    maxs: { x: 16, y: 16, z: 32 },
-    damageAlpha: 0,
-    damageIndicators: [],
-    blend: [0, 0, 0, 0],
-    // Stubs for new fields
-    stats: [],
-    kick_angles: { x: 0, y: 0, z: 0 },
-    kick_origin: { x: 0, y: 0, z: 0 },
-    gunoffset: { x: 0, y: 0, z: 0 },
-    gunangles: { x: 0, y: 0, z: 0 },
-    gunindex: 0,
-    pm_type: 0,
-    pm_time: 0,
-    pm_flags: 0,
-    gun_frame: 0,
-    rdflags: 0,
-    fov: 90,
-    renderfx: 0
-  };
-}
-
-// src/protocol.ts
-import { ClientCommand } from "@quake2ts/shared";
-var ClientMessageParser = class {
-  constructor(stream, handler) {
-    this.stream = stream;
-    this.handler = handler;
-  }
-  parseMessage() {
-    while (this.stream.hasMore()) {
-      const cmdId = this.stream.readByte();
-      if (cmdId === -1) break;
-      switch (cmdId) {
-        case ClientCommand.move:
-          this.parseMove();
-          break;
-        case ClientCommand.userinfo:
-          this.parseUserInfo();
-          break;
-        case ClientCommand.stringcmd:
-          this.parseStringCmd();
-          break;
-        case ClientCommand.nop:
-          this.handler.onNop();
-          break;
-        default:
-          console.warn(`Unknown client command: ${cmdId}`);
-          this.handler.onBad();
-          return;
-      }
-    }
-  }
-  parseMove() {
-    const checksum = this.stream.readByte();
-    const lastFrame = this.stream.readLong();
-    const msec = this.stream.readByte();
-    const buttons = this.stream.readByte();
-    const angles = {
-      x: this.stream.readShort() * (360 / 65536),
-      y: this.stream.readShort() * (360 / 65536),
-      z: this.stream.readShort() * (360 / 65536)
-    };
-    const forwardmove = this.stream.readShort();
-    const sidemove = this.stream.readShort();
-    const upmove = this.stream.readShort();
-    const impulse = this.stream.readByte();
-    const lightlevel = this.stream.readByte();
-    const userCmd = {
-      msec,
-      buttons,
-      angles,
-      forwardmove,
-      sidemove,
-      upmove,
-      impulse,
-      lightlevel,
-      sequence: 0
-      // Server doesn't read sequence from packet body in standard protocol, it tracks it
-    };
-    this.handler.onMove(checksum, lastFrame, userCmd);
-  }
-  parseUserInfo() {
-    const info = this.stream.readString();
-    this.handler.onUserInfo(info);
-  }
-  parseStringCmd() {
-    const cmd = this.stream.readString();
-    this.handler.onStringCmd(cmd);
-  }
-};
-
-// src/dedicated.ts
-import { BinaryWriter as BinaryWriter2, ServerCommand as ServerCommand2, BinaryStream as BinaryStream2, traceBox, UPDATE_BACKUP as UPDATE_BACKUP2, MAX_CONFIGSTRINGS as MAX_CONFIGSTRINGS2, MAX_EDICTS, CollisionEntityIndex, inPVS, inPHS, crc8, ConfigStringIndex } from "@quake2ts/shared";
-import { parseBsp, PakArchive } from "@quake2ts/engine";
-import fs from "fs/promises";
-import * as path from "path";
-import { createPlayerInventory, createPlayerWeaponStates } from "@quake2ts/game";
-
-// src/server.ts
-var ServerState = /* @__PURE__ */ ((ServerState2) => {
-  ServerState2[ServerState2["Dead"] = 0] = "Dead";
-  ServerState2[ServerState2["Loading"] = 1] = "Loading";
-  ServerState2[ServerState2["Game"] = 2] = "Game";
-  ServerState2[ServerState2["Cinematic"] = 3] = "Cinematic";
-  ServerState2[ServerState2["Demo"] = 4] = "Demo";
-  ServerState2[ServerState2["Pic"] = 5] = "Pic";
-  return ServerState2;
-})(ServerState || {});
-
-// src/dedicated.ts
-import { writeDeltaEntity, writeRemoveEntity } from "@quake2ts/shared";
-
-// src/protocol/player.ts
-import { writePlayerState } from "@quake2ts/shared";
-
-// src/protocol/write.ts
-import { ServerCommand, TempEntity } from "@quake2ts/shared";
-function writeServerCommand(writer, event, ...args) {
-  writer.writeByte(event);
-  switch (event) {
-    case ServerCommand.print: {
-      const level = args[0];
-      const text = args[1];
-      writer.writeByte(level);
-      writer.writeString(text);
-      break;
-    }
-    case ServerCommand.centerprint: {
-      const text = args[0];
-      writer.writeString(text);
-      break;
-    }
-    case ServerCommand.stufftext: {
-      const text = args[0];
-      writer.writeString(text);
-      break;
-    }
-    case ServerCommand.sound: {
-      const flags = args[0];
-      const soundNum = args[1];
-      const volume = args[2];
-      const attenuation = args[3];
-      const offset = args[4];
-      const ent = args[5];
-      const pos = args[6];
-      writer.writeByte(flags);
-      writer.writeByte(soundNum);
-      if (flags & 1) {
-        writer.writeByte(volume || 0);
-      }
-      if (flags & 2) {
-        writer.writeByte(attenuation || 0);
-      }
-      if (flags & 16) {
-        writer.writeByte(offset || 0);
-      }
-      if (flags & 8) {
-        writer.writeShort(ent || 0);
-      }
-      if (flags & 4) {
-        if (pos) {
-          writer.writePos(pos);
-        } else {
-          writer.writePos({ x: 0, y: 0, z: 0 });
-        }
-      }
-      break;
-    }
-    case ServerCommand.muzzleflash: {
-      const entIndex = args[0];
-      const flashType = args[1];
-      writer.writeShort(entIndex);
-      writer.writeByte(flashType);
-      break;
-    }
-    case ServerCommand.temp_entity: {
-      const type = args[0];
-      writer.writeByte(type);
-      writeTempEntity(writer, type, args.slice(1));
-      break;
-    }
-    default:
-      console.warn(`writeServerCommand: Unhandled command ${event}`);
-      break;
-  }
-}
-function writeTempEntity(writer, type, args) {
-  switch (type) {
-    case TempEntity.ROCKET_EXPLOSION:
-    case TempEntity.GRENADE_EXPLOSION:
-    case TempEntity.EXPLOSION1:
-    case TempEntity.EXPLOSION2:
-    case TempEntity.ROCKET_EXPLOSION_WATER:
-    case TempEntity.GRENADE_EXPLOSION_WATER:
-    case TempEntity.BFG_EXPLOSION:
-    case TempEntity.BFG_BIGEXPLOSION:
-    case TempEntity.PLASMA_EXPLOSION:
-    case TempEntity.PLAIN_EXPLOSION:
-    case TempEntity.TRACKER_EXPLOSION:
-    case TempEntity.EXPLOSION1_BIG:
-    case TempEntity.EXPLOSION1_NP:
-    case TempEntity.EXPLOSION1_NL:
-    case TempEntity.EXPLOSION2_NL:
-    case TempEntity.BERSERK_SLAM:
-      writer.writePos(args[0]);
-      break;
-    case TempEntity.BLASTER:
-    case TempEntity.FLECHETTE:
-      writer.writePos(args[0]);
-      writer.writeDir(args[1]);
-      break;
-    case TempEntity.RAILTRAIL:
-    case TempEntity.DEBUGTRAIL:
-    case TempEntity.BUBBLETRAIL:
-    case TempEntity.BUBBLETRAIL2:
-    case TempEntity.BFG_LASER:
-    case TempEntity.LIGHTNING_BEAM:
-    case TempEntity.LIGHTNING:
-      writer.writePos(args[0]);
-      writer.writePos(args[1]);
-      break;
-    case TempEntity.LASER_SPARKS:
-    case TempEntity.WELDING_SPARKS:
-    case TempEntity.TUNNEL_SPARKS:
-    case TempEntity.ELECTRIC_SPARKS:
-    case TempEntity.HEATBEAM_SPARKS:
-    case TempEntity.HEATBEAM_STEAM:
-    case TempEntity.STEAM:
-      writer.writeByte(args[0]);
-      writer.writePos(args[1]);
-      writer.writeDir(args[2]);
-      writer.writeByte(args[3] || 0);
-      break;
-    case TempEntity.PARASITE_ATTACK:
-    case TempEntity.MEDIC_CABLE_ATTACK:
-      const ent = args[0];
-      writer.writeShort(ent ? ent.index : 0);
-      writer.writePos(args[1]);
-      writer.writePos(args[2]);
-      break;
-    case TempEntity.GUNSHOT:
-    case TempEntity.BLOOD:
-    case TempEntity.SPARKS:
-    case TempEntity.BULLET_SPARKS:
-    case TempEntity.SCREEN_SPARKS:
-    case TempEntity.SHIELD_SPARKS:
-      writer.writePos(args[0]);
-      writer.writeDir(args[1]);
-      break;
-    case TempEntity.SPLASH:
-    case TempEntity.POWER_SPLASH:
-    case TempEntity.WIDOWSPLASH:
-      writer.writeByte(args[0]);
-      writer.writePos(args[1]);
-      writer.writeDir(args[2]);
-      writer.writeByte(args[3] || 0);
-      break;
-    default:
-      console.warn(`writeTempEntity: Unhandled TempEntity ${type}`);
-      break;
-  }
-}
-
-// src/dedicated.ts
-import { lerpAngle } from "@quake2ts/shared";
-
-// src/transports/websocket.ts
-import { WebSocketServer } from "ws";
-var WebSocketTransport = class {
-  constructor() {
-    this.wss = null;
-    this.connectionCallback = null;
-    this.errorCallback = null;
-  }
-  async listen(port) {
-    return new Promise((resolve2) => {
-      this.wss = new WebSocketServer({ port });
-      this.wss.on("listening", () => resolve2());
-      this.wss.on("connection", (ws, req) => {
-        const driver = new WebSocketNetDriver();
-        driver.attach(ws);
-        if (this.connectionCallback) {
-          this.connectionCallback(driver, req);
-        }
-      });
-      this.wss.on("error", (err) => {
-        if (this.errorCallback) this.errorCallback(err);
-      });
-    });
-  }
-  close() {
-    if (this.wss) {
-      this.wss.close();
-      this.wss = null;
-    }
-  }
-  onConnection(callback) {
-    this.connectionCallback = callback;
-  }
-  onError(callback) {
-    this.errorCallback = callback;
-  }
-};
-
-// src/dedicated.ts
-var DEFAULT_MAX_CLIENTS = 16;
-var FRAME_RATE = 10;
-var FRAME_TIME_MS = 1e3 / FRAME_RATE;
-var DedicatedServer = class {
-  constructor(optionsOrPort = {}) {
-    this.game = null;
-    this.frameTimeout = null;
-    this.entityIndex = null;
-    // History buffer: Map<EntityIndex, HistoryArray>
-    this.history = /* @__PURE__ */ new Map();
-    this.backup = /* @__PURE__ */ new Map();
-    const options = typeof optionsOrPort === "number" ? { port: optionsOrPort } : optionsOrPort;
-    this.options = {
-      port: 27910,
-      maxPlayers: DEFAULT_MAX_CLIENTS,
-      deathmatch: true,
-      ...options
-    };
-    this.transport = this.options.transport || new WebSocketTransport();
-    this.svs = {
-      initialized: false,
-      realTime: 0,
-      mapCmd: "",
-      spawnCount: 0,
-      clients: new Array(this.options.maxPlayers).fill(null),
-      lastHeartbeat: 0,
-      challenges: []
-    };
-    this.sv = {
-      state: 0 /* Dead */,
-      attractLoop: false,
-      loadGame: false,
-      startTime: 0,
-      // Initialize startTime
-      time: 0,
-      frame: 0,
-      name: "",
-      collisionModel: null,
-      configStrings: new Array(MAX_CONFIGSTRINGS2).fill(""),
-      baselines: new Array(MAX_EDICTS).fill(null),
-      multicastBuf: new Uint8Array(0)
-    };
-    this.entityIndex = new CollisionEntityIndex();
-  }
-  setTransport(transport) {
-    if (this.svs.initialized) {
-      throw new Error("Cannot set transport after server started");
-    }
-    this.transport = transport;
-  }
-  async startServer(mapName) {
-    const map = mapName || this.options.mapName;
-    if (!map) {
-      throw new Error("No map specified");
-    }
-    await this.start(map);
-  }
-  stopServer() {
-    this.stop();
-  }
-  kickPlayer(clientId) {
-    if (clientId < 0 || clientId >= this.svs.clients.length) return;
-    const client = this.svs.clients[clientId];
-    if (client && client.state >= 2 /* Connected */) {
-      console.log(`Kicking client ${clientId}`);
-      if (client.netchan) {
-        const writer = new BinaryWriter2();
-        writer.writeByte(ServerCommand2.print);
-        writer.writeByte(2);
-        writer.writeString("Kicked by server.\n");
-        try {
-          const packet = client.netchan.transmit(writer.getData());
-          client.net.send(packet);
-        } catch (e) {
-        }
-      }
-      this.dropClient(client);
-    }
-  }
-  async changeMap(mapName) {
-    console.log(`Changing map to ${mapName}`);
-    this.multicast(
-      { x: 0, y: 0, z: 0 },
-      MulticastType.All,
-      ServerCommand2.print,
-      2,
-      `Changing map to ${mapName}...
-`
-    );
-    if (this.frameTimeout) clearTimeout(this.frameTimeout);
-    this.sv.state = 1 /* Loading */;
-    this.sv.collisionModel = null;
-    this.sv.time = 0;
-    this.sv.frame = 0;
-    this.sv.configStrings.fill("");
-    this.sv.baselines.fill(null);
-    this.history.clear();
-    this.entityIndex = new CollisionEntityIndex();
-    await this.loadMap(mapName);
-    this.initGame();
-    for (const client of this.svs.clients) {
-      if (client && client.state >= 2 /* Connected */) {
-        client.edict = null;
-        client.state = 2 /* Connected */;
-        this.sendServerData(client);
-        client.netchan.writeReliableByte(ServerCommand2.stufftext);
-        client.netchan.writeReliableString(`map ${mapName}
-`);
-        this.handleBegin(client);
-      }
-    }
-    this.runFrame();
-  }
-  getConnectedClients() {
-    const list = [];
-    for (const client of this.svs.clients) {
-      if (client && client.state >= 2 /* Connected */) {
-        list.push({
-          id: client.index,
-          name: "Player",
-          // TODO: Parse userinfo for name
-          ping: client.ping,
-          address: "unknown"
-        });
-      }
-    }
-    return list;
-  }
-  async start(mapName) {
-    console.log(`Starting Dedicated Server on port ${this.options.port}...`);
-    this.sv.name = mapName;
-    this.svs.initialized = true;
-    this.svs.spawnCount++;
-    this.transport.onConnection((driver, info) => {
-      console.log("New connection", info ? `from ${info.socket?.remoteAddress}` : "");
-      this.handleConnection(driver, info);
-    });
-    this.transport.onError((err) => {
-      if (this.onServerError) this.onServerError(err);
-    });
-    await this.transport.listen(this.options.port);
-    await this.loadMap(mapName);
-    this.initGame();
-    this.runFrame();
-    console.log("Server started.");
-  }
-  async loadMap(mapName) {
-    try {
-      console.log(`Loading map ${mapName}...`);
-      this.sv.state = 1 /* Loading */;
-      this.sv.name = mapName;
-      let arrayBuffer;
-      try {
-        await fs.access(mapName);
-        const mapData = await fs.readFile(mapName);
-        arrayBuffer = mapData.buffer.slice(mapData.byteOffset, mapData.byteOffset + mapData.byteLength);
-      } catch (e) {
-        console.log(`Map file ${mapName} not found on disk, checking pak.pak...`);
-        const possiblePakPaths = [
-          path.resolve(process.cwd(), "pak.pak"),
-          path.resolve(process.cwd(), "../pak.pak"),
-          path.resolve(process.cwd(), "../../pak.pak"),
-          path.resolve("baseq2/pak.pak")
-        ];
-        let pakPath = null;
-        for (const p of possiblePakPaths) {
-          try {
-            await fs.access(p);
-            pakPath = p;
-            break;
-          } catch {
-          }
-        }
-        if (!pakPath) {
-          throw new Error(`Map ${mapName} not found and pak.pak not found.`);
-        }
-        const pakBuffer = await fs.readFile(pakPath);
-        const pakArrayBuffer = pakBuffer.buffer.slice(pakBuffer.byteOffset, pakBuffer.byteOffset + pakBuffer.byteLength);
-        const pak = PakArchive.fromArrayBuffer("pak.pak", pakArrayBuffer);
-        const entry = pak.getEntry(mapName);
-        if (!entry) {
-          throw new Error(`Map ${mapName} not found in pak.pak`);
-        }
-        const data = pak.readFile(mapName);
-        arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-      }
-      const bspMap = parseBsp(arrayBuffer);
-      const planes = bspMap.planes.map((p) => {
-        const normal = { x: p.normal[0], y: p.normal[1], z: p.normal[2] };
-        let signbits = 0;
-        if (normal.x < 0) signbits |= 1;
-        if (normal.y < 0) signbits |= 2;
-        if (normal.z < 0) signbits |= 4;
-        return {
-          normal,
-          dist: p.dist,
-          type: p.type,
-          signbits
-        };
-      });
-      const nodes = bspMap.nodes.map((n) => ({
-        plane: planes[n.planeIndex],
-        children: n.children
-      }));
-      const leafBrushes = [];
-      const leaves = bspMap.leafs.map((l, i) => {
-        const brushes2 = bspMap.leafLists.leafBrushes[i];
-        const firstLeafBrush = leafBrushes.length;
-        leafBrushes.push(...brushes2);
-        return {
-          contents: l.contents,
-          cluster: l.cluster,
-          area: l.area,
-          firstLeafBrush,
-          numLeafBrushes: brushes2.length
-        };
-      });
-      const brushes = bspMap.brushes.map((b) => {
-        const sides = [];
-        for (let i = 0; i < b.numSides; i++) {
-          const sideIndex = b.firstSide + i;
-          const bspSide = bspMap.brushSides[sideIndex];
-          const plane = planes[bspSide.planeIndex];
-          const texInfo = bspMap.texInfo[bspSide.texInfo];
-          const surfaceFlags = texInfo ? texInfo.flags : 0;
-          sides.push({
-            plane,
-            surfaceFlags
-          });
-        }
-        return {
-          contents: b.contents,
-          sides,
-          checkcount: 0
-        };
-      });
-      const bmodels = bspMap.models.map((m) => ({
-        mins: { x: m.mins[0], y: m.mins[1], z: m.mins[2] },
-        maxs: { x: m.maxs[0], y: m.maxs[1], z: m.maxs[2] },
-        origin: { x: m.origin[0], y: m.origin[1], z: m.origin[2] },
-        headnode: m.headNode
-      }));
-      let visibility;
-      if (bspMap.visibility) {
-        visibility = {
-          numClusters: bspMap.visibility.numClusters,
-          clusters: bspMap.visibility.clusters
-        };
-      }
-      this.sv.collisionModel = {
-        planes,
-        nodes,
-        leaves,
-        brushes,
-        leafBrushes,
-        bmodels,
-        visibility
-      };
-      console.log(`Map loaded successfully.`);
-    } catch (e) {
-      console.warn("Failed to load map:", e);
-      if (this.onServerError) this.onServerError(e);
-    }
-  }
-  initGame() {
-    this.sv.startTime = Date.now();
-    const imports = {
-      trace: (start, mins, maxs, end, passent, contentmask) => {
-        if (this.entityIndex) {
-          const result = this.entityIndex.trace({
-            start,
-            end,
-            mins: mins || void 0,
-            maxs: maxs || void 0,
-            model: this.sv.collisionModel,
-            passId: passent ? passent.index : void 0,
-            contentMask: contentmask
-          });
-          let hitEntity = null;
-          if (result.entityId !== null && result.entityId !== void 0 && this.game) {
-            hitEntity = this.game.entities.getByIndex(result.entityId) ?? null;
-          }
-          return {
-            allsolid: result.allsolid,
-            startsolid: result.startsolid,
-            fraction: result.fraction,
-            endpos: result.endpos,
-            plane: result.plane || null,
-            surfaceFlags: result.surfaceFlags || 0,
-            contents: result.contents || 0,
-            ent: hitEntity
-          };
-        }
-        const worldResult = this.sv.collisionModel ? traceBox({
-          start,
-          end,
-          mins: mins || void 0,
-          maxs: maxs || void 0,
-          model: this.sv.collisionModel,
-          contentMask: contentmask
-        }) : {
-          fraction: 1,
-          endpos: { ...end },
-          allsolid: false,
-          startsolid: false,
-          plane: null,
-          surfaceFlags: 0,
-          contents: 0
-        };
-        return {
-          allsolid: worldResult.allsolid,
-          startsolid: worldResult.startsolid,
-          fraction: worldResult.fraction,
-          endpos: worldResult.endpos,
-          plane: worldResult.plane || null,
-          surfaceFlags: worldResult.surfaceFlags || 0,
-          contents: worldResult.contents || 0,
-          ent: null
-        };
-      },
-      pointcontents: (p) => 0,
-      linkentity: (ent) => {
-        if (!this.entityIndex) return;
-        this.entityIndex.link({
-          id: ent.index,
-          origin: ent.origin,
-          mins: ent.mins,
-          maxs: ent.maxs,
-          contents: ent.solid === 0 ? 0 : 1,
-          surfaceFlags: 0
-        });
-      },
-      areaEdicts: (mins, maxs) => {
-        if (!this.entityIndex) return [];
-        return this.entityIndex.gatherTriggerTouches({ x: 0, y: 0, z: 0 }, mins, maxs, 4294967295);
-      },
-      multicast: (origin, type, event, ...args) => this.multicast(origin, type, event, ...args),
-      unicast: (ent, reliable, event, ...args) => this.unicast(ent, reliable, event, ...args),
-      configstring: (index, value) => this.SV_SetConfigString(index, value),
-      serverCommand: (cmd) => {
-        console.log(`Server command: ${cmd}`);
-      },
-      setLagCompensation: (active, client, lagMs) => this.setLagCompensation(active, client, lagMs)
-    };
-    this.game = createGame(imports, this, {
-      gravity: { x: 0, y: 0, z: -800 },
-      deathmatch: this.options.deathmatch !== false
-    });
-    this.game.init(0);
-    this.game.spawnWorld();
-    this.populateBaselines();
-    this.sv.state = 2 /* Game */;
-  }
-  populateBaselines() {
-    if (!this.game) return;
-    this.game.entities.forEachEntity((ent) => {
-      if (ent.index >= MAX_EDICTS) return;
-      if (ent.modelindex > 0 || ent.solid !== Solid.Not) {
-        this.sv.baselines[ent.index] = this.entityToState(ent);
-      }
-    });
-  }
-  entityToState(ent) {
-    return {
-      number: ent.index,
-      origin: { ...ent.origin },
-      angles: { ...ent.angles },
-      modelIndex: ent.modelindex,
-      frame: ent.frame,
-      skinNum: ent.skin,
-      effects: ent.effects,
-      renderfx: ent.renderfx,
-      solid: ent.solid,
-      sound: ent.sounds,
-      event: 0
-    };
-  }
-  stop() {
-    if (this.frameTimeout) clearTimeout(this.frameTimeout);
-    this.transport.close();
-    this.game?.shutdown();
-    this.sv.state = 0 /* Dead */;
-  }
-  handleConnection(driver, info) {
-    let clientIndex = -1;
-    for (let i = 0; i < this.options.maxPlayers; i++) {
-      if (this.svs.clients[i] === null || this.svs.clients[i].state === 0 /* Free */) {
-        clientIndex = i;
-        break;
-      }
-    }
-    if (clientIndex === -1) {
-      console.log("Server full, rejecting connection");
-      driver.disconnect();
-      return;
-    }
-    const client = createClient(clientIndex, driver);
-    client.lastMessage = this.sv.frame;
-    client.lastCommandTime = Date.now();
-    this.svs.clients[clientIndex] = client;
-    console.log(`Client ${clientIndex} attached to slot from ${info?.socket?.remoteAddress || "unknown"}`);
-    driver.onMessage((data) => this.onClientMessage(client, data));
-    driver.onClose(() => this.onClientDisconnect(client));
-  }
-  onClientMessage(client, data) {
-    const buffer = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength ? data.buffer : data.slice().buffer;
-    if (buffer instanceof ArrayBuffer) {
-      client.messageQueue.push(new Uint8Array(buffer));
-    } else {
-      client.messageQueue.push(new Uint8Array(buffer));
-    }
-  }
-  onClientDisconnect(client) {
-    console.log(`Client ${client.index} disconnected`);
-    if (client.edict && this.game) {
-      this.game.clientDisconnect(client.edict);
-    }
-    if (this.onClientDisconnected) {
-      this.onClientDisconnected(client.index);
-    }
-    client.state = 0 /* Free */;
-    this.svs.clients[client.index] = null;
-    if (this.entityIndex && client.edict) {
-      this.entityIndex.unlink(client.edict.index);
-    }
-  }
-  dropClient(client) {
-    if (client.net) {
-      client.net.disconnect();
-    }
-  }
-  handleMove(client, cmd, checksum, lastFrame) {
-    if (lastFrame > 0 && lastFrame <= client.lastFrame && lastFrame > client.lastFrame - UPDATE_BACKUP2) {
-      const frameIdx = lastFrame % UPDATE_BACKUP2;
-      const frame = client.frames[frameIdx];
-      if (frame.packetCRC !== checksum) {
-        console.warn(`Client ${client.index} checksum mismatch for frame ${lastFrame}: expected ${frame.packetCRC}, got ${checksum}`);
-      }
-    }
-    client.lastCmd = cmd;
-    client.lastMessage = this.sv.frame;
-    client.commandCount++;
-  }
-  handleUserInfo(client, info) {
-    client.userInfo = info;
-  }
-  handleStringCmd(client, cmd) {
-    console.log(`Client ${client.index} stringcmd: ${cmd}`);
-    if (cmd === "getchallenge") {
-      this.handleGetChallenge(client);
-    } else if (cmd.startsWith("connect ")) {
-      const userInfo = cmd.substring(8);
-      this.handleConnect(client, userInfo);
-    } else if (cmd === "begin") {
-      this.handleBegin(client);
-    } else if (cmd === "status") {
-      this.handleStatus(client);
-    }
-  }
-  handleStatus(client) {
-    let activeClients = 0;
-    for (const c of this.svs.clients) {
-      if (c && c.state >= 2 /* Connected */) {
-        activeClients++;
-      }
-    }
-    let status = `map: ${this.sv.name}
-`;
-    status += `players: ${activeClients} active (${this.options.maxPlayers} max)
-
-`;
-    status += `num score ping name            lastmsg address               qport rate
-`;
-    status += `--- ----- ---- --------------- ------- --------------------- ----- -----
-`;
-    for (const c of this.svs.clients) {
-      if (c && c.state >= 2 /* Connected */) {
-        const score = 0;
-        const ping = 0;
-        const lastMsg = this.sv.frame - c.lastMessage;
-        const address = "unknown";
-        status += `${c.index.toString().padStart(3)} ${score.toString().padStart(5)} ${ping.toString().padStart(4)} ${c.userInfo.substring(0, 15).padEnd(15)} ${lastMsg.toString().padStart(7)} ${address.padEnd(21)} ${c.netchan.qport.toString().padStart(5)} 0
-`;
-      }
-    }
-    const writer = new BinaryWriter2();
-    writer.writeByte(ServerCommand2.print);
-    writer.writeByte(2);
-    writer.writeString(status);
-    const packet = client.netchan.transmit(writer.getData());
-    client.net.send(packet);
-  }
-  handleGetChallenge(client) {
-    const challenge = Math.floor(Math.random() * 1e6) + 1;
-    client.challenge = challenge;
-    const writer = new BinaryWriter2();
-    writer.writeByte(ServerCommand2.stufftext);
-    writer.writeString(`challenge ${challenge}
-`);
-    const packet = client.netchan.transmit(writer.getData());
-    client.net.send(packet);
-  }
-  handleConnect(client, userInfo) {
-    if (!this.game) return;
-    const result = this.game.clientConnect(client.edict || null, userInfo);
-    if (result === true) {
-      client.state = 2 /* Connected */;
-      client.userInfo = userInfo;
-      console.log(`Client ${client.index} connected: ${userInfo}`);
-      if (this.onClientConnected) {
-        this.onClientConnected(client.index, "Player");
-      }
-      try {
-        this.sendServerData(client);
-        client.netchan.writeReliableByte(ServerCommand2.stufftext);
-        client.netchan.writeReliableString("precache\n");
-        const packet = client.netchan.transmit();
-        client.net.send(packet);
-      } catch (e) {
-        console.warn(`Client ${client.index} reliable buffer overflow or connection error`);
-        this.dropClient(client);
-      }
-    } else {
-      console.log(`Client ${client.index} rejected: ${result}`);
-      const writer = new BinaryWriter2();
-      writer.writeByte(ServerCommand2.print);
-      writer.writeByte(2);
-      writer.writeString(`Connection rejected: ${result}
-`);
-      const packet = client.netchan.transmit(writer.getData());
-      client.net.send(packet);
-    }
-  }
-  handleBegin(client) {
-    if (client.state === 2 /* Connected */) {
-      this.spawnClient(client);
-    }
-  }
-  spawnClient(client) {
-    if (!this.game) return;
-    const ent = this.game.clientBegin({
-      inventory: createPlayerInventory(),
-      weaponStates: createPlayerWeaponStates(),
-      buttons: 0,
-      pm_type: 0,
-      pm_time: 0,
-      pm_flags: 0,
-      gun_frame: 0,
-      rdflags: 0,
-      fov: 90,
-      pers: {
-        connected: true,
-        inventory: [],
-        health: 100,
-        max_health: 100,
-        savedFlags: 0,
-        selected_item: 0
-      }
-    });
-    client.edict = ent;
-    client.state = 4 /* Active */;
-    console.log(`Client ${client.index} entered game`);
-  }
-  sendServerData(client) {
-    client.netchan.writeReliableByte(ServerCommand2.serverdata);
-    client.netchan.writeReliableLong(34);
-    client.netchan.writeReliableLong(this.sv.frame);
-    client.netchan.writeReliableByte(0);
-    client.netchan.writeReliableString("baseq2");
-    client.netchan.writeReliableShort(client.index);
-    client.netchan.writeReliableString(this.sv.name || "maps/test.bsp");
-    for (let i = 0; i < MAX_CONFIGSTRINGS2; i++) {
-      if (this.sv.configStrings[i]) {
-        client.netchan.writeReliableByte(ServerCommand2.configstring);
-        client.netchan.writeReliableShort(i);
-        client.netchan.writeReliableString(this.sv.configStrings[i]);
-      }
-    }
-    const baselineWriter = new BinaryWriter2();
-    for (let i = 0; i < MAX_EDICTS; i++) {
-      if (this.sv.baselines[i]) {
-        baselineWriter.reset();
-        baselineWriter.writeByte(ServerCommand2.spawnbaseline);
-        writeDeltaEntity({}, this.sv.baselines[i], baselineWriter, true, true);
-        const data = baselineWriter.getData();
-        for (let j = 0; j < data.length; j++) {
-          client.netchan.writeReliableByte(data[j]);
-        }
-      }
-    }
-  }
-  SV_SetConfigString(index, value) {
-    if (index < 0 || index >= MAX_CONFIGSTRINGS2) return;
-    this.sv.configStrings[index] = value;
-    for (const client of this.svs.clients) {
-      if (client && client.state >= 2 /* Connected */) {
-        if (client.netchan) {
-          try {
-            client.netchan.writeReliableByte(ServerCommand2.configstring);
-            client.netchan.writeReliableShort(index);
-            client.netchan.writeReliableString(value);
-            const packet = client.netchan.transmit();
-            client.net.send(packet);
-          } catch (e) {
-            console.warn(`Client ${client.index} reliable buffer overflow`);
-            this.dropClient(client);
-          }
-        }
-      }
-    }
-  }
-  SV_WriteConfigString(writer, index, value) {
-    writer.writeByte(ServerCommand2.configstring);
-    writer.writeShort(index);
-    writer.writeString(value);
-  }
-  SV_ReadPackets() {
-    for (const client of this.svs.clients) {
-      if (!client || client.state === 0 /* Free */) continue;
-      while (client.messageQueue.length > 0) {
-        const rawData = client.messageQueue.shift();
-        if (!rawData) continue;
-        if (rawData.byteLength >= 10) {
-          const view = new DataView(rawData.buffer, rawData.byteOffset, rawData.byteLength);
-          const incomingQPort = view.getUint16(8, true);
-          if (client.netchan.qport !== incomingQPort) {
-            client.netchan.qport = incomingQPort;
-          }
-        }
-        const data = client.netchan.process(rawData);
-        if (!data) {
-          continue;
-        }
-        if (data.length === 0) {
-          continue;
-        }
-        let buffer;
-        if (data.buffer instanceof ArrayBuffer) {
-          buffer = data.buffer;
-        } else {
-          buffer = new Uint8Array(data).buffer;
-        }
-        const reader = new BinaryStream2(buffer);
-        const parser = new ClientMessageParser(reader, {
-          onMove: (checksum, lastFrame, cmd) => this.handleMove(client, cmd, checksum, lastFrame),
-          onUserInfo: (info) => this.handleUserInfo(client, info),
-          onStringCmd: (cmd) => this.handleStringCmd(client, cmd),
-          onNop: () => {
-          },
-          onBad: () => {
-            console.warn(`Bad command from client ${client.index}`);
-          }
-        });
-        try {
-          parser.parseMessage();
-        } catch (e) {
-          console.error(`Error parsing message from client ${client.index}:`, e);
-        }
-      }
-    }
-  }
-  runFrame() {
-    if (!this.game) return;
-    const startTime = Date.now();
-    this.sv.frame++;
-    this.sv.time += 100;
-    this.SV_ReadPackets();
-    for (const client of this.svs.clients) {
-      if (!client || client.state === 0 /* Free */) continue;
-      if (client.edict && client.edict.client) {
-        client.edict.client.ping = client.ping;
-      }
-      if (client.state >= 2 /* Connected */) {
-        const timeoutFrames = 300;
-        if (this.sv.frame - client.lastMessage > timeoutFrames) {
-          console.log(`Client ${client.index} timed out`);
-          this.dropClient(client);
-          continue;
-        }
-      }
-      if (client && client.state === 4 /* Active */ && client.edict) {
-        const now = Date.now();
-        if (now - client.lastCommandTime >= 1e3) {
-          client.lastCommandTime = now;
-          client.commandCount = 0;
-        }
-        if (client.commandCount > 200) {
-          console.warn(`Client ${client.index} kicked for command flooding (count: ${client.commandCount})`);
-          this.dropClient(client);
-          continue;
-        }
-        this.game.clientThink(client.edict, client.lastCmd);
-      }
-    }
-    const snapshot = this.game.frame({
-      frame: this.sv.frame,
-      deltaMs: FRAME_TIME_MS,
-      nowMs: Date.now()
-    });
-    this.recordHistory();
-    if (snapshot && snapshot.state) {
-      this.SV_SendClientMessages(snapshot.state);
-    }
-    const endTime = Date.now();
-    const elapsed = endTime - startTime;
-    const sleepTime = Math.max(0, FRAME_TIME_MS - elapsed);
-    if (this.sv.state === 2 /* Game */) {
-      this.frameTimeout = setTimeout(() => this.runFrame(), sleepTime);
-    }
-  }
-  SV_SendClientMessages(snapshot) {
-    for (const client of this.svs.clients) {
-      if (client && client.state === 4 /* Active */) {
-        this.SV_SendClientFrame(client, snapshot);
-      }
-    }
-  }
-  SV_SendClientFrame(client, snapshot) {
-    const MTU = 1400;
-    const writer = new BinaryWriter2(MTU);
-    writer.writeByte(ServerCommand2.frame);
-    writer.writeLong(this.sv.frame);
-    let deltaFrame = 0;
-    if (client.lastFrame && client.lastFrame < this.sv.frame && client.lastFrame >= this.sv.frame - UPDATE_BACKUP2) {
-      deltaFrame = client.lastFrame;
-    }
-    writer.writeLong(deltaFrame);
-    writer.writeByte(0);
-    writer.writeByte(0);
-    writer.writeByte(ServerCommand2.playerinfo);
-    const ps = {
-      pm_type: snapshot.pmType,
-      origin: snapshot.origin,
-      velocity: snapshot.velocity,
-      pm_time: snapshot.pm_time,
-      pm_flags: snapshot.pmFlags,
-      gravity: Math.abs(snapshot.gravity.z),
-      delta_angles: snapshot.deltaAngles,
-      viewoffset: { x: 0, y: 0, z: 22 },
-      viewangles: snapshot.viewangles,
-      kick_angles: snapshot.kick_angles,
-      gun_index: snapshot.gunindex,
-      gun_frame: snapshot.gun_frame,
-      gun_offset: snapshot.gunoffset,
-      gun_angles: snapshot.gunangles,
-      blend: snapshot.blend,
-      fov: snapshot.fov,
-      rdflags: snapshot.rdflags,
-      stats: snapshot.stats,
-      watertype: snapshot.watertype
-      // Populate watertype
-    };
-    writePlayerState(writer, ps);
-    writer.writeByte(ServerCommand2.packetentities);
-    const entities = snapshot.packetEntities || [];
-    const currentEntityIds = [];
-    const frameIdx = this.sv.frame % UPDATE_BACKUP2;
-    const currentFrame = client.frames[frameIdx];
-    currentFrame.entities = entities;
-    let oldEntities = [];
-    if (deltaFrame > 0) {
-      const oldFrameIdx = deltaFrame % UPDATE_BACKUP2;
-      oldEntities = client.frames[oldFrameIdx].entities;
-    }
-    for (const entityState of currentFrame.entities) {
-      if (writer.getOffset() > MTU - 200) {
-        console.warn("Packet MTU limit reached, dropping remaining entities");
-        break;
-      }
-      currentEntityIds.push(entityState.number);
-      const oldState = oldEntities.find((e) => e.number === entityState.number);
-      if (oldState) {
-        writeDeltaEntity(oldState, entityState, writer, false, false);
-      } else {
-        writeDeltaEntity({}, entityState, writer, false, true);
-      }
-    }
-    for (const oldId of client.lastPacketEntities) {
-      if (writer.getOffset() > MTU - 10) {
-        console.warn("Packet MTU limit reached, dropping remaining removals");
-        break;
-      }
-      if (!currentEntityIds.includes(oldId)) {
-        writeRemoveEntity(oldId, writer);
-      }
-    }
-    writer.writeShort(0);
-    const frameData = writer.getData();
-    currentFrame.packetCRC = crc8(frameData);
-    const packet = client.netchan.transmit(frameData);
-    client.net.send(packet);
-    client.lastFrame = this.sv.frame;
-    client.lastPacketEntities = currentEntityIds;
-  }
-  // GameEngine Implementation
-  trace(start, end) {
-    return { fraction: 1 };
-  }
-  modelIndex(name) {
-    console.log(`modelIndex(${name}) called`);
-    const start = ConfigStringIndex.Models;
-    const end = ConfigStringIndex.Sounds;
-    for (let i = start + 1; i < end; i++) {
-      if (this.sv.configStrings[i] === name) {
-        return i - start;
-      }
-    }
-    for (let i = start + 1; i < end; i++) {
-      if (!this.sv.configStrings[i]) {
-        this.SV_SetConfigString(i, name);
-        return i - start;
-      }
-    }
-    console.warn(`MAX_MODELS overflow for ${name}`);
-    return 0;
-  }
-  soundIndex(name) {
-    const start = ConfigStringIndex.Sounds;
-    const end = ConfigStringIndex.Images;
-    for (let i = start + 1; i < end; i++) {
-      if (this.sv.configStrings[i] === name) {
-        return i - start;
-      }
-    }
-    for (let i = start + 1; i < end; i++) {
-      if (!this.sv.configStrings[i]) {
-        this.SV_SetConfigString(i, name);
-        return i - start;
-      }
-    }
-    console.warn(`MAX_SOUNDS overflow for ${name}`);
-    return 0;
-  }
-  imageIndex(name) {
-    const start = ConfigStringIndex.Images;
-    const end = ConfigStringIndex.Lights;
-    for (let i = start + 1; i < end; i++) {
-      if (this.sv.configStrings[i] === name) {
-        return i - start;
-      }
-    }
-    for (let i = start + 1; i < end; i++) {
-      if (!this.sv.configStrings[i]) {
-        this.SV_SetConfigString(i, name);
-        return i - start;
-      }
-    }
-    console.warn(`MAX_IMAGES overflow for ${name}`);
-    return 0;
-  }
-  multicast(origin, type, event, ...args) {
-    const writer = new BinaryWriter2();
-    writeServerCommand(writer, event, ...args);
-    const data = writer.getData();
-    const reliable = false;
-    for (const client of this.svs.clients) {
-      if (!client || client.state < 4 /* Active */ || !client.edict) {
-        continue;
-      }
-      let send = false;
-      switch (type) {
-        case MulticastType.All:
-          send = true;
-          break;
-        case MulticastType.Pvs:
-          if (this.sv.collisionModel) {
-            send = inPVS(origin, client.edict.origin, this.sv.collisionModel);
-          } else {
-            send = true;
-          }
-          break;
-        case MulticastType.Phs:
-          if (this.sv.collisionModel) {
-            send = inPHS(origin, client.edict.origin, this.sv.collisionModel);
-          } else {
-            send = true;
-          }
-          break;
-      }
-      if (send) {
-        if (reliable) {
-          try {
-            for (let i = 0; i < data.length; i++) {
-              client.netchan.writeReliableByte(data[i]);
-            }
-          } catch (e) {
-          }
-        } else {
-          const packet = client.netchan.transmit(data);
-          client.net.send(packet);
-        }
-      }
-    }
-  }
-  unicast(ent, reliable, event, ...args) {
-    const client = this.svs.clients.find((c) => c?.edict === ent);
-    if (client && client.state >= 2 /* Connected */) {
-      const writer = new BinaryWriter2();
-      writeServerCommand(writer, event, ...args);
-      const data = writer.getData();
-      if (reliable) {
-        try {
-          for (let i = 0; i < data.length; i++) {
-            client.netchan.writeReliableByte(data[i]);
-          }
-          const packet = client.netchan.transmit();
-          client.net.send(packet);
-        } catch (e) {
-          console.warn(`Client ${client.index} reliable buffer overflow in unicast`);
-          this.dropClient(client);
-        }
-      } else {
-        const packet = client.netchan.transmit(data);
-        client.net.send(packet);
-      }
-    }
-  }
-  configstring(index, value) {
-    this.SV_SetConfigString(index, value);
-  }
-  recordHistory() {
-    if (!this.game) return;
-    const now = Date.now();
-    const HISTORY_MAX_MS = 1e3;
-    this.game.entities.forEachEntity((ent) => {
-      if (ent.solid !== Solid.Not || ent.takedamage) {
-        let hist = this.history.get(ent.index);
-        if (!hist) {
-          hist = [];
-          this.history.set(ent.index, hist);
-        }
-        hist.push({
-          time: now,
-          origin: { ...ent.origin },
-          mins: { ...ent.mins },
-          maxs: { ...ent.maxs },
-          angles: { ...ent.angles }
-        });
-        while (hist.length > 0 && hist[0].time < now - HISTORY_MAX_MS) {
-          hist.shift();
-        }
-      }
-    });
-  }
-  setLagCompensation(active, client, lagMs) {
-    if (!this.game || !this.entityIndex) return;
-    if (active) {
-      if (!client || lagMs === void 0) return;
-      const now = Date.now();
-      const targetTime = now - lagMs;
-      this.game.entities.forEachEntity((ent) => {
-        if (ent === client) return;
-        if (ent.solid === Solid.Not && !ent.takedamage) return;
-        const hist = this.history.get(ent.index);
-        if (!hist || hist.length === 0) return;
-        let i = hist.length - 1;
-        while (i >= 0 && hist[i].time > targetTime) {
-          i--;
-        }
-        if (i < 0) {
-          i = 0;
-        }
-        const s1 = hist[i];
-        const s2 = i + 1 < hist.length ? hist[i + 1] : s1;
-        let frac = 0;
-        if (s1.time !== s2.time) {
-          frac = (targetTime - s1.time) / (s2.time - s1.time);
-        }
-        if (frac < 0) frac = 0;
-        if (frac > 1) frac = 1;
-        const origin = {
-          x: s1.origin.x + (s2.origin.x - s1.origin.x) * frac,
-          y: s1.origin.y + (s2.origin.y - s1.origin.y) * frac,
-          z: s1.origin.z + (s2.origin.z - s1.origin.z) * frac
-        };
-        const angles = {
-          x: lerpAngle(s1.angles.x, s2.angles.x, frac),
-          y: lerpAngle(s1.angles.y, s2.angles.y, frac),
-          z: lerpAngle(s1.angles.z, s2.angles.z, frac)
-        };
-        this.backup.set(ent.index, {
-          origin: { ...ent.origin },
-          mins: { ...ent.mins },
-          maxs: { ...ent.maxs },
-          angles: { ...ent.angles },
-          link: true
-        });
-        ent.origin = origin;
-        ent.angles = angles;
-        ent.mins = {
-          x: s1.mins.x + (s2.mins.x - s1.mins.x) * frac,
-          y: s1.mins.y + (s2.mins.y - s1.mins.y) * frac,
-          z: s1.mins.z + (s2.mins.z - s1.mins.z) * frac
-        };
-        ent.maxs = {
-          x: s1.maxs.x + (s2.maxs.x - s1.maxs.x) * frac,
-          y: s1.maxs.y + (s2.maxs.y - s1.maxs.y) * frac,
-          z: s1.maxs.z + (s2.maxs.z - s1.maxs.z) * frac
-        };
-        this.entityIndex.link({
-          id: ent.index,
-          origin: ent.origin,
-          mins: ent.mins,
-          maxs: ent.maxs,
-          contents: ent.solid === 0 ? 0 : 1,
-          surfaceFlags: 0
-        });
-      });
-    } else {
-      this.backup.forEach((state, id) => {
-        const ent = this.game?.entities.getByIndex(id);
-        if (ent) {
-          ent.origin = state.origin;
-          ent.mins = state.mins;
-          ent.maxs = state.maxs;
-          ent.angles = state.angles;
-          this.entityIndex.link({
-            id: ent.index,
-            origin: ent.origin,
-            mins: ent.mins,
-            maxs: ent.maxs,
-            contents: ent.solid === 0 ? 0 : 1,
-            surfaceFlags: 0
-          });
-        }
-      });
-      this.backup.clear();
-    }
-  }
-};
-function createServer(options = {}) {
-  return new DedicatedServer(options);
-}
-export {
-  ClientMessageParser,
-  ClientState,
-  DedicatedServer,
-  ServerState,
-  WebSocketNetDriver,
-  createClient,
-  createServer
-};