@quake2ts/engine 0.0.753 → 0.0.756

package/dist/cjs/index.cjs

@@ -12011,46 +12011,7 @@ _StreamingBuffer.INITIAL_SIZE = 64 * 1024;
 _StreamingBuffer.MAX_STRING_LENGTH = 2048;
 var StreamingBuffer = _StreamingBuffer;
 
-// src/demo/parser.ts
-var PROTOCOL_VERSION_RERELEASE = 2023;
-var U_ORIGIN1 = 1 << 0;
-var U_ORIGIN2 = 1 << 1;
-var U_ANGLE2 = 1 << 2;
-var U_ANGLE3 = 1 << 3;
-var U_FRAME8 = 1 << 4;
-var U_EVENT = 1 << 5;
-var U_REMOVE = 1 << 6;
-var U_MOREBITS1 = 1 << 7;
-var U_NUMBER16 = 1 << 8;
-var U_ORIGIN3 = 1 << 9;
-var U_ANGLE1 = 1 << 10;
-var U_MODEL = 1 << 11;
-var U_RENDERFX8 = 1 << 12;
-var U_ALPHA = 1 << 13;
-var U_EFFECTS8 = 1 << 14;
-var U_MOREBITS2 = 1 << 15;
-var U_SKIN8 = 1 << 16;
-var U_FRAME16 = 1 << 17;
-var U_RENDERFX16 = 1 << 18;
-var U_EFFECTS16 = 1 << 19;
-var U_MODEL2 = 1 << 20;
-var U_MODEL3 = 1 << 21;
-var U_MODEL4 = 1 << 22;
-var U_MOREBITS3 = 1 << 23;
-var U_OLDORIGIN = 1 << 24;
-var U_SKIN16 = 1 << 25;
-var U_SOUND = 1 << 26;
-var U_SOLID = 1 << 27;
-var U_SCALE = 1 << 28;
-var U_INSTANCE_BITS = 1 << 29;
-var U_LOOP_VOLUME = 1 << 30;
-var U_MOREBITS4 = 2147483648 | 0;
-var U_LOOP_ATTENUATION_HIGH = 1 << 0;
-var U_OWNER_HIGH = 1 << 1;
-var U_OLD_FRAME_HIGH = 1 << 2;
-var RECORD_CLIENT = 1;
-var RECORD_SERVER = 2;
-var RECORD_RELAY = 128;
+// src/demo/state.ts
 var createEmptyEntityState = () => ({
   number: 0,
   modelindex: 0,
@@ -12102,6 +12063,575 @@ var createEmptyProtocolPlayerState = () => ({
   team_id: 0,
   watertype: 0
 });
+
+// src/demo/protocol/quake2.ts
+var PROTO34_MAP = {
+  0: shared.ServerCommand.bad,
+  1: shared.ServerCommand.nop,
+  2: shared.ServerCommand.disconnect,
+  3: shared.ServerCommand.reconnect,
+  4: shared.ServerCommand.download,
+  5: shared.ServerCommand.frame,
+  6: shared.ServerCommand.inventory,
+  7: shared.ServerCommand.layout,
+  8: shared.ServerCommand.muzzleflash,
+  9: shared.ServerCommand.temp_entity,
+  10: shared.ServerCommand.sound,
+  11: shared.ServerCommand.print,
+  12: shared.ServerCommand.stufftext,
+  13: shared.ServerCommand.serverdata,
+  14: shared.ServerCommand.configstring,
+  15: shared.ServerCommand.spawnbaseline,
+  16: shared.ServerCommand.centerprint,
+  17: shared.ServerCommand.playerinfo,
+  18: shared.ServerCommand.packetentities,
+  19: shared.ServerCommand.deltapacketentities,
+  20: shared.ServerCommand.muzzleflash2
+};
+var Quake2ProtocolHandler = class {
+  constructor() {
+    this.protocolVersion = 34;
+  }
+  translateCommand(cmd) {
+    if (PROTO34_MAP[cmd] !== void 0) {
+      return PROTO34_MAP[cmd];
+    }
+    return shared.ServerCommand.bad;
+  }
+  parseServerData(stream) {
+    const protocol = stream.readLong();
+    const serverCount = stream.readLong();
+    const attractLoop = stream.readByte();
+    const gameDir = stream.readString();
+    const playerNum = stream.readShort();
+    const levelName = stream.readString();
+    return {
+      protocol,
+      serverCount,
+      attractLoop,
+      gameDir,
+      playerNum,
+      levelName
+    };
+  }
+  parseEntityBits(stream) {
+    let total = stream.readByte();
+    if (total & shared.U_MOREBITS1) total |= stream.readByte() << 8;
+    if (total & shared.U_MOREBITS2) total |= stream.readByte() << 16;
+    if (total & shared.U_MOREBITS3) total |= stream.readByte() << 24;
+    let number;
+    if (total & shared.U_NUMBER16) number = stream.readShort();
+    else number = stream.readByte();
+    return { number, bits: total, bitsHigh: 0 };
+  }
+  parseDelta(from, to, number, bits, bitsHigh, stream) {
+    to.number = from.number;
+    to.modelindex = from.modelindex;
+    to.modelindex2 = from.modelindex2;
+    to.modelindex3 = from.modelindex3;
+    to.modelindex4 = from.modelindex4;
+    to.frame = from.frame;
+    to.skinnum = from.skinnum;
+    to.effects = from.effects;
+    to.renderfx = from.renderfx;
+    to.origin.x = from.origin.x;
+    to.origin.y = from.origin.y;
+    to.origin.z = from.origin.z;
+    to.old_origin.x = from.origin.x;
+    to.old_origin.y = from.origin.y;
+    to.old_origin.z = from.origin.z;
+    to.angles.x = from.angles.x;
+    to.angles.y = from.angles.y;
+    to.angles.z = from.angles.z;
+    to.sound = from.sound;
+    to.event = from.event;
+    to.solid = from.solid;
+    to.number = number;
+    to.bits = bits;
+    if (bits & shared.U_MODEL) to.modelindex = stream.readByte();
+    if (bits & shared.U_MODEL2) to.modelindex2 = stream.readByte();
+    if (bits & shared.U_MODEL3) to.modelindex3 = stream.readByte();
+    if (bits & shared.U_MODEL4) to.modelindex4 = stream.readByte();
+    if (bits & shared.U_FRAME8) to.frame = stream.readByte();
+    if (bits & shared.U_FRAME16) to.frame = stream.readShort();
+    if (bits & shared.U_SKIN8 && bits & shared.U_SKIN16) to.skinnum = stream.readLong();
+    else if (bits & shared.U_SKIN8) to.skinnum = stream.readByte();
+    else if (bits & shared.U_SKIN16) to.skinnum = stream.readShort();
+    if (bits & shared.U_EFFECTS8 && bits & shared.U_EFFECTS16) to.effects = stream.readLong();
+    else if (bits & shared.U_EFFECTS8) to.effects = stream.readByte();
+    else if (bits & shared.U_EFFECTS16) to.effects = stream.readShort();
+    if (bits & shared.U_RENDERFX8 && bits & shared.U_RENDERFX16) to.renderfx = stream.readLong();
+    else if (bits & shared.U_RENDERFX8) to.renderfx = stream.readByte();
+    else if (bits & shared.U_RENDERFX16) to.renderfx = stream.readShort();
+    if (bits & shared.U_ORIGIN1) to.origin.x = stream.readShort() * 0.125;
+    if (bits & shared.U_ORIGIN2) to.origin.y = stream.readShort() * 0.125;
+    if (bits & shared.U_ORIGIN3) to.origin.z = stream.readShort() * 0.125;
+    if (bits & shared.U_ANGLE1) to.angles.x = stream.readByte() * (360 / 256);
+    if (bits & shared.U_ANGLE2) to.angles.y = stream.readByte() * (360 / 256);
+    if (bits & shared.U_ANGLE3) to.angles.z = stream.readByte() * (360 / 256);
+    if (bits & shared.U_OLDORIGIN) {
+      to.old_origin.x = stream.readShort() * 0.125;
+      to.old_origin.y = stream.readShort() * 0.125;
+      to.old_origin.z = stream.readShort() * 0.125;
+    }
+    if (bits & shared.U_SOUND) to.sound = stream.readByte();
+    if (bits & shared.U_EVENT) to.event = stream.readByte();
+    else to.event = 0;
+    if (bits & shared.U_SOLID) to.solid = stream.readShort();
+  }
+  parsePlayerState(stream) {
+    const ps = createEmptyProtocolPlayerState();
+    const flags = stream.readShort();
+    if (flags & 1) ps.pm_type = stream.readByte();
+    if (flags & 2) {
+      ps.origin.x = stream.readShort() * 0.125;
+      ps.origin.y = stream.readShort() * 0.125;
+      ps.origin.z = stream.readShort() * 0.125;
+    }
+    if (flags & 4) {
+      ps.velocity.x = stream.readShort() * 0.125;
+      ps.velocity.y = stream.readShort() * 0.125;
+      ps.velocity.z = stream.readShort() * 0.125;
+    }
+    if (flags & 8) ps.pm_time = stream.readByte();
+    if (flags & 16) ps.pm_flags = stream.readByte();
+    if (flags & 32) ps.gravity = stream.readShort();
+    if (flags & 64) {
+      ps.delta_angles.x = stream.readShort() * (180 / 32768);
+      ps.delta_angles.y = stream.readShort() * (180 / 32768);
+      ps.delta_angles.z = stream.readShort() * (180 / 32768);
+    }
+    if (flags & 128) {
+      ps.viewoffset.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.viewoffset.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.viewoffset.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 256) {
+      ps.viewangles.x = stream.readShort() * (360 / 65536);
+      ps.viewangles.y = stream.readShort() * (360 / 65536);
+      ps.viewangles.z = stream.readShort() * (360 / 65536);
+    }
+    if (flags & 512) {
+      ps.kick_angles.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.kick_angles.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.kick_angles.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 4096) ps.gun_index = stream.readByte();
+    if (flags & 8192) {
+      ps.gun_frame = stream.readByte();
+      ps.gun_offset.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_offset.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_offset.z = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 1024) {
+      ps.blend[0] = stream.readByte();
+      ps.blend[1] = stream.readByte();
+      ps.blend[2] = stream.readByte();
+      ps.blend[3] = stream.readByte();
+    }
+    if (flags & 2048) ps.fov = stream.readByte();
+    if (flags & 16384) ps.rdflags = stream.readByte();
+    if (flags & 32768) ps.watertype = stream.readByte();
+    const statbits = stream.readLong();
+    for (let i = 0; i < 32; i++) {
+      if (statbits & 1 << i) ps.stats[i] = stream.readShort();
+    }
+    return ps;
+  }
+};
+var PROTOCOL_VERSION_RERELEASE = 2023;
+var RereleaseProtocolHandler = class {
+  constructor() {
+    this.protocolVersion = PROTOCOL_VERSION_RERELEASE;
+  }
+  translateCommand(cmd) {
+    return cmd;
+  }
+  parseServerData(stream) {
+    const protocol = stream.readLong();
+    const spawnCount = stream.readLong();
+    const demoType = stream.readByte();
+    const tickRate = stream.readByte();
+    const gameDir = stream.readString();
+    let playerNum = stream.readShort();
+    if (playerNum === -2) {
+      const numSplits = stream.readShort();
+      for (let i = 0; i < numSplits; i++) stream.readShort();
+      playerNum = 0;
+    } else if (playerNum === -1) {
+      playerNum = -1;
+    }
+    const levelName = stream.readString();
+    return {
+      protocol,
+      serverCount: spawnCount,
+      // Map spawnCount to serverCount interface
+      spawnCount,
+      attractLoop: 0,
+      // Not used in rerelease
+      gameDir,
+      playerNum,
+      levelName,
+      tickRate,
+      demoType
+    };
+  }
+  parseEntityBits(stream) {
+    let total = stream.readByte();
+    if (total & shared.U_MOREBITS1) total |= stream.readByte() << 8;
+    if (total & shared.U_MOREBITS2) total |= stream.readByte() << 16;
+    if (total & shared.U_MOREBITS3) total |= stream.readByte() << 24;
+    let bitsHigh = 0;
+    if (total & shared.U_MOREBITS4) bitsHigh = stream.readByte();
+    let number;
+    if (total & shared.U_NUMBER16) number = stream.readShort();
+    else number = stream.readByte();
+    return { number, bits: total, bitsHigh };
+  }
+  parseDelta(from, to, number, bits, bitsHigh, stream) {
+    Object.assign(to, from);
+    to.origin = { ...from.origin };
+    to.old_origin = { ...from.old_origin };
+    to.angles = { ...from.angles };
+    to.number = number;
+    to.bits = bits;
+    to.bitsHigh = bitsHigh;
+    if (bits & shared.U_MODEL) to.modelindex = stream.readByte();
+    if (bits & shared.U_MODEL2) to.modelindex2 = stream.readByte();
+    if (bits & shared.U_MODEL3) to.modelindex3 = stream.readByte();
+    if (bits & shared.U_MODEL4) to.modelindex4 = stream.readByte();
+    if (bits & shared.U_FRAME8) to.frame = stream.readByte();
+    if (bits & shared.U_FRAME16) to.frame = stream.readShort();
+    if (bits & shared.U_SKIN8 && bits & shared.U_SKIN16) to.skinnum = stream.readLong();
+    else if (bits & shared.U_SKIN8) to.skinnum = stream.readByte();
+    else if (bits & shared.U_SKIN16) to.skinnum = stream.readShort();
+    if (bits & shared.U_EFFECTS8 && bits & shared.U_EFFECTS16) to.effects = stream.readLong();
+    else if (bits & shared.U_EFFECTS8) to.effects = stream.readByte();
+    else if (bits & shared.U_EFFECTS16) to.effects = stream.readShort();
+    if (bits & shared.U_RENDERFX8 && bits & shared.U_RENDERFX16) to.renderfx = stream.readLong();
+    else if (bits & shared.U_RENDERFX8) to.renderfx = stream.readByte();
+    else if (bits & shared.U_RENDERFX16) to.renderfx = stream.readShort();
+    if (bits & shared.U_ORIGIN1) to.origin.x = stream.readShort() * 0.125;
+    if (bits & shared.U_ORIGIN2) to.origin.y = stream.readShort() * 0.125;
+    if (bits & shared.U_ORIGIN3) to.origin.z = stream.readShort() * 0.125;
+    if (bits & shared.U_ANGLE1) to.angles.x = stream.readByte() * (360 / 256);
+    if (bits & shared.U_ANGLE2) to.angles.y = stream.readByte() * (360 / 256);
+    if (bits & shared.U_ANGLE3) to.angles.z = stream.readByte() * (360 / 256);
+    if (bits & shared.U_OLDORIGIN) {
+      to.old_origin.x = stream.readShort() * 0.125;
+      to.old_origin.y = stream.readShort() * 0.125;
+      to.old_origin.z = stream.readShort() * 0.125;
+    }
+    if (bits & shared.U_SOUND) to.sound = stream.readByte();
+    if (bits & shared.U_EVENT) to.event = stream.readByte();
+    else to.event = 0;
+    if (bits & shared.U_SOLID) to.solid = stream.readShort();
+    if (bits & shared.U_ALPHA) to.alpha = stream.readByte() / 255;
+    if (bits & shared.U_SCALE) to.scale = stream.readFloat();
+    if (bits & shared.U_INSTANCE_BITS) to.instanceBits = stream.readLong();
+    if (bits & shared.U_LOOP_VOLUME) to.loopVolume = stream.readByte() / 255;
+    if (bitsHigh & shared.U_LOOP_ATTENUATION_HIGH) to.loopAttenuation = stream.readByte() / 255;
+    if (bitsHigh & shared.U_OWNER_HIGH) to.owner = stream.readShort();
+    if (bitsHigh & shared.U_OLD_FRAME_HIGH) to.oldFrame = stream.readShort();
+  }
+  parsePlayerState(stream) {
+    const ps = createEmptyProtocolPlayerState();
+    const flags = stream.readShort();
+    if (flags & 1) ps.pm_type = stream.readByte();
+    if (flags & 2) {
+      ps.origin.x = stream.readShort() * 0.125;
+      ps.origin.y = stream.readShort() * 0.125;
+      ps.origin.z = stream.readShort() * 0.125;
+    }
+    if (flags & 4) {
+      ps.velocity.x = stream.readShort() * 0.125;
+      ps.velocity.y = stream.readShort() * 0.125;
+      ps.velocity.z = stream.readShort() * 0.125;
+    }
+    if (flags & 8) ps.pm_time = stream.readByte();
+    if (flags & 16) ps.pm_flags = stream.readByte();
+    if (flags & 32) ps.gravity = stream.readShort();
+    if (flags & 64) {
+      ps.delta_angles.x = stream.readShort() * (180 / 32768);
+      ps.delta_angles.y = stream.readShort() * (180 / 32768);
+      ps.delta_angles.z = stream.readShort() * (180 / 32768);
+    }
+    if (flags & 128) {
+      ps.viewoffset.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.viewoffset.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.viewoffset.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 256) {
+      ps.viewangles.x = stream.readShort() * (360 / 65536);
+      ps.viewangles.y = stream.readShort() * (360 / 65536);
+      ps.viewangles.z = stream.readShort() * (360 / 65536);
+    }
+    if (flags & 512) {
+      ps.kick_angles.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.kick_angles.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.kick_angles.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 4096) ps.gun_index = stream.readByte();
+    if (flags & 8192) {
+      ps.gun_frame = stream.readByte();
+      ps.gun_offset.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_offset.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_offset.z = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 1024) {
+      ps.blend[0] = stream.readByte();
+      ps.blend[1] = stream.readByte();
+      ps.blend[2] = stream.readByte();
+      ps.blend[3] = stream.readByte();
+    }
+    if (flags & 2048) ps.fov = stream.readByte();
+    if (flags & 16384) ps.rdflags = stream.readByte();
+    if (flags & 32768) ps.watertype = stream.readByte();
+    const statbits = stream.readLong();
+    for (let i = 0; i < 32; i++) {
+      if (statbits & 1 << i) ps.stats[i] = stream.readShort();
+    }
+    return ps;
+  }
+};
+var LegacyProtocolHandler = class {
+  constructor(version = 0) {
+    this.protocolVersion = version;
+  }
+  translateCommand(cmd) {
+    return cmd;
+  }
+  parseServerData(stream) {
+    const protocol = stream.readLong();
+    const serverCount = stream.readLong();
+    const attractLoop = stream.readByte();
+    const gameDir = stream.readString();
+    const playerNum = stream.readShort();
+    const levelName = stream.readString();
+    return {
+      protocol,
+      serverCount,
+      attractLoop,
+      gameDir,
+      playerNum,
+      levelName
+    };
+  }
+  parseEntityBits(stream) {
+    let total = stream.readByte();
+    if (total & shared.U_MOREBITS1) total |= stream.readByte() << 8;
+    if (total & shared.U_MOREBITS2) total |= stream.readByte() << 16;
+    if (total & shared.U_MOREBITS3) total |= stream.readByte() << 24;
+    let number;
+    if (total & shared.U_NUMBER16) number = stream.readShort();
+    else number = stream.readByte();
+    return { number, bits: total, bitsHigh: 0 };
+  }
+  parseDelta(from, to, number, bits, bitsHigh, stream) {
+    to.number = from.number;
+    to.modelindex = from.modelindex;
+    to.modelindex2 = from.modelindex2;
+    to.modelindex3 = from.modelindex3;
+    to.modelindex4 = from.modelindex4;
+    to.frame = from.frame;
+    to.skinnum = from.skinnum;
+    to.effects = from.effects;
+    to.renderfx = from.renderfx;
+    to.origin.x = from.origin.x;
+    to.origin.y = from.origin.y;
+    to.origin.z = from.origin.z;
+    to.old_origin.x = from.origin.x;
+    to.old_origin.y = from.origin.y;
+    to.old_origin.z = from.origin.z;
+    to.angles.x = from.angles.x;
+    to.angles.y = from.angles.y;
+    to.angles.z = from.angles.z;
+    to.sound = from.sound;
+    to.event = from.event;
+    to.solid = from.solid;
+    to.number = number;
+    to.bits = bits;
+    if (bits & shared.U_MODEL) to.modelindex = stream.readByte();
+    if (bits & shared.U_MODEL2) to.modelindex2 = stream.readByte();
+    if (bits & shared.U_MODEL3) to.modelindex3 = stream.readByte();
+    if (bits & shared.U_MODEL4) to.modelindex4 = stream.readByte();
+    if (bits & shared.U_FRAME8) to.frame = stream.readByte();
+    if (bits & shared.U_FRAME16) to.frame = stream.readShort();
+    if (bits & shared.U_SKIN8 && bits & shared.U_SKIN16) to.skinnum = stream.readLong();
+    else if (bits & shared.U_SKIN8) to.skinnum = stream.readByte();
+    else if (bits & shared.U_SKIN16) to.skinnum = stream.readShort();
+    if (bits & shared.U_EFFECTS8 && bits & shared.U_EFFECTS16) to.effects = stream.readLong();
+    else if (bits & shared.U_EFFECTS8) to.effects = stream.readByte();
+    else if (bits & shared.U_EFFECTS16) to.effects = stream.readShort();
+    if (bits & shared.U_RENDERFX8 && bits & shared.U_RENDERFX16) to.renderfx = stream.readLong();
+    else if (bits & shared.U_RENDERFX8) to.renderfx = stream.readByte();
+    else if (bits & shared.U_RENDERFX16) to.renderfx = stream.readShort();
+    if (bits & shared.U_ORIGIN1) to.origin.x = stream.readShort() * 0.125;
+    if (bits & shared.U_ORIGIN2) to.origin.y = stream.readShort() * 0.125;
+    if (bits & shared.U_ORIGIN3) to.origin.z = stream.readShort() * 0.125;
+    if (bits & shared.U_ANGLE1) to.angles.x = stream.readByte() * (360 / 256);
+    if (bits & shared.U_ANGLE2) to.angles.y = stream.readByte() * (360 / 256);
+    if (bits & shared.U_ANGLE3) to.angles.z = stream.readByte() * (360 / 256);
+    if (bits & shared.U_OLDORIGIN) {
+      to.old_origin.x = stream.readShort() * 0.125;
+      to.old_origin.y = stream.readShort() * 0.125;
+      to.old_origin.z = stream.readShort() * 0.125;
+    }
+    if (bits & shared.U_SOUND) to.sound = stream.readByte();
+    if (bits & shared.U_EVENT) to.event = stream.readByte();
+    else to.event = 0;
+    if (bits & shared.U_SOLID) to.solid = stream.readShort();
+  }
+  parsePlayerState(stream) {
+    const ps = createEmptyProtocolPlayerState();
+    const flags = stream.readShort();
+    if (flags & 1) ps.pm_type = stream.readByte();
+    if (flags & 2) {
+      ps.origin.x = stream.readShort() * 0.125;
+      ps.origin.y = stream.readShort() * 0.125;
+      ps.origin.z = stream.readShort() * 0.125;
+    }
+    if (flags & 4) {
+      ps.velocity.x = stream.readShort() * 0.125;
+      ps.velocity.y = stream.readShort() * 0.125;
+      ps.velocity.z = stream.readShort() * 0.125;
+    }
+    if (flags & 8) ps.pm_time = stream.readByte();
+    if (flags & 16) ps.pm_flags = stream.readByte();
+    if (flags & 32) ps.gravity = stream.readShort();
+    if (flags & 64) {
+      ps.delta_angles.x = stream.readShort() * (180 / 32768);
+      ps.delta_angles.y = stream.readShort() * (180 / 32768);
+      ps.delta_angles.z = stream.readShort() * (180 / 32768);
+    }
+    if (flags & 128) {
+      ps.viewoffset.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.viewoffset.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.viewoffset.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 256) {
+      ps.viewangles.x = stream.readShort() * (360 / 65536);
+      ps.viewangles.y = stream.readShort() * (360 / 65536);
+      ps.viewangles.z = stream.readShort() * (360 / 65536);
+    }
+    if (flags & 512) {
+      ps.kick_angles.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.kick_angles.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.kick_angles.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 4096) ps.gun_index = stream.readByte();
+    if (flags & 8192) {
+      ps.gun_frame = stream.readByte();
+      ps.gun_offset.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_offset.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_offset.z = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.x = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.y = (stream.readByte() << 24 >> 24) * 0.25;
+      ps.gun_angles.z = (stream.readByte() << 24 >> 24) * 0.25;
+    }
+    if (flags & 1024) {
+      ps.blend[0] = stream.readByte();
+      ps.blend[1] = stream.readByte();
+      ps.blend[2] = stream.readByte();
+      ps.blend[3] = stream.readByte();
+    }
+    if (flags & 2048) ps.fov = stream.readByte();
+    if (flags & 16384) ps.rdflags = stream.readByte();
+    if (flags & 32768) ps.watertype = stream.readByte();
+    const statbits = stream.readLong();
+    for (let i = 0; i < 32; i++) {
+      if (statbits & 1 << i) ps.stats[i] = stream.readShort();
+    }
+    return ps;
+  }
+};
+var BootstrapProtocolHandler = class {
+  constructor() {
+    this.protocolVersion = 0;
+  }
+  // We assume standard Q2 opcodes for bootstrap to find serverdata
+  // but we can also check for legacy serverdata (12 vs 13 vs 7)
+  translateCommand(cmd) {
+    if (cmd === 7) return shared.ServerCommand.serverdata;
+    if (cmd === 12) return shared.ServerCommand.serverdata;
+    if (cmd === 13) return shared.ServerCommand.serverdata;
+    if (cmd === shared.ServerCommand.stufftext) return shared.ServerCommand.stufftext;
+    return shared.ServerCommand.bad;
+  }
+  parseServerData(stream) {
+    const protocol = stream.readLong();
+    if (protocol === PROTOCOL_VERSION_RERELEASE) {
+      const spawnCount = stream.readLong();
+      const demoType = stream.readByte();
+      const tickRate = stream.readByte();
+      const gameDir = stream.readString();
+      let playerNum = stream.readShort();
+      if (playerNum === -2) {
+        const numSplits = stream.readShort();
+        for (let i = 0; i < numSplits; i++) stream.readShort();
+        playerNum = 0;
+      } else if (playerNum === -1) {
+        playerNum = -1;
+      }
+      const levelName = stream.readString();
+      return {
+        protocol,
+        serverCount: spawnCount,
+        spawnCount,
+        attractLoop: 0,
+        gameDir,
+        playerNum,
+        levelName,
+        tickRate,
+        demoType
+      };
+    } else {
+      const serverCount = stream.readLong();
+      const attractLoop = stream.readByte();
+      const gameDir = stream.readString();
+      const playerNum = stream.readShort();
+      const levelName = stream.readString();
+      return {
+        protocol,
+        serverCount,
+        attractLoop,
+        gameDir,
+        playerNum,
+        levelName
+      };
+    }
+  }
+  parseEntityBits(stream) {
+    throw new Error("Bootstrap handler cannot parse entities");
+  }
+  parseDelta(from, to, number, bits, bitsHigh, stream) {
+    throw new Error("Bootstrap handler cannot parse delta");
+  }
+  parsePlayerState(stream) {
+    throw new Error("Bootstrap handler cannot parse player state");
+  }
+};
+function createProtocolHandler(version) {
+  if (version === 0) {
+    return new BootstrapProtocolHandler();
+  }
+  if (version === PROTOCOL_VERSION_RERELEASE) {
+    return new RereleaseProtocolHandler();
+  }
+  if (version === 34) {
+    return new Quake2ProtocolHandler();
+  }
+  return new LegacyProtocolHandler(version);
+}
+var RECORD_CLIENT = 1;
+var RECORD_SERVER = 2;
+var RECORD_RELAY = 128;
 var BinaryStreamAdapter = class extends StreamingBuffer {
   constructor(stream) {
     super(0);
@@ -12139,38 +12669,11 @@ var BinaryStreamAdapter = class extends StreamingBuffer {
     throw new Error("peekBytes not implemented for BinaryStreamAdapter");
   }
 };
-var PROTO34_MAP = {
-  0: shared.ServerCommand.bad,
-  1: shared.ServerCommand.nop,
-  2: shared.ServerCommand.disconnect,
-  3: shared.ServerCommand.reconnect,
-  4: shared.ServerCommand.download,
-  5: shared.ServerCommand.frame,
-  6: shared.ServerCommand.inventory,
-  7: shared.ServerCommand.layout,
-  8: shared.ServerCommand.muzzleflash,
-  9: shared.ServerCommand.sound,
-  10: shared.ServerCommand.print,
-  11: shared.ServerCommand.stufftext,
-  12: shared.ServerCommand.serverdata,
-  13: shared.ServerCommand.configstring,
-  14: shared.ServerCommand.spawnbaseline,
-  15: shared.ServerCommand.centerprint,
-  16: shared.ServerCommand.download,
-  17: shared.ServerCommand.playerinfo,
-  18: shared.ServerCommand.packetentities,
-  19: shared.ServerCommand.deltapacketentities,
-  23: shared.ServerCommand.temp_entity,
-  // Wire 23 -> Enum 3 (TempEntity)
-  22: shared.ServerCommand.muzzleflash2
-  // Wire 22 -> Enum 2 (MuzzleFlash2)
-};
 var NetworkMessageParser = class _NetworkMessageParser {
   constructor(stream, handler, strictMode = false) {
-    this.protocolVersion = 0;
-    this.isDemo = RECORD_CLIENT;
     this.strictMode = false;
     this.errorCount = 0;
+    this.isDemo = RECORD_CLIENT;
     if (stream instanceof shared.BinaryStream) {
       this.stream = new BinaryStreamAdapter(stream);
     } else {
@@ -12178,41 +12681,19 @@ var NetworkMessageParser = class _NetworkMessageParser {
     }
     this.handler = handler;
     this.strictMode = strictMode;
+    this.protocolHandler = new BootstrapProtocolHandler();
   }
   setProtocolVersion(version) {
-    this.protocolVersion = version;
+    if (this.protocolHandler.protocolVersion !== version) {
+      this.protocolHandler = createProtocolHandler(version);
+    }
   }
   getProtocolVersion() {
-    return this.protocolVersion;
+    return this.protocolHandler.protocolVersion;
   }
   getErrorCount() {
     return this.errorCount;
   }
-  translateCommand(cmd) {
-    if (this.protocolVersion === 0) {
-      if (cmd === 7) return shared.ServerCommand.serverdata;
-      if (cmd === 12) return shared.ServerCommand.serverdata;
-      return cmd;
-    }
-    if (this.protocolVersion === PROTOCOL_VERSION_RERELEASE) {
-      return cmd;
-    }
-    if (this.protocolVersion === 25 || this.protocolVersion === 26) {
-      if (cmd === 0) return shared.ServerCommand.bad;
-      const translated = cmd + 5;
-      if (translated >= shared.ServerCommand.nop && translated <= shared.ServerCommand.frame) {
-        return translated;
-      }
-      return shared.ServerCommand.bad;
-    }
-    if (this.protocolVersion === 34) {
-      if (PROTO34_MAP[cmd] !== void 0) {
-        return PROTO34_MAP[cmd];
-      }
-      return shared.ServerCommand.bad;
-    }
-    return cmd;
-  }
   parseMessage() {
     while (this.stream.hasBytes(1)) {
       const startPos = this.stream.getReadPosition();
@@ -12221,9 +12702,16 @@ var NetworkMessageParser = class _NetworkMessageParser {
         cmd = this.stream.readByte();
         if (cmd === -1) break;
         const originalCmd = cmd;
-        cmd = this.translateCommand(cmd);
-        switch (cmd) {
+        const translatedCmd = this.protocolHandler.translateCommand(cmd);
+        switch (translatedCmd) {
           case shared.ServerCommand.bad:
+            if (originalCmd === 0) {
+              return;
+            }
+            const errorMsg = `Unknown server command: ${originalCmd} (translated: ${translatedCmd}) at offset ${startPos} (Protocol: ${this.getProtocolVersion()})`;
+            if (this.strictMode) throw new Error(errorMsg);
+            console.warn(errorMsg);
+            this.errorCount++;
             return;
           case shared.ServerCommand.nop:
             break;
@@ -12324,9 +12812,9 @@ var NetworkMessageParser = class _NetworkMessageParser {
             this.parseAchievement();
             break;
           default:
-            const errorMsg = `Unknown server command: ${originalCmd} (translated: ${cmd}) at offset ${startPos}`;
-            if (this.strictMode) throw new Error(errorMsg);
-            console.warn(errorMsg);
+            const errorMsgDef = `Unknown server command: ${originalCmd} (translated: ${translatedCmd}) at offset ${startPos}`;
+            if (this.strictMode) throw new Error(errorMsgDef);
+            console.warn(errorMsgDef);
             this.errorCount++;
             return;
         }
@@ -12340,7 +12828,7 @@ var NetworkMessageParser = class _NetworkMessageParser {
           }
           return;
         }
-        const context = `offset ${startPos}, cmd ${cmd}, protocol ${this.protocolVersion}`;
+        const context = `offset ${startPos}, cmd ${cmd}, protocol ${this.getProtocolVersion()}`;
         console.warn(`Error parsing command ${cmd} (${context}): ${errMsg}`);
         this.errorCount++;
         if (this.strictMode) throw e;
@@ -12393,31 +12881,24 @@ var NetworkMessageParser = class _NetworkMessageParser {
     if (this.handler) this.handler.onCenterPrint(centerMsg);
   }
   parseServerData() {
-    this.protocolVersion = this.stream.readLong();
-    if (this.protocolVersion === PROTOCOL_VERSION_RERELEASE) {
-      const spawnCount = this.stream.readLong();
-      const demoType = this.stream.readByte();
-      this.isDemo = demoType;
-      const tickRate = this.stream.readByte();
-      const gameDir = this.stream.readString();
-      let playerNum = this.stream.readShort();
-      if (playerNum === -2) {
-        const numSplits = this.stream.readShort();
-        for (let i = 0; i < numSplits; i++) this.stream.readShort();
-        playerNum = 0;
-      } else if (playerNum === -1) {
-        playerNum = -1;
-      }
-      const levelName = this.stream.readString();
-      if (this.handler) this.handler.onServerData(this.protocolVersion, spawnCount, 0, gameDir, playerNum, levelName, tickRate, demoType);
+    const data = this.protocolHandler.parseServerData(this.stream);
+    this.setProtocolVersion(data.protocol);
+    if (this.handler) {
+      this.handler.onServerData(
+        data.protocol,
+        data.serverCount,
+        data.attractLoop,
+        data.gameDir,
+        data.playerNum,
+        data.levelName,
+        data.tickRate,
+        data.demoType
+      );
+    }
+    if (data.protocol === PROTOCOL_VERSION_RERELEASE) {
+      this.isDemo = data.demoType ?? RECORD_CLIENT;
     } else {
-      const serverCount = this.stream.readLong();
-      const attractLoop = this.stream.readByte();
-      this.isDemo = attractLoop;
-      const gameDir = this.stream.readString();
-      const playerNum = this.stream.readShort();
-      const levelName = this.stream.readString();
-      if (this.handler) this.handler.onServerData(this.protocolVersion, serverCount, attractLoop, gameDir, playerNum, levelName);
+      this.isDemo = data.attractLoop;
     }
   }
   parseConfigString() {
@@ -12453,7 +12934,7 @@ var NetworkMessageParser = class _NetworkMessageParser {
       const decompressed = pako.inflate(compressedData);
       const blastStream = new shared.BinaryStream(decompressed.buffer);
       const blastParser = new _NetworkMessageParser(blastStream, this.handler, this.strictMode);
-      blastParser.setProtocolVersion(this.protocolVersion);
+      blastParser.setProtocolVersion(this.getProtocolVersion());
       while (blastStream.hasMore()) {
         blastParser.parseSpawnBaseline();
       }
@@ -12649,7 +13130,7 @@ var NetworkMessageParser = class _NetworkMessageParser {
         color = this.stream.readByte();
         break;
       case shared.TempEntity.BLUEHYPERBLASTER:
-        if (this.protocolVersion >= 32) {
+        if (this.getProtocolVersion() >= 32) {
           this.readPos(pos);
           this.readPos(pos2);
         } else {
@@ -12658,7 +13139,7 @@ var NetworkMessageParser = class _NetworkMessageParser {
         }
         break;
       case shared.TempEntity.GREENBLOOD:
-        if (this.protocolVersion >= 32) {
+        if (this.getProtocolVersion() >= 32) {
           this.readPos(pos);
           this.readDir(dir);
         } else {
@@ -12723,29 +13204,29 @@ var NetworkMessageParser = class _NetworkMessageParser {
     if (this.handler) this.handler.onTempEntity(type, pos, pos2, dir, cnt, color, ent, srcEnt, destEnt);
   }
   parseSpawnBaseline() {
-    const bits = this.parseEntityBits();
+    const bits = this.protocolHandler.parseEntityBits(this.stream);
     const entity = createEmptyEntityState();
-    this.parseDelta(createEmptyEntityState(), entity, bits.number, bits.bits, bits.bitsHigh);
+    this.protocolHandler.parseDelta(createEmptyEntityState(), entity, bits.number, bits.bits, bits.bitsHigh, this.stream);
     if (this.handler) this.handler.onSpawnBaseline(entity);
   }
   parseFrame() {
     const serverFrame = this.stream.readLong();
     const deltaFrame = this.stream.readLong();
     let surpressCount = 0;
-    if (this.protocolVersion !== 26 && this.protocolVersion !== 25) {
+    if (this.getProtocolVersion() !== 26 && this.getProtocolVersion() !== 25) {
       surpressCount = this.stream.readByte();
     }
     const areaBytes = this.stream.readByte();
     const areaBits = this.stream.readData(areaBytes);
     let piCmd = this.stream.readByte();
-    piCmd = this.translateCommand(piCmd);
+    piCmd = this.protocolHandler.translateCommand(piCmd);
     if (piCmd !== shared.ServerCommand.playerinfo) {
       if (this.strictMode) throw new Error(`Expected svc_playerinfo after svc_frame, got ${piCmd}`);
       return;
     }
     const playerState = this.parsePlayerState();
     let peCmd = this.stream.readByte();
-    peCmd = this.translateCommand(peCmd);
+    peCmd = this.protocolHandler.translateCommand(peCmd);
     if (peCmd !== shared.ServerCommand.packetentities && peCmd !== shared.ServerCommand.deltapacketentities) {
       if (this.strictMode) throw new Error(`Expected svc_packetentities after svc_playerinfo, got ${peCmd}`);
       return;
@@ -12767,64 +13248,7 @@ var NetworkMessageParser = class _NetworkMessageParser {
     });
   }
   parsePlayerState() {
-    const ps = createEmptyProtocolPlayerState();
-    const flags = this.stream.readShort();
-    if (flags & 1) ps.pm_type = this.stream.readByte();
-    if (flags & 2) {
-      ps.origin.x = this.readCoord();
-      ps.origin.y = this.readCoord();
-      ps.origin.z = this.readCoord();
-    }
-    if (flags & 4) {
-      ps.velocity.x = this.readCoord();
-      ps.velocity.y = this.readCoord();
-      ps.velocity.z = this.readCoord();
-    }
-    if (flags & 8) ps.pm_time = this.stream.readByte();
-    if (flags & 16) ps.pm_flags = this.stream.readByte();
-    if (flags & 32) ps.gravity = this.stream.readShort();
-    if (flags & 64) {
-      ps.delta_angles.x = this.stream.readShort() * (180 / 32768);
-      ps.delta_angles.y = this.stream.readShort() * (180 / 32768);
-      ps.delta_angles.z = this.stream.readShort() * (180 / 32768);
-    }
-    if (flags & 128) {
-      ps.viewoffset.x = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.viewoffset.y = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.viewoffset.z = (this.stream.readByte() << 24 >> 24) * 0.25;
-    }
-    if (flags & 256) {
-      ps.viewangles.x = this.readAngle16();
-      ps.viewangles.y = this.readAngle16();
-      ps.viewangles.z = this.readAngle16();
-    }
-    if (flags & 512) {
-      ps.kick_angles.x = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.kick_angles.y = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.kick_angles.z = (this.stream.readByte() << 24 >> 24) * 0.25;
-    }
-    if (flags & 4096) ps.gun_index = this.stream.readByte();
-    if (flags & 8192) {
-      ps.gun_frame = this.stream.readByte();
-      ps.gun_offset.x = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.gun_offset.y = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.gun_offset.z = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.gun_angles.x = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.gun_angles.y = (this.stream.readByte() << 24 >> 24) * 0.25;
-      ps.gun_angles.z = (this.stream.readByte() << 24 >> 24) * 0.25;
-    }
-    if (flags & 1024) {
-      ps.blend[0] = this.stream.readByte();
-      ps.blend[1] = this.stream.readByte();
-      ps.blend[2] = this.stream.readByte();
-      ps.blend[3] = this.stream.readByte();
-    }
-    if (flags & 2048) ps.fov = this.stream.readByte();
-    if (flags & 16384) ps.rdflags = this.stream.readByte();
-    if (flags & 32768) ps.watertype = this.stream.readByte();
-    const statbits = this.stream.readLong();
-    for (let i = 0; i < 32; i++) if (statbits & 1 << i) ps.stats[i] = this.stream.readShort();
-    return ps;
+    return this.protocolHandler.parsePlayerState(this.stream);
   }
   parsePacketEntities(delta) {
     const entities = this.collectPacketEntities();
@@ -12841,103 +13265,20 @@ var NetworkMessageParser = class _NetworkMessageParser {
   collectPacketEntities() {
     const entities = [];
     while (true) {
-      const bits = this.parseEntityBits();
-      if (bits.bits & U_REMOVE) {
+      const bits = this.protocolHandler.parseEntityBits(this.stream);
+      if (bits.bits & shared.U_REMOVE) {
         if (bits.number === 0) break;
         continue;
       }
       const entity = createEmptyEntityState();
-      const forceParse = bits.number === 0 && !(bits.bits & U_MOREBITS1);
-      if (bits.number !== 0 || forceParse) {
-        this.parseDelta(createEmptyEntityState(), entity, bits.number, bits.bits, bits.bitsHigh);
+      if (bits.number === 0) {
+        break;
       }
-      if (bits.number === 0) break;
+      this.protocolHandler.parseDelta(createEmptyEntityState(), entity, bits.number, bits.bits, bits.bitsHigh, this.stream);
       entities.push(entity);
     }
     return entities;
   }
-  parseEntityBits() {
-    let total = this.stream.readByte();
-    if (total & U_MOREBITS1) total |= this.stream.readByte() << 8;
-    if (total & U_MOREBITS2) total |= this.stream.readByte() << 16;
-    if (total & U_MOREBITS3) total |= this.stream.readByte() << 24;
-    let bitsHigh = 0;
-    if (this.protocolVersion === PROTOCOL_VERSION_RERELEASE) {
-      if (total & U_MOREBITS4) bitsHigh = this.stream.readByte();
-    }
-    let number;
-    if (total & U_NUMBER16) number = this.stream.readShort();
-    else number = this.stream.readByte();
-    return { number, bits: total, bitsHigh };
-  }
-  parseDelta(from, to, number, bits, bitsHigh = 0) {
-    to.number = from.number;
-    to.modelindex = from.modelindex;
-    to.modelindex2 = from.modelindex2;
-    to.modelindex3 = from.modelindex3;
-    to.modelindex4 = from.modelindex4;
-    to.frame = from.frame;
-    to.skinnum = from.skinnum;
-    to.effects = from.effects;
-    to.renderfx = from.renderfx;
-    to.origin.x = from.origin.x;
-    to.origin.y = from.origin.y;
-    to.origin.z = from.origin.z;
-    to.old_origin.x = from.origin.x;
-    to.old_origin.y = from.origin.y;
-    to.old_origin.z = from.origin.z;
-    to.angles.x = from.angles.x;
-    to.angles.y = from.angles.y;
-    to.angles.z = from.angles.z;
-    to.sound = from.sound;
-    to.event = from.event;
-    to.solid = from.solid;
-    to.alpha = from.alpha;
-    to.scale = from.scale;
-    to.instanceBits = from.instanceBits;
-    to.loopVolume = from.loopVolume;
-    to.loopAttenuation = from.loopAttenuation;
-    to.owner = from.owner;
-    to.oldFrame = from.oldFrame;
-    to.number = number;
-    to.bits = bits;
-    to.bitsHigh = bitsHigh;
-    if (bits & U_MODEL) to.modelindex = this.stream.readByte();
-    if (bits & U_MODEL2) to.modelindex2 = this.stream.readByte();
-    if (bits & U_MODEL3) to.modelindex3 = this.stream.readByte();
-    if (bits & U_MODEL4) to.modelindex4 = this.stream.readByte();
-    if (bits & U_FRAME8) to.frame = this.stream.readByte();
-    if (bits & U_FRAME16) to.frame = this.stream.readShort();
-    if (bits & U_SKIN8 && bits & U_SKIN16) to.skinnum = this.stream.readLong();
-    else if (bits & U_SKIN8) to.skinnum = this.stream.readByte();
-    else if (bits & U_SKIN16) to.skinnum = this.stream.readShort();
-    if (bits & U_EFFECTS8 && bits & U_EFFECTS16) to.effects = this.stream.readLong();
-    else if (bits & U_EFFECTS8) to.effects = this.stream.readByte();
-    else if (bits & U_EFFECTS16) to.effects = this.stream.readShort();
-    if (bits & U_RENDERFX8 && bits & U_RENDERFX16) to.renderfx = this.stream.readLong();
-    else if (bits & U_RENDERFX8) to.renderfx = this.stream.readByte();
-    else if (bits & U_RENDERFX16) to.renderfx = this.stream.readShort();
-    if (bits & U_ORIGIN1) to.origin.x = this.readCoord();
-    if (bits & U_ORIGIN2) to.origin.y = this.readCoord();
-    if (bits & U_ORIGIN3) to.origin.z = this.readCoord();
-    if (bits & U_ANGLE1) to.angles.x = this.readAngle();
-    if (bits & U_ANGLE2) to.angles.y = this.readAngle();
-    if (bits & U_ANGLE3) to.angles.z = this.readAngle();
-    if (bits & U_OLDORIGIN) this.readPos(to.old_origin);
-    if (bits & U_SOUND) to.sound = this.stream.readByte();
-    if (bits & U_EVENT) to.event = this.stream.readByte();
-    else to.event = 0;
-    if (bits & U_SOLID) to.solid = this.stream.readShort();
-    if (this.protocolVersion === PROTOCOL_VERSION_RERELEASE) {
-      if (bits & U_ALPHA) to.alpha = this.stream.readByte() / 255;
-      if (bits & U_SCALE) to.scale = this.stream.readFloat();
-      if (bits & U_INSTANCE_BITS) to.instanceBits = this.stream.readLong();
-      if (bits & U_LOOP_VOLUME) to.loopVolume = this.stream.readByte() / 255;
-      if (bitsHigh & U_LOOP_ATTENUATION_HIGH) to.loopAttenuation = this.stream.readByte() / 255;
-      if (bitsHigh & U_OWNER_HIGH) to.owner = this.stream.readShort();
-      if (bitsHigh & U_OLD_FRAME_HIGH) to.oldFrame = this.stream.readShort();
-    }
-  }
 };
 
 // src/demo/analysis.ts
@@ -13203,12 +13544,12 @@ var DemoCameraMode = /* @__PURE__ */ ((DemoCameraMode2) => {
 })(DemoCameraMode || {});
 
 // src/demo/playback.ts
-var PlaybackState = /* @__PURE__ */ ((PlaybackState3) => {
-  PlaybackState3[PlaybackState3["Stopped"] = 0] = "Stopped";
-  PlaybackState3[PlaybackState3["Playing"] = 1] = "Playing";
-  PlaybackState3[PlaybackState3["Paused"] = 2] = "Paused";
-  PlaybackState3[PlaybackState3["Finished"] = 3] = "Finished";
-  return PlaybackState3;
+var PlaybackState = /* @__PURE__ */ ((PlaybackState2) => {
+  PlaybackState2[PlaybackState2["Stopped"] = 0] = "Stopped";
+  PlaybackState2[PlaybackState2["Playing"] = 1] = "Playing";
+  PlaybackState2[PlaybackState2["Paused"] = 2] = "Paused";
+  PlaybackState2[PlaybackState2["Finished"] = 3] = "Finished";
+  return PlaybackState2;
 })(PlaybackState || {});
 var createNoOpHandler = () => ({
   onServerData: () => {
@@ -13929,289 +14270,134 @@ var DemoRecorder = class {
     return this.isRecording;
   }
 };
-var PROTO34_REVERSE_MAP = {
-  [shared.ServerCommand.bad]: 0,
-  [shared.ServerCommand.nop]: 1,
-  [shared.ServerCommand.disconnect]: 2,
-  [shared.ServerCommand.reconnect]: 3,
-  // 4 is download? standard Q2 uses 4 for download sometimes, but let's stick to parser map (download=16).
-  // Let's map download to 16.
-  [shared.ServerCommand.download]: 16,
-  [shared.ServerCommand.frame]: 5,
-  [shared.ServerCommand.inventory]: 6,
-  [shared.ServerCommand.layout]: 7,
-  [shared.ServerCommand.muzzleflash]: 8,
-  [shared.ServerCommand.sound]: 9,
-  [shared.ServerCommand.print]: 10,
-  [shared.ServerCommand.stufftext]: 11,
-  [shared.ServerCommand.serverdata]: 12,
-  [shared.ServerCommand.configstring]: 13,
-  [shared.ServerCommand.spawnbaseline]: 14,
-  [shared.ServerCommand.centerprint]: 15,
-  // 16 is download
-  [shared.ServerCommand.playerinfo]: 17,
-  [shared.ServerCommand.packetentities]: 18,
-  [shared.ServerCommand.deltapacketentities]: 19,
-  // Temp entity? Standard Q2 uses 9 for temp_entity?
-  // But we mapped 9 to sound.
-  // If we map temp_entity to 23 (arbitrary safe slot for internal tests) or assume standard Q2 layout:
-  // Q2: svc_temp_entity = 9. svc_sound = 10.
-  // My previous edit to parser.ts used 9->Sound, 10->Print.
-  // I should check what I committed to `parser.ts` just now.
-  // I committed: 9: Sound, 10: Print.
-  // So Writer MUST MATCH Parser.
-  // So if Parser says 9 is Sound, Writer must write Sound as 9.
-  // But what about TempEntity?
-  // Parser does NOT map any wire code to TempEntity in my recent edit (I commented out 23).
-  // So TempEntity is currently broken for Protocol 34 unless I map it.
-  // I will map TempEntity to 23 in both.
-  [shared.ServerCommand.temp_entity]: 23,
-  // MuzzleFlash2?
-  // I'll map it to 22 (arbitrary) just to have a value, or skip if unused.
-  [shared.ServerCommand.muzzleflash2]: 22
-};
 var MessageWriter = class {
-  constructor() {
-    this.writer = new shared.BinaryWriter();
-  }
-  getData() {
-    return this.writer.getData();
-  }
-  writeCommand(cmd, protocolVersion = 0) {
-    if (protocolVersion === 34) {
-      const translated = PROTO34_REVERSE_MAP[cmd];
-      if (translated !== void 0) {
-        this.writer.writeByte(translated);
-        return;
-      }
-    }
-    this.writer.writeByte(cmd);
-  }
-  writeServerData(protocol, serverCount, attractLoop, gameDir, playerNum, levelName) {
-    this.writeCommand(shared.ServerCommand.serverdata, protocol);
-    this.writer.writeLong(protocol);
-    this.writer.writeLong(serverCount);
-    this.writer.writeByte(attractLoop);
-    this.writer.writeString(gameDir);
-    this.writer.writeShort(playerNum);
-    this.writer.writeString(levelName);
-  }
-  writeServerDataRerelease(protocol, spawnCount, demoType, tickRate, gameDir, playerNum, levelName) {
-    this.writeCommand(shared.ServerCommand.serverdata, protocol);
-    this.writer.writeLong(protocol);
-    this.writer.writeLong(spawnCount);
-    this.writer.writeByte(demoType);
-    this.writer.writeByte(tickRate);
-    this.writer.writeString(gameDir);
-    this.writer.writeShort(playerNum);
-    this.writer.writeString(levelName);
-  }
-  writeConfigString(index, str, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.configstring, protocolVersion);
-    this.writer.writeShort(index);
-    this.writer.writeString(str);
-  }
-  writeSpawnBaseline(entity, protocolVersion) {
-    this.writeCommand(shared.ServerCommand.spawnbaseline, protocolVersion);
-    this.writeEntityState(entity, null, true, protocolVersion);
-  }
-  writeStuffText(text, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.stufftext, protocolVersion);
-    this.writer.writeString(text);
-  }
-  writeCenterPrint(text, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.centerprint, protocolVersion);
-    this.writer.writeString(text);
-  }
-  writePrint(level, text, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.print, protocolVersion);
-    this.writer.writeByte(level);
-    this.writer.writeString(text);
-  }
-  writeLayout(layout, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.layout, protocolVersion);
-    this.writer.writeString(layout);
-  }
-  writeInventory(inventory, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.inventory, protocolVersion);
-    for (let i = 0; i < 256; i++) {
-      this.writer.writeShort(inventory[i] || 0);
-    }
-  }
-  writeMuzzleFlash(ent, weapon, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.muzzleflash, protocolVersion);
-    this.writer.writeShort(ent);
-    this.writer.writeByte(weapon);
-  }
-  writeMuzzleFlash2(ent, weapon, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.muzzleflash2, protocolVersion);
-    this.writer.writeShort(ent);
-    this.writer.writeByte(weapon);
-  }
-  writeTempEntity(type, pos, pos2, dir, cnt, color, ent, srcEnt, destEnt, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.temp_entity, protocolVersion);
-    this.writer.writeByte(type);
-    switch (type) {
-      case shared.TempEntity.EXPLOSION1:
-      case shared.TempEntity.EXPLOSION2:
-      case shared.TempEntity.ROCKET_EXPLOSION:
-      case shared.TempEntity.GRENADE_EXPLOSION:
-      case shared.TempEntity.ROCKET_EXPLOSION_WATER:
-      case shared.TempEntity.GRENADE_EXPLOSION_WATER:
-      case shared.TempEntity.BFG_EXPLOSION:
-      case shared.TempEntity.BFG_BIGEXPLOSION:
-      case shared.TempEntity.BOSSTPORT:
-      case shared.TempEntity.PLASMA_EXPLOSION:
-      case shared.TempEntity.PLAIN_EXPLOSION:
-      case shared.TempEntity.CHAINFIST_SMOKE:
-      case shared.TempEntity.TRACKER_EXPLOSION:
-      case shared.TempEntity.TELEPORT_EFFECT:
-      case shared.TempEntity.DBALL_GOAL:
-      case shared.TempEntity.NUKEBLAST:
-      case shared.TempEntity.WIDOWSPLASH:
-      case shared.TempEntity.EXPLOSION1_BIG:
-      case shared.TempEntity.EXPLOSION1_NP:
-        this.writer.writePos(pos);
-        break;
-      case shared.TempEntity.GUNSHOT:
-      case shared.TempEntity.BLOOD:
-      case shared.TempEntity.BLASTER:
-      case shared.TempEntity.SHOTGUN:
-      case shared.TempEntity.SPARKS:
-      case shared.TempEntity.BULLET_SPARKS:
-      case shared.TempEntity.SCREEN_SPARKS:
-      case shared.TempEntity.SHIELD_SPARKS:
-      case shared.TempEntity.BLASTER2:
-      case shared.TempEntity.FLECHETTE:
-      case shared.TempEntity.MOREBLOOD:
-      case shared.TempEntity.ELECTRIC_SPARKS:
-      case shared.TempEntity.HEATBEAM_SPARKS:
-      case shared.TempEntity.HEATBEAM_STEAM:
-        this.writer.writePos(pos);
-        this.writer.writeDir(dir || { x: 0, y: 0, z: 0 });
-        break;
-      case shared.TempEntity.SPLASH:
-      case shared.TempEntity.LASER_SPARKS:
-      case shared.TempEntity.WELDING_SPARKS:
-      case shared.TempEntity.TUNNEL_SPARKS:
-        this.writer.writeByte(cnt || 0);
-        this.writer.writePos(pos);
-        this.writer.writeDir(dir || { x: 0, y: 0, z: 0 });
-        this.writer.writeByte(color || 0);
-        break;
-      case shared.TempEntity.BLUEHYPERBLASTER:
-        if (protocolVersion >= 32) {
-          this.writer.writePos(pos);
-          this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        } else {
-          this.writer.writePos(pos);
-          this.writer.writeDir(dir || { x: 0, y: 0, z: 0 });
-        }
-        break;
-      case shared.TempEntity.GREENBLOOD:
-        if (protocolVersion >= 32) {
-          this.writer.writePos(pos);
-          this.writer.writeDir(dir || { x: 0, y: 0, z: 0 });
-        } else {
-          this.writer.writePos(pos);
-          this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        }
-        break;
-      case shared.TempEntity.RAILTRAIL:
-      case shared.TempEntity.BUBBLETRAIL:
-      case shared.TempEntity.BFG_LASER:
-      case shared.TempEntity.DEBUGTRAIL:
-      case shared.TempEntity.BUBBLETRAIL2:
-        this.writer.writePos(pos);
-        this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        break;
-      case shared.TempEntity.PARASITE_ATTACK:
-      case shared.TempEntity.MEDIC_CABLE_ATTACK:
-        this.writer.writeShort(ent || 0);
-        this.writer.writePos(pos);
-        this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        break;
-      case shared.TempEntity.GRAPPLE_CABLE:
-        this.writer.writeShort(ent || 0);
-        this.writer.writePos(pos);
-        this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        this.writer.writePos(dir || { x: 0, y: 0, z: 0 });
-        break;
-      case shared.TempEntity.LIGHTNING:
-        this.writer.writeShort(srcEnt || 0);
-        this.writer.writeShort(destEnt || 0);
-        this.writer.writePos(pos);
-        this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        break;
-      case shared.TempEntity.FLASHLIGHT:
-        this.writer.writePos(pos);
-        this.writer.writeShort(ent || 0);
-        break;
-      case shared.TempEntity.FORCEWALL:
-        this.writer.writePos(pos);
-        this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        this.writer.writeByte(color || 0);
-        break;
-      case shared.TempEntity.STEAM:
-        this.writer.writeShort(-1);
-        this.writer.writeByte(cnt || 0);
-        this.writer.writePos(pos);
-        this.writer.writeDir(dir || { x: 0, y: 0, z: 0 });
-        this.writer.writeByte(color || 0);
-        this.writer.writeShort(0);
-        break;
-      case shared.TempEntity.WIDOWBEAMOUT:
-        this.writer.writeShort(0);
-      // ent
-      // Fallthrough
-      case shared.TempEntity.HEATBEAM:
-      case shared.TempEntity.MONSTER_HEATBEAM:
-        this.writer.writeShort(ent || 0);
-        this.writer.writePos(pos);
-        this.writer.writePos(pos2 || { x: 0, y: 0, z: 0 });
-        this.writer.writeDir(dir || { x: 0, y: 0, z: 0 });
-        break;
-      default:
-        console.warn(`writeTempEntity: Unhandled type ${type}`);
-        break;
+  constructor(writer, protocol = 34) {
+    this.writer = writer || new shared.BinaryWriter(new Uint8Array(64 * 1024));
+    this.protocol = protocol;
+  }
+  getData() {
+    return this.writer.getData();
+  }
+  getOpcode(cmd) {
+    if (this.protocol === 34) {
+      switch (cmd) {
+        case shared.ServerCommand.serverdata:
+          return 13;
+        case shared.ServerCommand.frame:
+          return 5;
+        case shared.ServerCommand.playerinfo:
+          return 17;
+        case shared.ServerCommand.packetentities:
+          return 18;
+        case shared.ServerCommand.deltapacketentities:
+          return 19;
+        case shared.ServerCommand.print:
+          return 11;
+        case shared.ServerCommand.centerprint:
+          return 16;
+        case shared.ServerCommand.stufftext:
+          return 12;
+        case shared.ServerCommand.sound:
+          return 10;
+        case shared.ServerCommand.temp_entity:
+          return 9;
+        case shared.ServerCommand.configstring:
+          return 14;
+        case shared.ServerCommand.spawnbaseline:
+          return 15;
+        case shared.ServerCommand.layout:
+          return 7;
+        case shared.ServerCommand.inventory:
+          return 6;
+        case shared.ServerCommand.muzzleflash:
+          return 8;
+        case shared.ServerCommand.muzzleflash2:
+          return 20;
+      }
+    }
+    return cmd;
+  }
+  writeCommand(cmd, protocol) {
+    const proto = protocol ?? this.protocol;
+    if (proto === 34 || proto === 0) {
+      this.writer.writeByte(this.getOpcode(cmd));
+    } else {
+      this.writer.writeByte(cmd);
+    }
+  }
+  writeServerData(protocol, serverCount, attractLoop, gameDir, playerNum, levelName) {
+    this.writeCommand(shared.ServerCommand.serverdata);
+    this.writer.writeLong(protocol);
+    this.writer.writeLong(serverCount);
+    this.writer.writeByte(attractLoop);
+    this.writer.writeString(gameDir);
+    this.writer.writeShort(playerNum);
+    this.writer.writeString(levelName);
+  }
+  writeConfigString(index, str) {
+    this.writeCommand(shared.ServerCommand.configstring);
+    this.writer.writeShort(index);
+    this.writer.writeString(str);
+  }
+  writeStuffText(text) {
+    this.writeCommand(shared.ServerCommand.stufftext);
+    this.writer.writeString(text);
+  }
+  writeCenterPrint(msg) {
+    this.writeCommand(shared.ServerCommand.centerprint);
+    this.writer.writeString(msg);
+  }
+  writePrint(level, msg) {
+    this.writeCommand(shared.ServerCommand.print);
+    this.writer.writeByte(level);
+    this.writer.writeString(msg);
+  }
+  writeLayout(layout) {
+    this.writeCommand(shared.ServerCommand.layout);
+    this.writer.writeString(layout);
+  }
+  writeInventory(inventory) {
+    this.writeCommand(shared.ServerCommand.inventory);
+    for (const count of inventory) {
+      this.writer.writeShort(count);
+    }
+    for (let i = inventory.length; i < 256; i++) {
+      this.writer.writeShort(0);
     }
   }
-  writeSound(mask, soundNum, volume, attenuation, offset, ent, pos, protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.sound, protocolVersion);
+  writeMuzzleFlash(ent, weapon) {
+    this.writeCommand(shared.ServerCommand.muzzleflash);
+    this.writer.writeShort(ent);
+    this.writer.writeByte(weapon);
+  }
+  writeMuzzleFlash2(ent, weapon) {
+    this.writeCommand(shared.ServerCommand.muzzleflash2);
+    this.writer.writeShort(ent);
+    this.writer.writeByte(weapon);
+  }
+  writeSound(mask, soundNum, volume, attenuation, offset, ent, pos, protocol) {
+    this.writeCommand(shared.ServerCommand.sound);
     this.writer.writeByte(mask);
     this.writer.writeByte(soundNum);
-    if (mask & 1) this.writer.writeByte(volume || 0);
-    if (mask & 2) this.writer.writeByte(attenuation || 0);
-    if (mask & 16) this.writer.writeByte(offset || 0);
-    if (mask & 8) this.writer.writeShort(ent || 0);
-    if (mask & 4 && pos) {
+    if (mask & 1) this.writer.writeByte(volume);
+    if (mask & 2) this.writer.writeByte(attenuation);
+    if (mask & 16) this.writer.writeByte(offset);
+    if (mask & 8) this.writer.writeShort(ent);
+    if (mask & 4) {
       this.writer.writeCoord(pos.x);
       this.writer.writeCoord(pos.y);
       this.writer.writeCoord(pos.z);
     }
   }
-  writeDisconnect(protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.disconnect, protocolVersion);
-  }
-  writeReconnect(protocolVersion = 0) {
-    this.writeCommand(shared.ServerCommand.reconnect, protocolVersion);
-  }
-  writeFrame(frame, protocolVersion) {
-    this.writeCommand(shared.ServerCommand.frame, protocolVersion);
-    this.writer.writeLong(frame.serverFrame);
-    this.writer.writeLong(frame.deltaFrame);
-    if (protocolVersion !== 25 && protocolVersion !== 26) {
-      this.writer.writeByte(frame.surpressCount);
-    }
-    this.writer.writeByte(frame.areaBytes);
-    if (frame.areaBytes > 0) {
-      this.writer.writeBytes(frame.areaBits);
+  writeTempEntity(type, pos, pos2, dir, cnt, color, ent, srcEnt, destEnt) {
+    this.writeCommand(shared.ServerCommand.temp_entity);
+    this.writer.writeByte(type);
+    if (pos) {
+      this.writer.writePos(pos);
     }
-    this.writeCommand(shared.ServerCommand.playerinfo, protocolVersion);
-    this.writePlayerState(frame.playerState);
-    this.writePacketEntities(frame.packetEntities.entities, frame.packetEntities.delta, protocolVersion);
   }
   writePlayerState(ps) {
+    this.writeCommand(shared.ServerCommand.playerinfo);
     let flags = 0;
     if (ps.pm_type !== 0) flags |= 1;
     if (ps.origin.x !== 0 || ps.origin.y !== 0 || ps.origin.z !== 0) flags |= 2;
@@ -14223,55 +14409,56 @@ var MessageWriter = class {
     if (ps.viewoffset.x !== 0 || ps.viewoffset.y !== 0 || ps.viewoffset.z !== 0) flags |= 128;
     if (ps.viewangles.x !== 0 || ps.viewangles.y !== 0 || ps.viewangles.z !== 0) flags |= 256;
     if (ps.kick_angles.x !== 0 || ps.kick_angles.y !== 0 || ps.kick_angles.z !== 0) flags |= 512;
-    if (ps.blend[0] !== 0 || ps.blend[1] !== 0 || ps.blend[2] !== 0 || ps.blend[3] !== 0) flags |= 1024;
     if (ps.gun_index !== 0) flags |= 4096;
     if (ps.gun_frame !== 0 || ps.gun_offset.x !== 0 || ps.gun_offset.y !== 0 || ps.gun_offset.z !== 0 || ps.gun_angles.x !== 0 || ps.gun_angles.y !== 0 || ps.gun_angles.z !== 0) flags |= 8192;
+    if (ps.blend[0] !== 0 || ps.blend[1] !== 0 || ps.blend[2] !== 0 || ps.blend[3] !== 0) flags |= 1024;
     if (ps.fov !== 0) flags |= 2048;
     if (ps.rdflags !== 0) flags |= 16384;
+    if (ps.watertype !== 0) flags |= 32768;
     this.writer.writeShort(flags);
     if (flags & 1) this.writer.writeByte(ps.pm_type);
     if (flags & 2) {
-      this.writer.writeCoord(ps.origin.x);
-      this.writer.writeCoord(ps.origin.y);
-      this.writer.writeCoord(ps.origin.z);
+      this.writer.writeShort(ps.origin.x / 0.125);
+      this.writer.writeShort(ps.origin.y / 0.125);
+      this.writer.writeShort(ps.origin.z / 0.125);
     }
     if (flags & 4) {
-      this.writer.writeCoord(ps.velocity.x);
-      this.writer.writeCoord(ps.velocity.y);
-      this.writer.writeCoord(ps.velocity.z);
+      this.writer.writeShort(ps.velocity.x / 0.125);
+      this.writer.writeShort(ps.velocity.y / 0.125);
+      this.writer.writeShort(ps.velocity.z / 0.125);
     }
     if (flags & 8) this.writer.writeByte(ps.pm_time);
     if (flags & 16) this.writer.writeByte(ps.pm_flags);
     if (flags & 32) this.writer.writeShort(ps.gravity);
     if (flags & 64) {
-      this.writer.writeShort(Math.round(ps.delta_angles.x * (32768 / 180)));
-      this.writer.writeShort(Math.round(ps.delta_angles.y * (32768 / 180)));
-      this.writer.writeShort(Math.round(ps.delta_angles.z * (32768 / 180)));
+      this.writer.writeShort(ps.delta_angles.x / (180 / 32768));
+      this.writer.writeShort(ps.delta_angles.y / (180 / 32768));
+      this.writer.writeShort(ps.delta_angles.z / (180 / 32768));
     }
     if (flags & 128) {
-      this.writer.writeChar(Math.round(ps.viewoffset.x * 4));
-      this.writer.writeChar(Math.round(ps.viewoffset.y * 4));
-      this.writer.writeChar(Math.round(ps.viewoffset.z * 4));
+      this.writer.writeByte(ps.viewoffset.x / 0.25);
+      this.writer.writeByte(ps.viewoffset.y / 0.25);
+      this.writer.writeByte(ps.viewoffset.z / 0.25);
     }
     if (flags & 256) {
-      this.writer.writeAngle16(ps.viewangles.x);
-      this.writer.writeAngle16(ps.viewangles.y);
-      this.writer.writeAngle16(ps.viewangles.z);
+      this.writer.writeShort(ps.viewangles.x / (360 / 65536));
+      this.writer.writeShort(ps.viewangles.y / (360 / 65536));
+      this.writer.writeShort(ps.viewangles.z / (360 / 65536));
     }
     if (flags & 512) {
-      this.writer.writeChar(Math.round(ps.kick_angles.x * 4));
-      this.writer.writeChar(Math.round(ps.kick_angles.y * 4));
-      this.writer.writeChar(Math.round(ps.kick_angles.z * 4));
+      this.writer.writeByte(ps.kick_angles.x / 0.25);
+      this.writer.writeByte(ps.kick_angles.y / 0.25);
+      this.writer.writeByte(ps.kick_angles.z / 0.25);
     }
     if (flags & 4096) this.writer.writeByte(ps.gun_index);
     if (flags & 8192) {
       this.writer.writeByte(ps.gun_frame);
-      this.writer.writeChar(Math.round(ps.gun_offset.x * 4));
-      this.writer.writeChar(Math.round(ps.gun_offset.y * 4));
-      this.writer.writeChar(Math.round(ps.gun_offset.z * 4));
-      this.writer.writeChar(Math.round(ps.gun_angles.x * 4));
-      this.writer.writeChar(Math.round(ps.gun_angles.y * 4));
-      this.writer.writeChar(Math.round(ps.gun_angles.z * 4));
+      this.writer.writeByte(ps.gun_offset.x / 0.25);
+      this.writer.writeByte(ps.gun_offset.y / 0.25);
+      this.writer.writeByte(ps.gun_offset.z / 0.25);
+      this.writer.writeByte(ps.gun_angles.x / 0.25);
+      this.writer.writeByte(ps.gun_angles.y / 0.25);
+      this.writer.writeByte(ps.gun_angles.z / 0.25);
     }
     if (flags & 1024) {
       this.writer.writeByte(ps.blend[0]);
@@ -14281,6 +14468,7 @@ var MessageWriter = class {
     }
     if (flags & 2048) this.writer.writeByte(ps.fov);
     if (flags & 16384) this.writer.writeByte(ps.rdflags);
+    if (flags & 32768) this.writer.writeByte(ps.watertype);
     let statbits = 0;
     for (let i = 0; i < 32; i++) {
       if (ps.stats[i] !== 0) statbits |= 1 << i;
@@ -14290,112 +14478,121 @@ var MessageWriter = class {
       if (statbits & 1 << i) this.writer.writeShort(ps.stats[i]);
     }
   }
-  writePacketEntities(entities, delta, protocolVersion) {
-    this.writeCommand(delta ? shared.ServerCommand.deltapacketentities : shared.ServerCommand.packetentities, protocolVersion);
+  writePacketEntities(entities, delta, protocol) {
+    this.writeCommand(delta ? shared.ServerCommand.deltapacketentities : shared.ServerCommand.packetentities);
     for (const ent of entities) {
-      const force = !delta;
-      this.writeEntityState(ent, null, force, protocolVersion);
+      this.writeDeltaEntity(createEmptyEntityState(), ent, true);
     }
     this.writer.writeShort(0);
   }
-  writeEntityState(to, from, force, protocolVersion) {
+  writeFrame(frame, protocol) {
+    this.writeCommand(shared.ServerCommand.frame);
+    this.writer.writeLong(frame.serverFrame);
+    this.writer.writeLong(frame.deltaFrame);
+    if (protocol !== 26 && protocol !== 25) {
+      this.writer.writeByte(frame.surpressCount);
+    }
+    this.writer.writeByte(frame.areaBytes);
+    this.writer.writeBytes(frame.areaBits);
+    this.writePlayerState(frame.playerState);
+    this.writePacketEntities(frame.packetEntities.entities, frame.packetEntities.delta, protocol);
+  }
+  writeDeltaEntity(from, to, force) {
     let bits = 0;
     let bitsHigh = 0;
-    if (to.bits !== 0 && !force) {
-      bits = to.bits;
-      bitsHigh = to.bitsHigh;
-    } else {
-      if (to.modelindex !== 0) bits |= U_MODEL;
-      if (to.modelindex2 !== 0) bits |= U_MODEL2;
-      if (to.modelindex3 !== 0) bits |= U_MODEL3;
-      if (to.modelindex4 !== 0) bits |= U_MODEL4;
-      if (to.frame !== 0) {
-        if (to.frame >= 256) bits |= U_FRAME16;
-        else bits |= U_FRAME8;
-      }
-      if (to.skinnum !== 0) {
-        if (to.skinnum >= 256) bits |= U_SKIN16;
-        else bits |= U_SKIN8;
-      }
-      if (to.effects !== 0) {
-        if (to.effects >= 256) bits |= U_EFFECTS16;
-        else bits |= U_EFFECTS8;
-      }
-      if (to.renderfx !== 0) {
-        if (to.renderfx >= 256) bits |= U_RENDERFX16;
-        else bits |= U_RENDERFX8;
-      }
-      if (to.origin.x !== 0) bits |= U_ORIGIN1;
-      if (to.origin.y !== 0) bits |= U_ORIGIN2;
-      if (to.origin.z !== 0) bits |= U_ORIGIN3;
-      if (to.angles.x !== 0) bits |= U_ANGLE1;
-      if (to.angles.y !== 0) bits |= U_ANGLE2;
-      if (to.angles.z !== 0) bits |= U_ANGLE3;
-      if (to.old_origin.x !== 0 || to.old_origin.y !== 0 || to.old_origin.z !== 0) bits |= U_OLDORIGIN;
-      if (to.sound !== 0) bits |= U_SOUND;
-      if (to.event !== 0) bits |= U_EVENT;
-      if (to.solid !== 0) bits |= U_SOLID;
-      if (protocolVersion >= 2023) {
-        if (to.alpha !== 0) bits |= U_ALPHA;
-        if (to.scale !== 0) bits |= U_SCALE;
-        if (to.instanceBits !== 0) bits |= U_INSTANCE_BITS;
-        if (to.loopVolume !== 0) bits |= U_LOOP_VOLUME;
-        if (to.loopAttenuation !== 0) bitsHigh |= U_LOOP_ATTENUATION_HIGH;
-        if (to.owner !== 0) bitsHigh |= U_OWNER_HIGH;
-        if (to.oldFrame !== 0) bitsHigh |= U_OLD_FRAME_HIGH;
-      }
-      if (to.number >= 256) bits |= U_NUMBER16;
-    }
-    if (bitsHigh !== 0) bits |= U_MOREBITS4;
-    if ((bits & 4278190080) !== 0) bits |= U_MOREBITS3;
-    if ((bits & 16711680) !== 0) bits |= U_MOREBITS2;
-    if ((bits & 65280) !== 0) bits |= U_MOREBITS1;
+    if (to.modelindex !== from.modelindex || force) bits |= shared.U_MODEL;
+    if (to.modelindex2 !== from.modelindex2 || force) bits |= shared.U_MODEL2;
+    if (to.modelindex3 !== from.modelindex3 || force) bits |= shared.U_MODEL3;
+    if (to.modelindex4 !== from.modelindex4 || force) bits |= shared.U_MODEL4;
+    if (to.frame !== from.frame || force) {
+      if (to.frame >= 256) bits |= shared.U_FRAME16;
+      else bits |= shared.U_FRAME8;
+    }
+    if (to.skinnum !== from.skinnum || force) {
+      if (to.skinnum >= 256) bits |= shared.U_SKIN16;
+      else bits |= shared.U_SKIN8;
+    }
+    if (to.effects !== from.effects || force) {
+      if (to.effects >= 256) bits |= shared.U_EFFECTS16;
+      else bits |= shared.U_EFFECTS8;
+    }
+    if (to.renderfx !== from.renderfx || force) {
+      if (to.renderfx >= 256) bits |= shared.U_RENDERFX16;
+      else bits |= shared.U_RENDERFX8;
+    }
+    if (to.origin.x !== from.origin.x || force) {
+      if (to.origin.x !== 0) bits |= shared.U_ORIGIN1;
+    }
+    if (to.origin.y !== from.origin.y || force) {
+      if (to.origin.y !== 0) bits |= shared.U_ORIGIN2;
+    }
+    if (to.origin.z !== from.origin.z || force) {
+      if (to.origin.z !== 0) bits |= shared.U_ORIGIN3;
+    }
+    if (to.angles.x !== from.angles.x || force) {
+      if (to.angles.x !== 0) bits |= shared.U_ANGLE1;
+    }
+    if (to.angles.y !== from.angles.y || force) {
+      if (to.angles.y !== 0) bits |= shared.U_ANGLE2;
+    }
+    if (to.angles.z !== from.angles.z || force) {
+      if (to.angles.z !== 0) bits |= shared.U_ANGLE3;
+    }
+    if (to.sound !== from.sound || force) bits |= shared.U_SOUND;
+    if (to.event !== from.event || force) bits |= shared.U_EVENT;
+    if (to.solid !== from.solid || force) bits |= shared.U_SOLID;
+    if (this.protocol !== 34) {
+      if (to.alpha !== from.alpha || force) bits |= shared.U_ALPHA;
+      if (to.scale !== from.scale || force) bits |= shared.U_SCALE;
+      if (to.instanceBits !== from.instanceBits || force) bits |= shared.U_INSTANCE_BITS;
+      if (to.loopVolume !== from.loopVolume || force) bits |= shared.U_LOOP_VOLUME;
+      if (to.loopAttenuation !== from.loopAttenuation || force) bitsHigh |= shared.U_LOOP_ATTENUATION_HIGH;
+      if (to.owner !== from.owner || force) bitsHigh |= shared.U_OWNER_HIGH;
+      if (to.oldFrame !== from.oldFrame || force) bitsHigh |= shared.U_OLD_FRAME_HIGH;
+    }
+    if (bitsHigh > 0) bits |= shared.U_MOREBITS4;
+    if (bits & 4278190080) bits |= shared.U_MOREBITS3;
+    if (bits & 4294901760) bits |= shared.U_MOREBITS2;
+    if (bits & 4294967040) bits |= shared.U_MOREBITS1;
     this.writer.writeByte(bits & 255);
-    if (bits & U_MOREBITS1) this.writer.writeByte(bits >> 8 & 255);
-    if (bits & U_MOREBITS2) this.writer.writeByte(bits >> 16 & 255);
-    if (bits & U_MOREBITS3) this.writer.writeByte(bits >> 24 & 255);
-    if (protocolVersion >= 2023 && bits & U_MOREBITS4) {
-      this.writer.writeByte(bitsHigh & 255);
-    }
-    if (bits & U_NUMBER16) this.writer.writeShort(to.number);
-    else this.writer.writeByte(to.number);
-    if (bits & U_MODEL) this.writer.writeByte(to.modelindex);
-    if (bits & U_MODEL2) this.writer.writeByte(to.modelindex2);
-    if (bits & U_MODEL3) this.writer.writeByte(to.modelindex3);
-    if (bits & U_MODEL4) this.writer.writeByte(to.modelindex4);
-    if (bits & U_FRAME8) this.writer.writeByte(to.frame);
-    if (bits & U_FRAME16) this.writer.writeShort(to.frame);
-    if (bits & U_SKIN8 && bits & U_SKIN16) this.writer.writeLong(to.skinnum);
-    else if (bits & U_SKIN8) this.writer.writeByte(to.skinnum);
-    else if (bits & U_SKIN16) this.writer.writeShort(to.skinnum);
-    if (bits & U_EFFECTS8 && bits & U_EFFECTS16) this.writer.writeLong(to.effects);
-    else if (bits & U_EFFECTS8) this.writer.writeByte(to.effects);
-    else if (bits & U_EFFECTS16) this.writer.writeShort(to.effects);
-    if (bits & U_RENDERFX8 && bits & U_RENDERFX16) this.writer.writeLong(to.renderfx);
-    else if (bits & U_RENDERFX8) this.writer.writeByte(to.renderfx);
-    else if (bits & U_RENDERFX16) this.writer.writeShort(to.renderfx);
-    if (bits & U_ORIGIN1) this.writer.writeCoord(to.origin.x);
-    if (bits & U_ORIGIN2) this.writer.writeCoord(to.origin.y);
-    if (bits & U_ORIGIN3) this.writer.writeCoord(to.origin.z);
-    if (bits & U_ANGLE1) this.writer.writeAngle(to.angles.x);
-    if (bits & U_ANGLE2) this.writer.writeAngle(to.angles.y);
-    if (bits & U_ANGLE3) this.writer.writeAngle(to.angles.z);
-    if (bits & U_OLDORIGIN) {
-      this.writer.writeCoord(to.old_origin.x);
-      this.writer.writeCoord(to.old_origin.y);
-      this.writer.writeCoord(to.old_origin.z);
-    }
-    if (bits & U_SOUND) this.writer.writeByte(to.sound);
-    if (bits & U_EVENT) this.writer.writeByte(to.event);
-    if (bits & U_SOLID) this.writer.writeShort(to.solid);
-    if (protocolVersion >= 2023) {
-      if (bits & U_ALPHA) this.writer.writeByte(Math.round(to.alpha * 255));
-      if (bits & U_SCALE) this.writer.writeFloat(to.scale);
-      if (bits & U_INSTANCE_BITS) this.writer.writeLong(to.instanceBits);
-      if (bits & U_LOOP_VOLUME) this.writer.writeByte(Math.round(to.loopVolume * 255));
-      if (bitsHigh & U_LOOP_ATTENUATION_HIGH) this.writer.writeByte(Math.round(to.loopAttenuation * 255));
-      if (bitsHigh & U_OWNER_HIGH) this.writer.writeShort(to.owner);
-      if (bitsHigh & U_OLD_FRAME_HIGH) this.writer.writeShort(to.oldFrame);
+    if (bits & shared.U_MOREBITS1) this.writer.writeByte(bits >> 8 & 255);
+    if (bits & shared.U_MOREBITS2) this.writer.writeByte(bits >> 16 & 255);
+    if (bits & shared.U_MOREBITS3) this.writer.writeByte(bits >> 24 & 255);
+    if (bits & shared.U_MOREBITS4) this.writer.writeByte(bitsHigh & 255);
+    if (to.number >= 256) {
+      this.writer.writeShort(to.number);
+    } else {
+      this.writer.writeByte(to.number);
+    }
+    if (bits & shared.U_MODEL) this.writer.writeByte(to.modelindex);
+    if (bits & shared.U_MODEL2) this.writer.writeByte(to.modelindex2);
+    if (bits & shared.U_MODEL3) this.writer.writeByte(to.modelindex3);
+    if (bits & shared.U_MODEL4) this.writer.writeByte(to.modelindex4);
+    if (bits & shared.U_FRAME8) this.writer.writeByte(to.frame);
+    if (bits & shared.U_FRAME16) this.writer.writeShort(to.frame);
+    if (bits & shared.U_SKIN8) this.writer.writeByte(to.skinnum);
+    if (bits & shared.U_SKIN16) this.writer.writeShort(to.skinnum);
+    if (bits & shared.U_EFFECTS8) this.writer.writeByte(to.effects);
+    if (bits & shared.U_EFFECTS16) this.writer.writeShort(to.effects);
+    if (bits & shared.U_RENDERFX8) this.writer.writeByte(to.renderfx);
+    if (bits & shared.U_RENDERFX16) this.writer.writeShort(to.renderfx);
+    if (bits & shared.U_ORIGIN1) this.writer.writeCoord(to.origin.x);
+    if (bits & shared.U_ORIGIN2) this.writer.writeCoord(to.origin.y);
+    if (bits & shared.U_ORIGIN3) this.writer.writeCoord(to.origin.z);
+    if (bits & shared.U_ANGLE1) this.writer.writeAngle(to.angles.x);
+    if (bits & shared.U_ANGLE2) this.writer.writeAngle(to.angles.y);
+    if (bits & shared.U_ANGLE3) this.writer.writeAngle(to.angles.z);
+    if (bits & shared.U_SOUND) this.writer.writeByte(to.sound ?? 0);
+    if (bits & shared.U_EVENT) this.writer.writeByte(to.event ?? 0);
+    if (bits & shared.U_SOLID) this.writer.writeShort(to.solid);
+    if (this.protocol !== 34) {
+      if (bits & shared.U_ALPHA) this.writer.writeByte(to.alpha * 255);
+      if (bits & shared.U_SCALE) this.writer.writeFloat(to.scale);
+      if (bits & shared.U_INSTANCE_BITS) this.writer.writeLong(to.instanceBits);
+      if (bits & shared.U_LOOP_VOLUME) this.writer.writeByte(to.loopVolume * 255);
+      if (bitsHigh & shared.U_LOOP_ATTENUATION_HIGH) this.writer.writeByte(to.loopAttenuation * 255);
+      if (bitsHigh & shared.U_OWNER_HIGH) this.writer.writeShort(to.owner);
+      if (bitsHigh & shared.U_OLD_FRAME_HIGH) this.writer.writeShort(to.oldFrame);
     }
   }
 };
@@ -14430,294 +14627,210 @@ var DemoValidator = class {
     return { valid: true, version };
   }
 };
-var DemoWriter = class {
-  constructor() {
-    this.writer = new shared.BinaryWriter();
-  }
-  writeBlock(data) {
-    this.writer.writeLong(data.byteLength);
-    this.writer.writeBytes(data);
-  }
-  writeEOF() {
-    this.writer.writeLong(-1);
-  }
-  getData() {
-    return this.writer.getData();
-  }
-};
-
-// src/demo/delta.ts
-function applyEntityDelta(to, from) {
-  const bits = from.bits;
-  const bitsHigh = from.bitsHigh;
-  to.number = from.number;
-  if (bits & U_MODEL) to.modelindex = from.modelindex;
-  if (bits & U_MODEL2) to.modelindex2 = from.modelindex2;
-  if (bits & U_MODEL3) to.modelindex3 = from.modelindex3;
-  if (bits & U_MODEL4) to.modelindex4 = from.modelindex4;
-  if (bits & U_FRAME8) to.frame = from.frame;
-  if (bits & U_FRAME16) to.frame = from.frame;
-  if (bits & U_SKIN8 || bits & U_SKIN16) to.skinnum = from.skinnum;
-  if (bits & U_EFFECTS8 || bits & U_EFFECTS16) to.effects = from.effects;
-  if (bits & U_RENDERFX8 || bits & U_RENDERFX16) to.renderfx = from.renderfx;
-  if (bits & U_ORIGIN1) to.origin.x = from.origin.x;
-  if (bits & U_ORIGIN2) to.origin.y = from.origin.y;
-  if (bits & U_ORIGIN3) to.origin.z = from.origin.z;
-  if (bits & U_ANGLE1) to.angles.x = from.angles.x;
-  if (bits & U_ANGLE2) to.angles.y = from.angles.y;
-  if (bits & U_ANGLE3) to.angles.z = from.angles.z;
-  if (bits & U_OLDORIGIN) {
-    to.old_origin.x = from.old_origin.x;
-    to.old_origin.y = from.old_origin.y;
-    to.old_origin.z = from.old_origin.z;
-  }
-  if (bits & U_SOUND) to.sound = from.sound;
-  if (bits & U_EVENT) to.event = from.event;
-  if (bits & U_SOLID) to.solid = from.solid;
-  if (bits & U_ALPHA) to.alpha = from.alpha;
-  if (bits & U_SCALE) to.scale = from.scale;
-  if (bits & U_INSTANCE_BITS) to.instanceBits = from.instanceBits;
-  if (bits & U_LOOP_VOLUME) to.loopVolume = from.loopVolume;
-  if (bitsHigh & U_LOOP_ATTENUATION_HIGH) to.loopAttenuation = from.loopAttenuation;
-  if (bitsHigh & U_OWNER_HIGH) to.owner = from.owner;
-  if (bitsHigh & U_OLD_FRAME_HIGH) to.oldFrame = from.oldFrame;
-}
 
 // src/demo/clipper.ts
 var DemoClipper = class {
-  /**
-   * Extracts a raw clip from a demo between two offsets.
-   * Simply copies the message blocks.
-   */
-  extractClip(demo, start, end, controller) {
-    const reader = new DemoReader(demo.buffer);
-    const startFrame = start.type === "frame" ? start.frame : controller.timeToFrame(start.seconds);
-    const endFrame = end.type === "frame" ? end.frame : controller.timeToFrame(end.seconds);
-    if (!reader.seekToMessage(startFrame)) {
-      throw new Error(`Start frame ${startFrame} out of bounds`);
-    }
-    const startByteOffset = reader.getOffset();
-    let endByteOffset = demo.byteLength;
-    if (reader.seekToMessage(endFrame + 1)) {
-      endByteOffset = reader.getOffset();
-    }
-    const clipData = demo.slice(startByteOffset, endByteOffset);
-    const result = new Uint8Array(clipData.length + 4);
-    result.set(clipData);
-    const view = new DataView(result.buffer);
-    view.setInt32(clipData.length, -1, true);
-    return result;
-  }
-  extractDemoRange(demo, startFrame, endFrame) {
-    const controller = new DemoPlaybackController();
-    controller.loadDemo(demo.buffer);
-    return this.extractClip(demo, { type: "frame", frame: startFrame }, { type: "frame", frame: endFrame }, controller);
+  constructor(buffer) {
+    this.frames = [];
+    this.configStrings = /* @__PURE__ */ new Map();
+    this.baselines = /* @__PURE__ */ new Map();
+    this.currentEntities = /* @__PURE__ */ new Map();
+    if (buffer) {
+      const sb = new StreamingBuffer(buffer.byteLength);
+      sb.append(new Uint8Array(buffer));
+      sb.setReadPosition(0);
+      this.parser = new NetworkMessageParser(sb, this);
+    } else {
+      this.parser = new NetworkMessageParser(new StreamingBuffer(), this);
+    }
   }
-  /**
-   * Captures the world state at a specific offset by playing the demo up to that point.
-   */
-  async captureWorldState(demo, atOffset) {
-    const controller = new DemoPlaybackController();
-    controller.loadDemo(demo.buffer);
-    const state = {
-      serverData: {
-        protocol: 0,
-        serverCount: 0,
-        attractLoop: 0,
-        gameDir: "",
-        playerNum: 0,
-        levelName: ""
-      },
-      configStrings: /* @__PURE__ */ new Map(),
-      entityBaselines: /* @__PURE__ */ new Map(),
-      playerState: createEmptyProtocolPlayerState(),
-      currentEntities: /* @__PURE__ */ new Map(),
-      currentFrameNumber: 0
-    };
-    const handler = {
-      onServerData: (protocol, serverCount, attractLoop, gameDir, playerNum, levelName, tickRate, demoType) => {
-        state.serverData = { protocol, serverCount, attractLoop, gameDir, playerNum, levelName, tickRate, demoType };
-      },
-      onConfigString: (index, str) => {
-        state.configStrings.set(index, str);
-      },
-      onSpawnBaseline: (entity) => {
-        state.entityBaselines.set(entity.number, { ...entity });
-      },
-      onFrame: (frame) => {
-        state.playerState = { ...frame.playerState };
-        state.currentFrameNumber = frame.serverFrame;
-        if (!frame.packetEntities.delta) {
-          state.currentEntities.clear();
-        }
-        const newEntities = /* @__PURE__ */ new Map();
-        if (frame.packetEntities.delta) {
-          for (const [key, val] of state.currentEntities) {
-            newEntities.set(key, val);
-          }
-        }
-        for (const deltaEnt of frame.packetEntities.entities) {
-          if (deltaEnt.bits & U_REMOVE) {
-            newEntities.delete(deltaEnt.number);
-            continue;
-          }
-          let prev = newEntities.get(deltaEnt.number);
-          if (!prev) {
-            const baseline = state.entityBaselines.get(deltaEnt.number);
-            if (baseline) {
-              prev = { ...baseline };
-            } else {
-              prev = createEmptyEntityState();
-              prev.number = deltaEnt.number;
-            }
-          } else {
-            prev = { ...prev };
+  // Implementation of extractClip matching api.ts usage: extractClip(demoData, start, end, controller)
+  extractClip(demoData, start, end, controller) {
+    const reader = new DemoReader(demoData.buffer);
+    const outputParts = [];
+    let totalLength = 0;
+    const startFrame = start.frame ?? -1;
+    const endFrame = end.frame ?? Number.MAX_SAFE_INTEGER;
+    let currentProtocol = 0;
+    let blockIndex = 0;
+    while (reader.nextBlock()) {
+      const block = reader.getBlock();
+      const blockData = block.data;
+      let keepBlock = false;
+      let frameNum = -1;
+      let parsedSuccessfully = false;
+      const probeHandler = {
+        onServerData: (protocol) => {
+          currentProtocol = protocol;
+          keepBlock = true;
+          parsedSuccessfully = true;
+        },
+        onConfigString: () => {
+          keepBlock = true;
+          parsedSuccessfully = true;
+        },
+        onSpawnBaseline: () => {
+          keepBlock = true;
+          parsedSuccessfully = true;
+        },
+        onFrame: (f) => {
+          frameNum = f.serverFrame;
+          parsedSuccessfully = true;
+          if (frameNum >= startFrame && frameNum <= endFrame) {
+            keepBlock = true;
           }
-          applyEntityDelta(prev, deltaEnt);
-          newEntities.set(deltaEnt.number, prev);
+        },
+        onCenterPrint: () => {
+          parsedSuccessfully = true;
+        },
+        onStuffText: () => {
+          parsedSuccessfully = true;
+        },
+        onPrint: () => {
+          parsedSuccessfully = true;
+        },
+        onSound: () => {
+          parsedSuccessfully = true;
+        },
+        onTempEntity: () => {
+          parsedSuccessfully = true;
+        },
+        onLayout: () => {
+          parsedSuccessfully = true;
+        },
+        onInventory: () => {
+          parsedSuccessfully = true;
+        },
+        onMuzzleFlash: () => {
+          parsedSuccessfully = true;
+        },
+        onMuzzleFlash2: () => {
+          parsedSuccessfully = true;
+        },
+        onDisconnect: () => {
+          parsedSuccessfully = true;
+        },
+        onReconnect: () => {
+          parsedSuccessfully = true;
+        },
+        onDownload: () => {
+          parsedSuccessfully = true;
         }
-        state.currentEntities = newEntities;
-      },
-      onCenterPrint: () => {
-      },
-      onStuffText: () => {
-      },
-      onPrint: () => {
-      },
-      onSound: () => {
-      },
-      onTempEntity: () => {
-      },
-      onLayout: () => {
-      },
-      onInventory: () => {
-      },
-      onMuzzleFlash: () => {
-      },
-      onMuzzleFlash2: () => {
-      },
-      onDisconnect: () => {
-      },
-      onReconnect: () => {
-      },
-      onDownload: () => {
-      }
-    };
-    controller.setHandler(handler);
-    const targetFrame = atOffset.type === "frame" ? atOffset.frame : controller.timeToFrame(atOffset.seconds);
-    controller.seek(targetFrame);
-    return state;
-  }
-  extractStandaloneClip(demo, start, end, worldState) {
-    const demoWriter = new DemoWriter();
-    const headerWriter = new MessageWriter();
-    const controller = new DemoPlaybackController();
-    controller.loadDemo(demo.buffer);
-    const startFrame = start.type === "frame" ? start.frame : controller.timeToFrame(start.seconds);
-    const endFrame = end.type === "frame" ? end.frame : controller.timeToFrame(end.seconds);
-    const { serverData } = worldState;
-    if (serverData.protocol >= 2023) {
-      headerWriter.writeServerDataRerelease(
-        serverData.protocol,
-        serverData.serverCount,
-        serverData.demoType || 0,
-        serverData.tickRate || 10,
-        serverData.gameDir,
-        serverData.playerNum,
-        serverData.levelName
-      );
-    } else {
-      headerWriter.writeServerData(
-        serverData.protocol,
-        serverData.serverCount,
-        serverData.attractLoop,
-        serverData.gameDir,
-        serverData.playerNum,
-        serverData.levelName
-      );
-    }
-    for (const [index, str] of worldState.configStrings) {
-      headerWriter.writeConfigString(index, str, serverData.protocol);
-    }
-    for (const entity of worldState.entityBaselines.values()) {
-      headerWriter.writeSpawnBaseline(entity, serverData.protocol);
-    }
-    const entities = Array.from(worldState.currentEntities.values());
-    const frame0 = {
-      serverFrame: 0,
-      // Rebase to 0
-      deltaFrame: -1,
-      surpressCount: 0,
-      areaBytes: 0,
-      areaBits: new Uint8Array(0),
-      // TODO: capture area bits?
-      playerState: worldState.playerState,
-      packetEntities: {
-        delta: false,
-        entities
-        // These are full entity states, writeFrame will handle them
+      };
+      const sb = new StreamingBuffer(blockData.getLength());
+      sb.append(blockData.readData(blockData.getLength()));
+      sb.setReadPosition(0);
+      blockData.seek(0);
+      const probeParser = new NetworkMessageParser(sb, probeHandler);
+      if (currentProtocol > 0) probeParser.setProtocolVersion(currentProtocol);
+      try {
+        probeParser.parseMessage();
+      } catch (e) {
       }
-    };
-    headerWriter.writeFrame(frame0, serverData.protocol);
-    demoWriter.writeBlock(headerWriter.getData());
-    const frameMap = /* @__PURE__ */ new Map();
-    frameMap.set(startFrame, 0);
-    const reader = new DemoReader(demo.buffer);
-    if (reader.seekToMessage(startFrame + 1)) {
-      let messageIndex = startFrame + 1;
-      while (messageIndex <= endFrame && reader.nextBlock()) {
-        const block = reader.getBlock();
-        const blockStream = block.data;
-        const blockWriter = new MessageWriter();
-        const passthroughHandler = {
-          onServerData: () => {
-          },
-          onConfigString: (idx, str) => blockWriter.writeConfigString(idx, str, serverData.protocol),
-          onSpawnBaseline: (ent) => blockWriter.writeSpawnBaseline(ent, serverData.protocol),
-          onCenterPrint: (msg) => blockWriter.writeCenterPrint(msg, serverData.protocol),
-          onStuffText: (txt) => blockWriter.writeStuffText(txt, serverData.protocol),
-          onPrint: (lvl, msg) => blockWriter.writePrint(lvl, msg, serverData.protocol),
-          onSound: (mask, s, v, a, o, e, p) => blockWriter.writeSound(mask, s, v, a, o, e, p, serverData.protocol),
-          onLayout: (l) => blockWriter.writeLayout(l, serverData.protocol),
-          onInventory: (inv) => blockWriter.writeInventory(inv, serverData.protocol),
-          onMuzzleFlash: (ent, w) => blockWriter.writeMuzzleFlash(ent, w, serverData.protocol),
-          onMuzzleFlash2: (ent, w) => blockWriter.writeMuzzleFlash2(ent, w, serverData.protocol),
-          onTempEntity: (t, p, p2, d, c, clr, e, s, de) => blockWriter.writeTempEntity(t, p, p2, d, c, clr, e, s, de, serverData.protocol),
-          onDisconnect: () => blockWriter.writeDisconnect(serverData.protocol),
-          onReconnect: () => blockWriter.writeReconnect(serverData.protocol),
-          onDownload: () => {
-          },
-          // Stub for download
-          onFrame: (frame) => {
-            const oldSeq = frame.serverFrame;
-            const oldDelta = frame.deltaFrame;
-            const newSeq = messageIndex - startFrame;
-            let newDelta = -1;
-            if (frameMap.has(oldDelta)) {
-              newDelta = frameMap.get(oldDelta);
-            } else {
-              frame.packetEntities.delta = false;
-            }
-            frameMap.set(oldSeq, newSeq);
-            frame.serverFrame = newSeq;
-            frame.deltaFrame = newDelta;
-            blockWriter.writeFrame(frame, serverData.protocol);
-          }
-        };
-        const blockParser = new NetworkMessageParser(blockStream, passthroughHandler, false);
-        blockParser.setProtocolVersion(serverData.protocol);
-        blockParser.parseMessage();
-        const blockData = blockWriter.getData();
-        if (blockData.byteLength > 0) {
-          demoWriter.writeBlock(blockData);
+      if (!parsedSuccessfully) {
+        if (blockIndex >= startFrame && blockIndex <= endFrame) {
+          keepBlock = true;
         }
-        messageIndex++;
       }
+      if (keepBlock) {
+        const blockHeader = new Uint8Array(4);
+        const view = new DataView(blockHeader.buffer);
+        view.setUint32(0, blockData.getLength(), true);
+        outputParts.push(blockHeader);
+        const data = blockData.readData(blockData.getLength());
+        outputParts.push(data);
+        totalLength += 4 + data.length;
+      }
+      blockIndex++;
+    }
+    const eof = new Uint8Array(4);
+    new DataView(eof.buffer).setInt32(0, -1, true);
+    outputParts.push(eof);
+    totalLength += 4;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const part of outputParts) {
+      result.set(part, offset);
+      offset += part.length;
     }
-    demoWriter.writeEOF();
-    return demoWriter.getData();
+    return result;
+  }
+  extractDemoRange(demoData, startFrame, endFrame) {
+    return this.extractClip(demoData, { frame: startFrame }, { frame: endFrame });
+  }
+  // Implement interface methods
+  onServerData(protocol, serverCount, attractLoop, gameDir, playerNum, levelName) {
+    this.serverData = { protocol, serverCount, attractLoop, gameDir, playerNum, levelName };
+  }
+  onConfigString(index, str) {
+    this.configStrings.set(index, str);
+  }
+  onSpawnBaseline(entity) {
+    this.baselines.set(entity.number, entity);
+  }
+  onFrame(frame) {
+    this.frames.push(frame);
+  }
+  onCenterPrint(msg) {
+  }
+  onStuffText(msg) {
+  }
+  onPrint(level, msg) {
+  }
+  onSound(flags, soundNum, volume, attenuation, offset, ent, pos) {
+  }
+  onTempEntity(type, pos, pos2, dir, cnt, color, ent, srcEnt, destEnt) {
+  }
+  onLayout(layout) {
+  }
+  onInventory(inventory) {
+  }
+  onMuzzleFlash(ent, weapon) {
+  }
+  onMuzzleFlash2(ent, weapon) {
+  }
+  onDisconnect() {
+  }
+  onReconnect() {
+  }
+  onDownload(size, percent, data) {
   }
 };
+function applyEntityDelta(target, delta) {
+  const bits = delta.bits;
+  target.bits = bits;
+  target.number = delta.number;
+  if (bits & shared.U_MODEL) target.modelindex = delta.modelindex;
+  if (bits & shared.U_MODEL2) target.modelindex2 = delta.modelindex2;
+  if (bits & shared.U_MODEL3) target.modelindex3 = delta.modelindex3;
+  if (bits & shared.U_MODEL4) target.modelindex4 = delta.modelindex4;
+  if (bits & shared.U_FRAME8) target.frame = delta.frame;
+  if (bits & shared.U_FRAME16) target.frame = delta.frame;
+  if (bits & shared.U_SKIN8) target.skinnum = delta.skinnum;
+  if (bits & shared.U_SKIN16) target.skinnum = delta.skinnum;
+  if (bits & shared.U_EFFECTS8) target.effects = delta.effects;
+  if (bits & shared.U_EFFECTS16) target.effects = delta.effects;
+  if (bits & shared.U_RENDERFX8) target.renderfx = delta.renderfx;
+  if (bits & shared.U_RENDERFX16) target.renderfx = delta.renderfx;
+  if (bits & shared.U_ORIGIN1) target.origin.x = delta.origin.x;
+  if (bits & shared.U_ORIGIN2) target.origin.y = delta.origin.y;
+  if (bits & shared.U_ORIGIN3) target.origin.z = delta.origin.z;
+  if (bits & shared.U_ANGLE1) target.angles.x = delta.angles.x;
+  if (bits & shared.U_ANGLE2) target.angles.y = delta.angles.y;
+  if (bits & shared.U_ANGLE3) target.angles.z = delta.angles.z;
+  if (bits & shared.U_OLDORIGIN) {
+    target.old_origin.x = delta.old_origin.x;
+    target.old_origin.y = delta.old_origin.y;
+    target.old_origin.z = delta.old_origin.z;
+  }
+  if (bits & shared.U_SOUND) target.sound = delta.sound;
+  if (bits & shared.U_EVENT) target.event = delta.event;
+  if (bits & shared.U_SOLID) target.solid = delta.solid;
+  if (bits & shared.U_ALPHA) target.alpha = delta.alpha;
+  if (bits & shared.U_SCALE) target.scale = delta.scale;
+  if (bits & shared.U_INSTANCE_BITS) target.instanceBits = delta.instanceBits;
+  if (bits & shared.U_LOOP_VOLUME) target.loopVolume = delta.loopVolume;
+}
 
 // src/assets/fileType.ts
 var FileType = /* @__PURE__ */ ((FileType2) => {
@@ -15634,6 +15747,126 @@ Object.defineProperty(exports, "SoundChannel", {
   enumerable: true,
   get: function () { return shared.SoundChannel; }
 });
+Object.defineProperty(exports, "U_ALPHA", {
+  enumerable: true,
+  get: function () { return shared.U_ALPHA; }
+});
+Object.defineProperty(exports, "U_ANGLE1", {
+  enumerable: true,
+  get: function () { return shared.U_ANGLE1; }
+});
+Object.defineProperty(exports, "U_ANGLE2", {
+  enumerable: true,
+  get: function () { return shared.U_ANGLE2; }
+});
+Object.defineProperty(exports, "U_ANGLE3", {
+  enumerable: true,
+  get: function () { return shared.U_ANGLE3; }
+});
+Object.defineProperty(exports, "U_EFFECTS16", {
+  enumerable: true,
+  get: function () { return shared.U_EFFECTS16; }
+});
+Object.defineProperty(exports, "U_EFFECTS8", {
+  enumerable: true,
+  get: function () { return shared.U_EFFECTS8; }
+});
+Object.defineProperty(exports, "U_EVENT", {
+  enumerable: true,
+  get: function () { return shared.U_EVENT; }
+});
+Object.defineProperty(exports, "U_FRAME16", {
+  enumerable: true,
+  get: function () { return shared.U_FRAME16; }
+});
+Object.defineProperty(exports, "U_FRAME8", {
+  enumerable: true,
+  get: function () { return shared.U_FRAME8; }
+});
+Object.defineProperty(exports, "U_INSTANCE_BITS", {
+  enumerable: true,
+  get: function () { return shared.U_INSTANCE_BITS; }
+});
+Object.defineProperty(exports, "U_LOOP_ATTENUATION_HIGH", {
+  enumerable: true,
+  get: function () { return shared.U_LOOP_ATTENUATION_HIGH; }
+});
+Object.defineProperty(exports, "U_LOOP_VOLUME", {
+  enumerable: true,
+  get: function () { return shared.U_LOOP_VOLUME; }
+});
+Object.defineProperty(exports, "U_MODEL", {
+  enumerable: true,
+  get: function () { return shared.U_MODEL; }
+});
+Object.defineProperty(exports, "U_MODEL2", {
+  enumerable: true,
+  get: function () { return shared.U_MODEL2; }
+});
+Object.defineProperty(exports, "U_MODEL3", {
+  enumerable: true,
+  get: function () { return shared.U_MODEL3; }
+});
+Object.defineProperty(exports, "U_MODEL4", {
+  enumerable: true,
+  get: function () { return shared.U_MODEL4; }
+});
+Object.defineProperty(exports, "U_OLDORIGIN", {
+  enumerable: true,
+  get: function () { return shared.U_OLDORIGIN; }
+});
+Object.defineProperty(exports, "U_OLD_FRAME_HIGH", {
+  enumerable: true,
+  get: function () { return shared.U_OLD_FRAME_HIGH; }
+});
+Object.defineProperty(exports, "U_ORIGIN1", {
+  enumerable: true,
+  get: function () { return shared.U_ORIGIN1; }
+});
+Object.defineProperty(exports, "U_ORIGIN2", {
+  enumerable: true,
+  get: function () { return shared.U_ORIGIN2; }
+});
+Object.defineProperty(exports, "U_ORIGIN3", {
+  enumerable: true,
+  get: function () { return shared.U_ORIGIN3; }
+});
+Object.defineProperty(exports, "U_OWNER_HIGH", {
+  enumerable: true,
+  get: function () { return shared.U_OWNER_HIGH; }
+});
+Object.defineProperty(exports, "U_REMOVE", {
+  enumerable: true,
+  get: function () { return shared.U_REMOVE; }
+});
+Object.defineProperty(exports, "U_RENDERFX16", {
+  enumerable: true,
+  get: function () { return shared.U_RENDERFX16; }
+});
+Object.defineProperty(exports, "U_RENDERFX8", {
+  enumerable: true,
+  get: function () { return shared.U_RENDERFX8; }
+});
+Object.defineProperty(exports, "U_SCALE", {
+  enumerable: true,
+  get: function () { return shared.U_SCALE; }
+});
+Object.defineProperty(exports, "U_SKIN16", {
+  enumerable: true,
+  get: function () { return shared.U_SKIN16; }
+});
+Object.defineProperty(exports, "U_SKIN8", {
+  enumerable: true,
+  get: function () { return shared.U_SKIN8; }
+});
+Object.defineProperty(exports, "U_SOLID", {
+  enumerable: true,
+  get: function () { return shared.U_SOLID; }
+});
+Object.defineProperty(exports, "U_SOUND", {
+  enumerable: true,
+  get: function () { return shared.U_SOUND; }
+});
 Object.defineProperty(exports, "attenuationToDistanceMultiplier", {
   enumerable: true,
   get: function () { return shared.attenuationToDistanceMultiplier; }
@@ -15729,36 +15962,6 @@ exports.Texture2D = Texture2D;
 exports.TextureCache = TextureCache;
 exports.TextureCubeMap = TextureCubeMap;
 exports.TgaParseError = TgaParseError;
-exports.U_ALPHA = U_ALPHA;
-exports.U_ANGLE1 = U_ANGLE1;
-exports.U_ANGLE2 = U_ANGLE2;
-exports.U_ANGLE3 = U_ANGLE3;
-exports.U_EFFECTS16 = U_EFFECTS16;
-exports.U_EFFECTS8 = U_EFFECTS8;
-exports.U_EVENT = U_EVENT;
-exports.U_FRAME16 = U_FRAME16;
-exports.U_FRAME8 = U_FRAME8;
-exports.U_INSTANCE_BITS = U_INSTANCE_BITS;
-exports.U_LOOP_ATTENUATION_HIGH = U_LOOP_ATTENUATION_HIGH;
-exports.U_LOOP_VOLUME = U_LOOP_VOLUME;
-exports.U_MODEL = U_MODEL;
-exports.U_MODEL2 = U_MODEL2;
-exports.U_MODEL3 = U_MODEL3;
-exports.U_MODEL4 = U_MODEL4;
-exports.U_OLDORIGIN = U_OLDORIGIN;
-exports.U_OLD_FRAME_HIGH = U_OLD_FRAME_HIGH;
-exports.U_ORIGIN1 = U_ORIGIN1;
-exports.U_ORIGIN2 = U_ORIGIN2;
-exports.U_ORIGIN3 = U_ORIGIN3;
-exports.U_OWNER_HIGH = U_OWNER_HIGH;
-exports.U_REMOVE = U_REMOVE;
-exports.U_RENDERFX16 = U_RENDERFX16;
-exports.U_RENDERFX8 = U_RENDERFX8;
-exports.U_SCALE = U_SCALE;
-exports.U_SKIN16 = U_SKIN16;
-exports.U_SKIN8 = U_SKIN8;
-exports.U_SOLID = U_SOLID;
-exports.U_SOUND = U_SOUND;
 exports.VertexArray = VertexArray;
 exports.VertexBuffer = VertexBuffer;
 exports.VirtualFileSystem = VirtualFileSystem;