quake2ts 0.0.7 → 0.0.39

package/apps/viewer/dist/cjs/index.cjs

@@ -25,30 +25,719 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // ../../packages/client/dist/esm/index.js
+var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD = Math.PI / 180;
+function addVec3(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function scaleVec3(a, scalar) {
+  return { x: a.x * scalar, y: a.y * scalar, z: a.z * scalar };
+}
+function dotVec3(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthSquaredVec3(a) {
+  return dotVec3(a, a);
+}
+function lengthVec3(a) {
+  return Math.sqrt(lengthSquaredVec3(a));
+}
+function normalizeVec3(a) {
+  const len = lengthVec3(a);
+  return len === 0 ? a : scaleVec3(a, 1 / len);
+}
+var PITCH = 0;
+var YAW = 1;
+var ROLL = 2;
+var DEG2RAD_FACTOR = Math.PI / 180;
+var RAD2DEG_FACTOR = 180 / Math.PI;
+function axisComponent(vec, axis) {
+  switch (axis) {
+    case PITCH:
+      return vec.x;
+    case YAW:
+      return vec.y;
+    case ROLL:
+    default:
+      return vec.z;
+  }
+}
+function degToRad(degrees) {
+  return degrees * DEG2RAD_FACTOR;
+}
+function angleMod(angle) {
+  const value = angle % 360;
+  return value < 0 ? 360 + value : value;
+}
+function angleVectors(angles) {
+  const yaw = degToRad(axisComponent(angles, YAW));
+  const pitch = degToRad(axisComponent(angles, PITCH));
+  const roll = degToRad(axisComponent(angles, ROLL));
+  const sy = Math.sin(yaw);
+  const cy = Math.cos(yaw);
+  const sp = Math.sin(pitch);
+  const cp = Math.cos(pitch);
+  const sr = Math.sin(roll);
+  const cr = Math.cos(roll);
+  const forward = {
+    x: cp * cy,
+    y: cp * sy,
+    z: -sp
+  };
+  const right = {
+    x: -sr * sp * cy - cr * -sy,
+    y: -sr * sp * sy - cr * cy,
+    z: -sr * cp
+  };
+  const up = {
+    x: cr * sp * cy - sr * -sy,
+    y: cr * sp * sy - sr * cy,
+    z: cr * cp
+  };
+  return { forward, right, up };
+}
+var CONTENTS_SOLID = 1 << 0;
+var CONTENTS_WINDOW = 1 << 1;
+var CONTENTS_AUX = 1 << 2;
+var CONTENTS_LAVA = 1 << 3;
+var CONTENTS_SLIME = 1 << 4;
+var CONTENTS_WATER = 1 << 5;
+var CONTENTS_MIST = 1 << 6;
+var CONTENTS_NO_WATERJUMP = 1 << 13;
+var CONTENTS_PROJECTILECLIP = 1 << 14;
+var CONTENTS_AREAPORTAL = 1 << 15;
+var CONTENTS_PLAYERCLIP = 1 << 16;
+var CONTENTS_MONSTERCLIP = 1 << 17;
+var CONTENTS_CURRENT_0 = 1 << 18;
+var CONTENTS_CURRENT_90 = 1 << 19;
+var CONTENTS_CURRENT_180 = 1 << 20;
+var CONTENTS_CURRENT_270 = 1 << 21;
+var CONTENTS_CURRENT_UP = 1 << 22;
+var CONTENTS_CURRENT_DOWN = 1 << 23;
+var CONTENTS_ORIGIN = 1 << 24;
+var CONTENTS_MONSTER = 1 << 25;
+var CONTENTS_DEADMONSTER = 1 << 26;
+var CONTENTS_DETAIL = 1 << 27;
+var CONTENTS_TRANSLUCENT = 1 << 28;
+var CONTENTS_LADDER = 1 << 29;
+var CONTENTS_PLAYER = 1 << 30;
+var CONTENTS_PROJECTILE = 1 << 31;
+var SURF_LIGHT = 1 << 0;
+var SURF_SLICK = 1 << 1;
+var SURF_SKY = 1 << 2;
+var SURF_WARP = 1 << 3;
+var SURF_TRANS33 = 1 << 4;
+var SURF_TRANS66 = 1 << 5;
+var SURF_FLOWING = 1 << 6;
+var SURF_NODRAW = 1 << 7;
+var SURF_ALPHATEST = 1 << 25;
+var SURF_N64_UV = 1 << 28;
+var SURF_N64_SCROLL_X = 1 << 29;
+var SURF_N64_SCROLL_Y = 1 << 30;
+var SURF_N64_SCROLL_FLIP = 1 << 31;
+var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
+var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+var MAX_CHECKCOUNT = Number.MAX_SAFE_INTEGER - 1;
+var MAX_CLIENTS = 256;
+var MAX_LIGHTSTYLES = 256;
+var MAX_MODELS = 8192;
+var MAX_SOUNDS = 2048;
+var MAX_IMAGES = 512;
+var MAX_ITEMS = 256;
+var MAX_GENERAL = MAX_CLIENTS * 2;
+var MAX_SHADOW_LIGHTS = 256;
+var MAX_WHEEL_ITEMS = 32;
+var ConfigStringIndex = ((ConfigStringIndex22) => {
+  ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
+  ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
+  ConfigStringIndex22[ConfigStringIndex22["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex22[ConfigStringIndex22["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex22[ConfigStringIndex22["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex22[ConfigStringIndex22["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex22;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
+  WaterLevel3[WaterLevel3["None"] = 0] = "None";
+  WaterLevel3[WaterLevel3["Feet"] = 1] = "Feet";
+  WaterLevel3[WaterLevel3["Waist"] = 2] = "Waist";
+  WaterLevel3[WaterLevel3["Under"] = 3] = "Under";
+  return WaterLevel3;
+})(WaterLevel || {});
+var PmFlag = /* @__PURE__ */ ((PmFlag2) => {
+  PmFlag2[PmFlag2["Ducked"] = 1] = "Ducked";
+  PmFlag2[PmFlag2["JumpHeld"] = 2] = "JumpHeld";
+  PmFlag2[PmFlag2["OnGround"] = 4] = "OnGround";
+  PmFlag2[PmFlag2["TimeWaterJump"] = 8] = "TimeWaterJump";
+  PmFlag2[PmFlag2["TimeLand"] = 16] = "TimeLand";
+  PmFlag2[PmFlag2["TimeTeleport"] = 32] = "TimeTeleport";
+  PmFlag2[PmFlag2["NoPositionalPrediction"] = 64] = "NoPositionalPrediction";
+  PmFlag2[PmFlag2["OnLadder"] = 128] = "OnLadder";
+  PmFlag2[PmFlag2["NoAngularPrediction"] = 256] = "NoAngularPrediction";
+  PmFlag2[PmFlag2["IgnorePlayerCollision"] = 512] = "IgnorePlayerCollision";
+  PmFlag2[PmFlag2["TimeTrick"] = 1024] = "TimeTrick";
+  return PmFlag2;
+})(PmFlag || {});
+function hasPmFlag(flags, flag) {
+  return (flags & flag) !== 0;
+}
+var PmType = /* @__PURE__ */ ((PmType2) => {
+  PmType2[PmType2["Normal"] = 0] = "Normal";
+  PmType2[PmType2["Grapple"] = 1] = "Grapple";
+  PmType2[PmType2["NoClip"] = 2] = "NoClip";
+  PmType2[PmType2["Spectator"] = 3] = "Spectator";
+  PmType2[PmType2["Dead"] = 4] = "Dead";
+  PmType2[PmType2["Gib"] = 5] = "Gib";
+  PmType2[PmType2["Freeze"] = 6] = "Freeze";
+  return PmType2;
+})(PmType || {});
+var PlayerButton = /* @__PURE__ */ ((PlayerButton2) => {
+  PlayerButton2[PlayerButton2["None"] = 0] = "None";
+  PlayerButton2[PlayerButton2["Attack"] = 1] = "Attack";
+  PlayerButton2[PlayerButton2["Use"] = 2] = "Use";
+  PlayerButton2[PlayerButton2["Holster"] = 4] = "Holster";
+  PlayerButton2[PlayerButton2["Jump"] = 8] = "Jump";
+  PlayerButton2[PlayerButton2["Crouch"] = 16] = "Crouch";
+  PlayerButton2[PlayerButton2["Any"] = 128] = "Any";
+  return PlayerButton2;
+})(PlayerButton || {});
+function applyPmoveFriction(params) {
+  const {
+    velocity,
+    frametime,
+    onGround,
+    groundIsSlick,
+    onLadder,
+    waterlevel,
+    pmFriction,
+    pmStopSpeed,
+    pmWaterFriction
+  } = params;
+  const speed = lengthVec3(velocity);
+  if (speed < 1) {
+    return { x: 0, y: 0, z: velocity.z };
+  }
+  let drop = 0;
+  if (onGround && !groundIsSlick || onLadder) {
+    const control = speed < pmStopSpeed ? pmStopSpeed : speed;
+    const friction = pmFriction;
+    drop += control * friction * frametime;
+  }
+  if (waterlevel > 0 && !onLadder) {
+    drop += speed * pmWaterFriction * waterlevel * frametime;
+  }
+  let newspeed = speed - drop;
+  if (newspeed < 0) {
+    newspeed = 0;
+  }
+  if (newspeed === speed) {
+    return velocity;
+  }
+  const scale = newspeed / speed;
+  return scaleVec3(velocity, scale);
+}
+function applyPmoveAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspeed - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * frametime * wishspeed;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function applyPmoveAirAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const wishspd = Math.min(wishspeed, 30);
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspd - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * wishspeed * frametime;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function buildAirGroundWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+function buildWaterWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  if (cmd.upmove > 10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else if (cmd.upmove < -10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: 10 });
+  }
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  wishspeed *= 0.5;
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+function addAngles(cmdAngles, deltaAngles) {
+  return {
+    x: cmdAngles.x + deltaAngles.x,
+    y: cmdAngles.y + deltaAngles.y,
+    z: cmdAngles.z + deltaAngles.z
+  };
+}
+function clampPitch(pitch) {
+  if (pitch > 89 && pitch < 180) {
+    return 89;
+  }
+  if (pitch < 271 && pitch >= 180) {
+    return 271;
+  }
+  return pitch;
+}
+function clampViewAngles(params) {
+  const { pmFlags, cmdAngles, deltaAngles } = params;
+  let viewangles;
+  if ((pmFlags & 32) !== 0) {
+    viewangles = {
+      x: 0,
+      y: cmdAngles.y + deltaAngles.y,
+      z: 0
+    };
+  } else {
+    viewangles = addAngles(cmdAngles, deltaAngles);
+    viewangles = { ...viewangles, x: clampPitch(viewangles.x) };
+  }
+  const vectors = angleVectors(viewangles);
+  return { viewangles, ...vectors };
+}
+var DEFAULTS = {
+  pmFriction: 6,
+  pmStopSpeed: 100,
+  pmAccelerate: 10,
+  pmAirAccelerate: 1,
+  pmWaterAccelerate: 4,
+  pmWaterFriction: 1,
+  pmMaxSpeed: 300,
+  pmDuckSpeed: 100,
+  pmWaterSpeed: 400,
+  groundIsSlick: false
+};
+var DEFAULT_GRAVITY = 800;
+var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+var MSEC_MAX = 250;
+function defaultPredictionState() {
+  return {
+    origin: ZERO_VEC32,
+    velocity: ZERO_VEC32,
+    viewangles: ZERO_VEC32,
+    pmFlags: PmFlag.OnGround,
+    pmType: PmType.Normal,
+    waterlevel: WaterLevel.None,
+    gravity: DEFAULT_GRAVITY,
+    deltaAngles: ZERO_VEC32
+  };
+}
+function normalizeState(state) {
+  if (!state) return defaultPredictionState();
+  return {
+    ...defaultPredictionState(),
+    ...state,
+    origin: { ...state.origin },
+    velocity: { ...state.velocity },
+    viewangles: { ...state.viewangles },
+    deltaAngles: state.deltaAngles ? { ...state.deltaAngles } : ZERO_VEC32
+  };
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpAngle(a, b, t) {
+  let delta = angleMod(b - a);
+  if (delta > 180) {
+    delta -= 360;
+  }
+  return angleMod(a + delta * t);
+}
+function interpolatePredictionState(previous, latest, alpha) {
+  const clamped = Math.max(0, Math.min(alpha, 1));
+  return {
+    origin: {
+      x: lerp(previous.origin.x, latest.origin.x, clamped),
+      y: lerp(previous.origin.y, latest.origin.y, clamped),
+      z: lerp(previous.origin.z, latest.origin.z, clamped)
+    },
+    velocity: {
+      x: lerp(previous.velocity.x, latest.velocity.x, clamped),
+      y: lerp(previous.velocity.y, latest.velocity.y, clamped),
+      z: lerp(previous.velocity.z, latest.velocity.z, clamped)
+    },
+    viewangles: {
+      x: lerpAngle(previous.viewangles.x, latest.viewangles.x, clamped),
+      y: lerpAngle(previous.viewangles.y, latest.viewangles.y, clamped),
+      z: lerpAngle(previous.viewangles.z, latest.viewangles.z, clamped)
+    },
+    pmFlags: latest.pmFlags,
+    pmType: latest.pmType,
+    waterlevel: latest.waterlevel,
+    gravity: latest.gravity,
+    deltaAngles: latest.deltaAngles
+  };
+}
+function simulateCommand(state, cmd, settings) {
+  const frametime = Math.min(Math.max(cmd.msec, 0), MSEC_MAX) / 1e3;
+  const onGround = hasPmFlag(state.pmFlags, PmFlag.OnGround);
+  const onLadder = hasPmFlag(state.pmFlags, PmFlag.OnLadder);
+  let velocity = applyPmoveFriction({
+    velocity: state.velocity,
+    frametime,
+    onGround,
+    groundIsSlick: settings.groundIsSlick,
+    onLadder,
+    waterlevel: state.waterlevel,
+    pmFriction: settings.pmFriction,
+    pmStopSpeed: settings.pmStopSpeed,
+    pmWaterFriction: settings.pmWaterFriction
+  });
+  const { viewangles, forward, right } = clampViewAngles({
+    pmFlags: state.pmFlags,
+    cmdAngles: cmd.angles,
+    deltaAngles: state.deltaAngles ?? ZERO_VEC32
+  });
+  const wish = state.waterlevel > WaterLevel.None ? buildWaterWish({ forward, right, cmd, maxSpeed: settings.pmWaterSpeed }) : buildAirGroundWish({ forward, right, cmd, maxSpeed: settings.pmMaxSpeed });
+  if (state.waterlevel > WaterLevel.None) {
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: wish.wishdir,
+      wishspeed: wish.wishspeed,
+      accel: settings.pmWaterAccelerate,
+      frametime
+    });
+  } else if (onGround || onLadder) {
+    const maxSpeed = hasPmFlag(state.pmFlags, PmFlag.Ducked) ? settings.pmDuckSpeed : settings.pmMaxSpeed;
+    const clampedWish = wish.wishspeed > maxSpeed ? {
+      wishdir: wish.wishdir,
+      wishspeed: maxSpeed
+    } : wish;
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: clampedWish.wishdir,
+      wishspeed: clampedWish.wishspeed,
+      accel: settings.pmAccelerate,
+      frametime
+    });
+  } else {
+    velocity = applyPmoveAirAccelerate({
+      velocity,
+      wishdir: wish.wishdir,
+      wishspeed: wish.wishspeed,
+      accel: settings.pmAirAccelerate,
+      frametime
+    });
+    velocity = { ...velocity, z: velocity.z - state.gravity * frametime };
+  }
+  const originDelta = scaleVec3(velocity, frametime);
+  const origin = addVec3(state.origin, originDelta);
+  return {
+    ...state,
+    origin,
+    velocity,
+    viewangles
+  };
+}
+var ClientPrediction = class {
+  constructor(settings = {}) {
+    this.baseFrame = {
+      frame: 0,
+      timeMs: 0,
+      state: defaultPredictionState()
+    };
+    this.commands = [];
+    this.predicted = defaultPredictionState();
+    this.settings = { ...DEFAULTS, ...settings };
+    this.predicted = this.baseFrame.state ?? defaultPredictionState();
+  }
+  setAuthoritative(frame) {
+    const normalized = normalizeState(frame.state);
+    this.baseFrame = { ...frame, state: normalized };
+    this.commands = this.commands.filter((cmd) => (cmd.serverFrame ?? Number.MAX_SAFE_INTEGER) > frame.frame);
+    return this.recompute();
+  }
+  enqueueCommand(cmd) {
+    this.commands.push(cmd);
+    return this.recompute();
+  }
+  getPredictedState() {
+    return this.predicted;
+  }
+  recompute() {
+    let state = normalizeState(this.baseFrame.state);
+    for (const cmd of this.commands) {
+      state = simulateCommand(state, cmd, this.settings);
+    }
+    this.predicted = state;
+    return state;
+  }
+};
+var DEFAULT_SETTINGS = {
+  runPitch: 2e-3,
+  runRoll: 5e-3,
+  bobUp: 5e-3,
+  bobPitch: 2e-3,
+  bobRoll: 2e-3,
+  maxBobHeight: 6,
+  maxBobAngle: 1.2
+};
+function clampViewOffset(offset) {
+  return {
+    x: Math.max(-14, Math.min(14, offset.x)),
+    y: Math.max(-14, Math.min(14, offset.y)),
+    z: Math.max(-22, Math.min(30, offset.z))
+  };
+}
+function computeBobMove(xyspeed, onGround, frameTimeMs) {
+  if (!onGround) return 0;
+  if (xyspeed > 210) return frameTimeMs / 400;
+  if (xyspeed > 100) return frameTimeMs / 800;
+  return frameTimeMs / 1600;
+}
+function computeBobValues(previousBobTime, xyspeed, pmFlags, onGround, frameTimeMs) {
+  if (xyspeed < 5) {
+    return { bobTime: 0, bobCycle: 0, bobCycleRun: 0, bobFracSin: 0 };
+  }
+  const bobMove = computeBobMove(xyspeed, onGround, frameTimeMs);
+  const bobTimeRun = previousBobTime + bobMove;
+  const crouched = hasPmFlag(pmFlags, PmFlag.Ducked) && onGround;
+  const bobTime = crouched ? bobTimeRun * 4 : bobTimeRun;
+  return {
+    bobTime: bobTimeRun,
+    bobCycle: Math.floor(bobTime),
+    bobCycleRun: Math.floor(bobTimeRun),
+    bobFracSin: Math.abs(Math.sin(bobTime * Math.PI))
+  };
+}
+var ViewEffects = class {
+  constructor(settings = {}) {
+    this.bobTime = 0;
+    this.bobCycle = 0;
+    this.bobCycleRun = 0;
+    this.bobFracSin = 0;
+    this.settings = { ...DEFAULT_SETTINGS, ...settings };
+  }
+  addKick(kick) {
+    if (kick.durationMs <= 0) return;
+    this.kick = { ...kick, remainingMs: kick.durationMs };
+  }
+  get last() {
+    return this.lastSample;
+  }
+  sample(state, frameTimeMs) {
+    const { forward, right } = angleVectors(
+      clampViewAngles({ pmFlags: state.pmFlags, cmdAngles: state.viewangles, deltaAngles: state.deltaAngles ?? ZERO_VEC3 }).viewangles
+    );
+    const xyspeed = Math.sqrt(state.velocity.x * state.velocity.x + state.velocity.y * state.velocity.y);
+    const onGround = hasPmFlag(state.pmFlags, PmFlag.OnGround);
+    const bobValues = computeBobValues(this.bobTime, xyspeed, state.pmFlags, onGround, frameTimeMs);
+    this.bobTime = bobValues.bobTime;
+    this.bobCycle = bobValues.bobCycle;
+    this.bobCycleRun = bobValues.bobCycleRun;
+    this.bobFracSin = bobValues.bobFracSin;
+    let pitchTilt = dotVec3(state.velocity, forward) * this.settings.runPitch;
+    let rollTilt = dotVec3(state.velocity, right) * this.settings.runRoll;
+    let pitchDelta = this.bobFracSin * this.settings.bobPitch * xyspeed;
+    let rollDelta = this.bobFracSin * this.settings.bobRoll * xyspeed;
+    if (hasPmFlag(state.pmFlags, PmFlag.Ducked) && onGround) {
+      pitchDelta *= 6;
+      rollDelta *= 6;
+    }
+    pitchTilt += Math.min(pitchDelta, this.settings.maxBobAngle);
+    rollDelta = Math.min(rollDelta, this.settings.maxBobAngle);
+    if (this.bobCycle & 1) rollDelta = -rollDelta;
+    rollTilt += rollDelta;
+    const bobHeight = Math.min(this.bobFracSin * xyspeed * this.settings.bobUp, this.settings.maxBobHeight);
+    let kickPitch = 0;
+    let kickRoll = 0;
+    if (this.kick && this.kick.remainingMs > 0) {
+      const ratio = Math.max(0, Math.min(1, this.kick.remainingMs / this.kick.durationMs));
+      kickPitch += ratio * this.kick.pitch;
+      kickRoll += ratio * this.kick.roll;
+      this.kick.remainingMs = Math.max(0, this.kick.remainingMs - frameTimeMs);
+      if (this.kick.remainingMs === 0) this.kick = void 0;
+    }
+    const angles = { x: pitchTilt + kickPitch, y: 0, z: rollTilt + kickRoll };
+    const offset = { x: 0, y: 0, z: bobHeight };
+    const sample = {
+      angles,
+      offset: clampViewOffset(offset),
+      bobCycle: this.bobCycle,
+      bobCycleRun: this.bobCycleRun,
+      bobFracSin: this.bobFracSin,
+      xyspeed
+    };
+    this.lastSample = sample;
+    return sample;
+  }
+};
+function normalizeCommand(command) {
+  return command.trim().toLowerCase();
+}
+var InputAction = /* @__PURE__ */ ((InputAction2) => {
+  InputAction2["Forward"] = "+forward";
+  InputAction2["Back"] = "+back";
+  InputAction2["MoveLeft"] = "+moveleft";
+  InputAction2["MoveRight"] = "+moveright";
+  InputAction2["MoveUp"] = "+moveup";
+  InputAction2["MoveDown"] = "+movedown";
+  InputAction2["Jump"] = "+jump";
+  InputAction2["Crouch"] = "+crouch";
+  InputAction2["Attack"] = "+attack";
+  InputAction2["Use"] = "+use";
+  InputAction2["Holster"] = "+holster";
+  InputAction2["TurnLeft"] = "+left";
+  InputAction2["TurnRight"] = "+right";
+  InputAction2["LookUp"] = "+lookup";
+  InputAction2["LookDown"] = "+lookdown";
+  InputAction2["SpeedModifier"] = "+speed";
+  InputAction2["Zoom"] = "+zoom";
+  return InputAction2;
+})(InputAction || {});
+var BUTTON_ACTIONS = {
+  [
+    "+attack"
+    /* Attack */
+  ]: PlayerButton.Attack,
+  [
+    "+use"
+    /* Use */
+  ]: PlayerButton.Use,
+  [
+    "+holster"
+    /* Holster */
+  ]: PlayerButton.Holster,
+  [
+    "+jump"
+    /* Jump */
+  ]: PlayerButton.Jump,
+  [
+    "+crouch"
+    /* Crouch */
+  ]: PlayerButton.Crouch
+};
+var ACTION_LOOKUP = new Map(
+  Object.values(InputAction).map((action) => [normalizeCommand(action), action])
+);
 function createClient(imports) {
+  const prediction = new ClientPrediction();
+  const view = new ViewEffects();
   let latestFrame;
+  let lastRendered;
+  let lastView;
   return {
     init(initial) {
       latestFrame = initial;
+      if (initial?.state) {
+        prediction.setAuthoritative(initial);
+      }
       void imports.engine.trace({ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 });
     },
-    predict(next) {
-      const { origin, velocity } = next;
-      return {
-        origin: {
-          x: origin.x + velocity.x,
-          y: origin.y + velocity.y,
-          z: origin.z + velocity.z
-        },
-        velocity
-      };
+    predict(command) {
+      return prediction.enqueueCommand(command);
     },
     render(sample) {
-      latestFrame = sample.latest ?? latestFrame;
+      if (sample.latest?.state) {
+        prediction.setAuthoritative(sample.latest);
+        latestFrame = sample.latest;
+      }
+      if (sample.previous?.state && sample.latest?.state) {
+        lastRendered = interpolatePredictionState(sample.previous.state, sample.latest.state, sample.alpha);
+      } else {
+        lastRendered = sample.latest?.state ?? sample.previous?.state ?? prediction.getPredictedState();
+      }
+      const frameTimeMs = sample.latest && sample.previous ? Math.max(0, sample.latest.timeMs - sample.previous.timeMs) : 0;
+      lastView = view.sample(lastRendered, frameTimeMs);
+      void imports;
       void sample;
     },
     shutdown() {
       latestFrame = void 0;
+      lastRendered = void 0;
+    },
+    get prediction() {
+      return prediction;
+    },
+    get lastRendered() {
+      return lastRendered;
+    },
+    get view() {
+      return view;
+    },
+    get lastView() {
+      return lastView;
     }
   };
 }
@@ -181,71 +870,72 @@ var EngineHost = class {
     return this.loop.isRunning();
   }
 };
-var DEG_TO_RAD = Math.PI / 180;
-var DEG2RAD_FACTOR = Math.PI / 180;
-var RAD2DEG_FACTOR = 180 / Math.PI;
-var CONTENTS_SOLID = 1 << 0;
-var CONTENTS_WINDOW = 1 << 1;
-var CONTENTS_AUX = 1 << 2;
-var CONTENTS_LAVA = 1 << 3;
-var CONTENTS_SLIME = 1 << 4;
-var CONTENTS_WATER = 1 << 5;
-var CONTENTS_MIST = 1 << 6;
-var CONTENTS_NO_WATERJUMP = 1 << 13;
-var CONTENTS_PROJECTILECLIP = 1 << 14;
-var CONTENTS_AREAPORTAL = 1 << 15;
-var CONTENTS_PLAYERCLIP = 1 << 16;
-var CONTENTS_MONSTERCLIP = 1 << 17;
-var CONTENTS_CURRENT_0 = 1 << 18;
-var CONTENTS_CURRENT_90 = 1 << 19;
-var CONTENTS_CURRENT_180 = 1 << 20;
-var CONTENTS_CURRENT_270 = 1 << 21;
-var CONTENTS_CURRENT_UP = 1 << 22;
-var CONTENTS_CURRENT_DOWN = 1 << 23;
-var CONTENTS_ORIGIN = 1 << 24;
-var CONTENTS_MONSTER = 1 << 25;
-var CONTENTS_DEADMONSTER = 1 << 26;
-var CONTENTS_DETAIL = 1 << 27;
-var CONTENTS_TRANSLUCENT = 1 << 28;
-var CONTENTS_LADDER = 1 << 29;
-var CONTENTS_PLAYER = 1 << 30;
-var CONTENTS_PROJECTILE = 1 << 31;
-var SURF_LIGHT = 1 << 0;
-var SURF_SLICK = 1 << 1;
-var SURF_SKY = 1 << 2;
-var SURF_WARP = 1 << 3;
-var SURF_TRANS33 = 1 << 4;
-var SURF_TRANS66 = 1 << 5;
-var SURF_FLOWING = 1 << 6;
-var SURF_NODRAW = 1 << 7;
-var SURF_ALPHATEST = 1 << 25;
-var SURF_N64_UV = 1 << 28;
-var SURF_N64_SCROLL_X = 1 << 29;
-var SURF_N64_SCROLL_Y = 1 << 30;
-var SURF_N64_SCROLL_FLIP = 1 << 31;
-var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
-var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
-var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
-var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
-var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
-var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
-var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
-var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
-var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
-var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
-var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
-var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
-var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
-var MAX_CLIENTS = 256;
-var MAX_LIGHTSTYLES = 256;
-var MAX_MODELS = 8192;
-var MAX_SOUNDS = 2048;
-var MAX_IMAGES = 512;
-var MAX_ITEMS = 256;
-var MAX_GENERAL = MAX_CLIENTS * 2;
-var MAX_SHADOW_LIGHTS = 256;
-var MAX_WHEEL_ITEMS = 32;
-var ConfigStringIndex = ((ConfigStringIndex22) => {
+var DEG_TO_RAD2 = Math.PI / 180;
+var DEG2RAD_FACTOR2 = Math.PI / 180;
+var RAD2DEG_FACTOR2 = 180 / Math.PI;
+var CONTENTS_SOLID2 = 1 << 0;
+var CONTENTS_WINDOW2 = 1 << 1;
+var CONTENTS_AUX2 = 1 << 2;
+var CONTENTS_LAVA2 = 1 << 3;
+var CONTENTS_SLIME2 = 1 << 4;
+var CONTENTS_WATER2 = 1 << 5;
+var CONTENTS_MIST2 = 1 << 6;
+var CONTENTS_NO_WATERJUMP2 = 1 << 13;
+var CONTENTS_PROJECTILECLIP2 = 1 << 14;
+var CONTENTS_AREAPORTAL2 = 1 << 15;
+var CONTENTS_PLAYERCLIP2 = 1 << 16;
+var CONTENTS_MONSTERCLIP2 = 1 << 17;
+var CONTENTS_CURRENT_02 = 1 << 18;
+var CONTENTS_CURRENT_902 = 1 << 19;
+var CONTENTS_CURRENT_1802 = 1 << 20;
+var CONTENTS_CURRENT_2702 = 1 << 21;
+var CONTENTS_CURRENT_UP2 = 1 << 22;
+var CONTENTS_CURRENT_DOWN2 = 1 << 23;
+var CONTENTS_ORIGIN2 = 1 << 24;
+var CONTENTS_MONSTER2 = 1 << 25;
+var CONTENTS_DEADMONSTER2 = 1 << 26;
+var CONTENTS_DETAIL2 = 1 << 27;
+var CONTENTS_TRANSLUCENT2 = 1 << 28;
+var CONTENTS_LADDER2 = 1 << 29;
+var CONTENTS_PLAYER2 = 1 << 30;
+var CONTENTS_PROJECTILE2 = 1 << 31;
+var SURF_LIGHT2 = 1 << 0;
+var SURF_SLICK2 = 1 << 1;
+var SURF_SKY2 = 1 << 2;
+var SURF_WARP2 = 1 << 3;
+var SURF_TRANS332 = 1 << 4;
+var SURF_TRANS662 = 1 << 5;
+var SURF_FLOWING2 = 1 << 6;
+var SURF_NODRAW2 = 1 << 7;
+var SURF_ALPHATEST2 = 1 << 25;
+var SURF_N64_UV2 = 1 << 28;
+var SURF_N64_SCROLL_X2 = 1 << 29;
+var SURF_N64_SCROLL_Y2 = 1 << 30;
+var SURF_N64_SCROLL_FLIP2 = 1 << 31;
+var MASK_SOLID2 = CONTENTS_SOLID2 | CONTENTS_WINDOW2;
+var MASK_PLAYERSOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
+var MASK_DEADSOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2;
+var MASK_MONSTERSOLID2 = CONTENTS_SOLID2 | CONTENTS_MONSTERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
+var MASK_WATER2 = CONTENTS_WATER2 | CONTENTS_LAVA2 | CONTENTS_SLIME2;
+var MASK_OPAQUE2 = CONTENTS_SOLID2 | CONTENTS_SLIME2 | CONTENTS_LAVA2;
+var MASK_SHOT2 = CONTENTS_SOLID2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2 | CONTENTS_WINDOW2 | CONTENTS_DEADMONSTER2;
+var MASK_CURRENT2 = CONTENTS_CURRENT_02 | CONTENTS_CURRENT_902 | CONTENTS_CURRENT_1802 | CONTENTS_CURRENT_2702 | CONTENTS_CURRENT_UP2 | CONTENTS_CURRENT_DOWN2;
+var MASK_BLOCK_SIGHT2 = CONTENTS_SOLID2 | CONTENTS_LAVA2 | CONTENTS_SLIME2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
+var MASK_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2;
+var MASK_LADDER_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_WINDOW2;
+var MASK_WALK_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTERCLIP2;
+var MASK_PROJECTILE2 = MASK_SHOT2 | CONTENTS_PROJECTILECLIP2;
+var MAX_CHECKCOUNT2 = Number.MAX_SAFE_INTEGER - 1;
+var MAX_CLIENTS2 = 256;
+var MAX_LIGHTSTYLES2 = 256;
+var MAX_MODELS2 = 8192;
+var MAX_SOUNDS2 = 2048;
+var MAX_IMAGES2 = 512;
+var MAX_ITEMS2 = 256;
+var MAX_GENERAL2 = MAX_CLIENTS2 * 2;
+var MAX_SHADOW_LIGHTS2 = 256;
+var MAX_WHEEL_ITEMS2 = 32;
+var ConfigStringIndex2 = ((ConfigStringIndex22) => {
   ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
   ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
   ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
@@ -256,23 +946,23 @@ var ConfigStringIndex = ((ConfigStringIndex22) => {
   ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
   ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
   ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
-  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS] = "Sounds";
-  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS] = "Images";
-  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES] = "Lights";
-  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
-  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
-  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS] = "PlayerSkins";
-  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS] = "General";
-  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL] = "WheelWeapons";
-  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
-  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
-  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS2] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS2] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES2] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES2] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS2] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS2] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS2] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL2] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS2] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS2] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS2] = "CdLoopCount";
   ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
   ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
   return ConfigStringIndex22;
-})(ConfigStringIndex || {});
-var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
-var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+})(ConfigStringIndex2 || {});
+var MAX_CONFIGSTRINGS2 = ConfigStringIndex2.MaxConfigStrings;
+var WATERJUMP_CLEAR2 = 8 | 16 | 32 | 1024;
 var EngineRuntime = class {
   constructor(engine, host) {
     this.engine = engine;
@@ -311,102 +1001,357 @@ function createCrcTable() {
     for (let j = 0; j < 8; j += 1) {
       crc = (crc & 1) !== 0 ? 3988292384 ^ crc >>> 1 : crc >>> 1;
     }
-    table[i] = crc >>> 0;
+    table[i] = crc >>> 0;
+  }
+  return table;
+}
+var CRC_TABLE = createCrcTable();
+var RERELEASE_KNOWN_PAKS = Object.freeze([
+  // Base campaign
+  { name: "pak0.pak", checksum: 2378051181, description: "Base game assets" },
+  { name: "pak0.pak@baseq2", checksum: 2378051181, description: "Base game assets (baseq2)" },
+  // Mission packs bundled with the rerelease
+  { name: "pak0.pak@rogue", checksum: 3373211245, description: "Ground Zero (rogue) mission pack" },
+  { name: "pak0.pak@xatrix", checksum: 1358269824, description: "The Reckoning (xatrix) mission pack" }
+]);
+var HEADER_SIZE2 = 17 * 4;
+var FLOAT_BYTES = 4;
+var STRIDE = 7 * FLOAT_BYTES;
+var BSP_VERTEX_LAYOUT = [
+  // Position
+  { index: 0, size: 3, type: 5126, stride: STRIDE, offset: 0 },
+  // Diffuse UV
+  { index: 1, size: 2, type: 5126, stride: STRIDE, offset: 3 * FLOAT_BYTES },
+  // Lightmap UV
+  { index: 2, size: 2, type: 5126, stride: STRIDE, offset: 5 * FLOAT_BYTES }
+];
+var SKYBOX_POSITIONS = new Float32Array([
+  // Front
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  // Back
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  // Left
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  // Right
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  // Top
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  // Bottom
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  1
+]);
+function createEngine(imports) {
+  return {
+    init() {
+      void imports.trace({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 0 });
+    },
+    shutdown() {
+    },
+    createMainLoop(callbacks, options) {
+      return new FixedTimestepLoop(callbacks, options);
+    }
+  };
+}
+
+// ../../packages/game/dist/esm/index.js
+var ZERO_VEC33 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD3 = Math.PI / 180;
+var DEG2RAD_FACTOR3 = Math.PI / 180;
+var RAD2DEG_FACTOR3 = 180 / Math.PI;
+var STATE_SIZE = 624;
+var MIDDLE_WORD = 397;
+var MATRIX_A = 2567483615;
+var UPPER_MASK = 2147483648;
+var LOWER_MASK = 2147483647;
+var TWO_POW_32 = 4294967296;
+var MersenneTwister19937 = class {
+  constructor(seed = 5489) {
+    this.state = new Uint32Array(STATE_SIZE);
+    this.index = STATE_SIZE;
+    this.seed(seed);
+  }
+  seed(seed) {
+    this.state[0] = seed >>> 0;
+    for (let i = 1; i < STATE_SIZE; i++) {
+      const prev = this.state[i - 1] ^ this.state[i - 1] >>> 30;
+      const next = Math.imul(prev >>> 0, 1812433253) + i;
+      this.state[i] = next >>> 0;
+    }
+    this.index = STATE_SIZE;
+  }
+  nextUint32() {
+    if (this.index >= STATE_SIZE) {
+      this.twist();
+    }
+    let y = this.state[this.index++];
+    y ^= y >>> 11;
+    y ^= y << 7 & 2636928640;
+    y ^= y << 15 & 4022730752;
+    y ^= y >>> 18;
+    return y >>> 0;
+  }
+  twist() {
+    for (let i = 0; i < STATE_SIZE; i++) {
+      const y = this.state[i] & UPPER_MASK | this.state[(i + 1) % STATE_SIZE] & LOWER_MASK;
+      let next = this.state[(i + MIDDLE_WORD) % STATE_SIZE] ^ y >>> 1;
+      if ((y & 1) !== 0) {
+        next ^= MATRIX_A;
+      }
+      this.state[i] = next >>> 0;
+    }
+    this.index = 0;
+  }
+  getState() {
+    return {
+      index: this.index,
+      state: Array.from(this.state)
+    };
+  }
+  setState(snapshot) {
+    if (snapshot.state.length !== STATE_SIZE) {
+      throw new Error(`Expected ${STATE_SIZE} MT state values, received ${snapshot.state.length}`);
+    }
+    this.index = snapshot.index;
+    this.state = Uint32Array.from(snapshot.state, (value) => value >>> 0);
+  }
+};
+var RandomGenerator = class {
+  constructor(options = {}) {
+    this.mt = new MersenneTwister19937(options.seed);
+  }
+  /** Uniform float in [0, 1). */
+  frandom() {
+    return this.mt.nextUint32() / TWO_POW_32;
+  }
+  /** Uniform float in [min, max). */
+  frandomRange(minInclusive, maxExclusive) {
+    return minInclusive + (maxExclusive - minInclusive) * this.frandom();
+  }
+  /** Uniform float in [0, max). */
+  frandomMax(maxExclusive) {
+    return this.frandomRange(0, maxExclusive);
+  }
+  /** Uniform float in [-1, 1). */
+  crandom() {
+    return this.frandomRange(-1, 1);
+  }
+  /** Uniform float in (-1, 1). */
+  crandomOpen() {
+    const epsilon = Number.EPSILON;
+    return this.frandomRange(-1 + epsilon, 1);
+  }
+  /** Raw uint32 sample. */
+  irandomUint32() {
+    return this.mt.nextUint32();
+  }
+  /** Uniform integer in [min, max). */
+  irandomRange(minInclusive, maxExclusive) {
+    if (maxExclusive - minInclusive <= 1) {
+      return minInclusive;
+    }
+    const span = maxExclusive - minInclusive;
+    const limit = TWO_POW_32 - TWO_POW_32 % span;
+    let sample;
+    do {
+      sample = this.mt.nextUint32();
+    } while (sample >= limit);
+    return minInclusive + sample % span;
+  }
+  /** Uniform integer in [0, max). */
+  irandom(maxExclusive) {
+    if (maxExclusive <= 0) {
+      return 0;
+    }
+    return this.irandomRange(0, maxExclusive);
   }
-  return table;
-}
-var CRC_TABLE = createCrcTable();
-var HEADER_SIZE2 = 17 * 4;
-var FLOAT_BYTES = 4;
-var STRIDE = 7 * FLOAT_BYTES;
-var BSP_VERTEX_LAYOUT = [
-  // Position
-  { index: 0, size: 3, type: 5126, stride: STRIDE, offset: 0 },
-  // Diffuse UV
-  { index: 1, size: 2, type: 5126, stride: STRIDE, offset: 3 * FLOAT_BYTES },
-  // Lightmap UV
-  { index: 2, size: 2, type: 5126, stride: STRIDE, offset: 5 * FLOAT_BYTES }
-];
-function createEngine(imports) {
-  return {
-    init() {
-      void imports.trace({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 0 });
-    },
-    shutdown() {
-    },
-    createMainLoop(callbacks, options) {
-      return new FixedTimestepLoop(callbacks, options);
+  /** Uniform time in milliseconds [min, max). */
+  randomTimeRange(minMs, maxMs) {
+    if (maxMs <= minMs) {
+      return minMs;
     }
-  };
+    return this.irandomRange(minMs, maxMs);
+  }
+  /** Uniform time in milliseconds [0, max). */
+  randomTime(maxMs) {
+    return this.irandom(maxMs);
+  }
+  randomIndex(container) {
+    return this.irandom(container.length);
+  }
+  getState() {
+    return { mt: this.mt.getState() };
+  }
+  setState(snapshot) {
+    this.mt.setState(snapshot.mt);
+  }
+};
+function createRandomGenerator(options) {
+  return new RandomGenerator(options);
 }
-
-// ../../packages/game/dist/esm/index.js
-var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
-var DEG_TO_RAD2 = Math.PI / 180;
-var DEG2RAD_FACTOR2 = Math.PI / 180;
-var RAD2DEG_FACTOR2 = 180 / Math.PI;
-var CONTENTS_SOLID2 = 1 << 0;
-var CONTENTS_WINDOW2 = 1 << 1;
-var CONTENTS_AUX2 = 1 << 2;
-var CONTENTS_LAVA2 = 1 << 3;
-var CONTENTS_SLIME2 = 1 << 4;
-var CONTENTS_WATER2 = 1 << 5;
-var CONTENTS_MIST2 = 1 << 6;
-var CONTENTS_NO_WATERJUMP2 = 1 << 13;
-var CONTENTS_PROJECTILECLIP2 = 1 << 14;
-var CONTENTS_AREAPORTAL2 = 1 << 15;
-var CONTENTS_PLAYERCLIP2 = 1 << 16;
-var CONTENTS_MONSTERCLIP2 = 1 << 17;
-var CONTENTS_CURRENT_02 = 1 << 18;
-var CONTENTS_CURRENT_902 = 1 << 19;
-var CONTENTS_CURRENT_1802 = 1 << 20;
-var CONTENTS_CURRENT_2702 = 1 << 21;
-var CONTENTS_CURRENT_UP2 = 1 << 22;
-var CONTENTS_CURRENT_DOWN2 = 1 << 23;
-var CONTENTS_ORIGIN2 = 1 << 24;
-var CONTENTS_MONSTER2 = 1 << 25;
-var CONTENTS_DEADMONSTER2 = 1 << 26;
-var CONTENTS_DETAIL2 = 1 << 27;
-var CONTENTS_TRANSLUCENT2 = 1 << 28;
-var CONTENTS_LADDER2 = 1 << 29;
-var CONTENTS_PLAYER2 = 1 << 30;
-var CONTENTS_PROJECTILE2 = 1 << 31;
-var SURF_LIGHT2 = 1 << 0;
-var SURF_SLICK2 = 1 << 1;
-var SURF_SKY2 = 1 << 2;
-var SURF_WARP2 = 1 << 3;
-var SURF_TRANS332 = 1 << 4;
-var SURF_TRANS662 = 1 << 5;
-var SURF_FLOWING2 = 1 << 6;
-var SURF_NODRAW2 = 1 << 7;
-var SURF_ALPHATEST2 = 1 << 25;
-var SURF_N64_UV2 = 1 << 28;
-var SURF_N64_SCROLL_X2 = 1 << 29;
-var SURF_N64_SCROLL_Y2 = 1 << 30;
-var SURF_N64_SCROLL_FLIP2 = 1 << 31;
-var MASK_SOLID2 = CONTENTS_SOLID2 | CONTENTS_WINDOW2;
-var MASK_PLAYERSOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
-var MASK_DEADSOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2;
-var MASK_MONSTERSOLID2 = CONTENTS_SOLID2 | CONTENTS_MONSTERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
-var MASK_WATER2 = CONTENTS_WATER2 | CONTENTS_LAVA2 | CONTENTS_SLIME2;
-var MASK_OPAQUE2 = CONTENTS_SOLID2 | CONTENTS_SLIME2 | CONTENTS_LAVA2;
-var MASK_SHOT2 = CONTENTS_SOLID2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2 | CONTENTS_WINDOW2 | CONTENTS_DEADMONSTER2;
-var MASK_CURRENT2 = CONTENTS_CURRENT_02 | CONTENTS_CURRENT_902 | CONTENTS_CURRENT_1802 | CONTENTS_CURRENT_2702 | CONTENTS_CURRENT_UP2 | CONTENTS_CURRENT_DOWN2;
-var MASK_BLOCK_SIGHT2 = CONTENTS_SOLID2 | CONTENTS_LAVA2 | CONTENTS_SLIME2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
-var MASK_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2;
-var MASK_LADDER_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_WINDOW2;
-var MASK_WALK_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTERCLIP2;
-var MASK_PROJECTILE2 = MASK_SHOT2 | CONTENTS_PROJECTILECLIP2;
-var MAX_CLIENTS2 = 256;
-var MAX_LIGHTSTYLES2 = 256;
-var MAX_MODELS2 = 8192;
-var MAX_SOUNDS2 = 2048;
-var MAX_IMAGES2 = 512;
-var MAX_ITEMS2 = 256;
-var MAX_GENERAL2 = MAX_CLIENTS2 * 2;
-var MAX_SHADOW_LIGHTS2 = 256;
-var MAX_WHEEL_ITEMS2 = 32;
-var ConfigStringIndex2 = ((ConfigStringIndex22) => {
+var CONTENTS_SOLID3 = 1 << 0;
+var CONTENTS_WINDOW3 = 1 << 1;
+var CONTENTS_AUX3 = 1 << 2;
+var CONTENTS_LAVA3 = 1 << 3;
+var CONTENTS_SLIME3 = 1 << 4;
+var CONTENTS_WATER3 = 1 << 5;
+var CONTENTS_MIST3 = 1 << 6;
+var CONTENTS_NO_WATERJUMP3 = 1 << 13;
+var CONTENTS_PROJECTILECLIP3 = 1 << 14;
+var CONTENTS_AREAPORTAL3 = 1 << 15;
+var CONTENTS_PLAYERCLIP3 = 1 << 16;
+var CONTENTS_MONSTERCLIP3 = 1 << 17;
+var CONTENTS_CURRENT_03 = 1 << 18;
+var CONTENTS_CURRENT_903 = 1 << 19;
+var CONTENTS_CURRENT_1803 = 1 << 20;
+var CONTENTS_CURRENT_2703 = 1 << 21;
+var CONTENTS_CURRENT_UP3 = 1 << 22;
+var CONTENTS_CURRENT_DOWN3 = 1 << 23;
+var CONTENTS_ORIGIN3 = 1 << 24;
+var CONTENTS_MONSTER3 = 1 << 25;
+var CONTENTS_DEADMONSTER3 = 1 << 26;
+var CONTENTS_DETAIL3 = 1 << 27;
+var CONTENTS_TRANSLUCENT3 = 1 << 28;
+var CONTENTS_LADDER3 = 1 << 29;
+var CONTENTS_PLAYER3 = 1 << 30;
+var CONTENTS_PROJECTILE3 = 1 << 31;
+var SURF_LIGHT3 = 1 << 0;
+var SURF_SLICK3 = 1 << 1;
+var SURF_SKY3 = 1 << 2;
+var SURF_WARP3 = 1 << 3;
+var SURF_TRANS333 = 1 << 4;
+var SURF_TRANS663 = 1 << 5;
+var SURF_FLOWING3 = 1 << 6;
+var SURF_NODRAW3 = 1 << 7;
+var SURF_ALPHATEST3 = 1 << 25;
+var SURF_N64_UV3 = 1 << 28;
+var SURF_N64_SCROLL_X3 = 1 << 29;
+var SURF_N64_SCROLL_Y3 = 1 << 30;
+var SURF_N64_SCROLL_FLIP3 = 1 << 31;
+var MASK_SOLID3 = CONTENTS_SOLID3 | CONTENTS_WINDOW3;
+var MASK_PLAYERSOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
+var MASK_DEADSOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3;
+var MASK_MONSTERSOLID3 = CONTENTS_SOLID3 | CONTENTS_MONSTERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
+var MASK_WATER3 = CONTENTS_WATER3 | CONTENTS_LAVA3 | CONTENTS_SLIME3;
+var MASK_OPAQUE3 = CONTENTS_SOLID3 | CONTENTS_SLIME3 | CONTENTS_LAVA3;
+var MASK_SHOT3 = CONTENTS_SOLID3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3 | CONTENTS_WINDOW3 | CONTENTS_DEADMONSTER3;
+var MASK_CURRENT3 = CONTENTS_CURRENT_03 | CONTENTS_CURRENT_903 | CONTENTS_CURRENT_1803 | CONTENTS_CURRENT_2703 | CONTENTS_CURRENT_UP3 | CONTENTS_CURRENT_DOWN3;
+var MASK_BLOCK_SIGHT3 = CONTENTS_SOLID3 | CONTENTS_LAVA3 | CONTENTS_SLIME3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
+var MASK_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3;
+var MASK_LADDER_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_WINDOW3;
+var MASK_WALK_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTERCLIP3;
+var MASK_PROJECTILE3 = MASK_SHOT3 | CONTENTS_PROJECTILECLIP3;
+var MAX_CHECKCOUNT3 = Number.MAX_SAFE_INTEGER - 1;
+var MAX_CLIENTS3 = 256;
+var MAX_LIGHTSTYLES3 = 256;
+var MAX_MODELS3 = 8192;
+var MAX_SOUNDS3 = 2048;
+var MAX_IMAGES3 = 512;
+var MAX_ITEMS3 = 256;
+var MAX_GENERAL3 = MAX_CLIENTS3 * 2;
+var MAX_SHADOW_LIGHTS3 = 256;
+var MAX_WHEEL_ITEMS3 = 32;
+var ConfigStringIndex3 = ((ConfigStringIndex22) => {
   ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
   ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
   ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
@@ -417,27 +1362,28 @@ var ConfigStringIndex2 = ((ConfigStringIndex22) => {
   ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
   ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
   ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
-  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS2] = "Sounds";
-  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS2] = "Images";
-  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES2] = "Lights";
-  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES2] = "ShadowLights";
-  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS2] = "Items";
-  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS2] = "PlayerSkins";
-  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS2] = "General";
-  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL2] = "WheelWeapons";
-  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS2] = "WheelAmmo";
-  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS2] = "WheelPowerups";
-  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS2] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS3] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS3] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES3] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES3] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS3] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS3] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS3] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL3] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS3] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS3] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS3] = "CdLoopCount";
   ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
   ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
   return ConfigStringIndex22;
-})(ConfigStringIndex2 || {});
-var MAX_CONFIGSTRINGS2 = ConfigStringIndex2.MaxConfigStrings;
-var WATERJUMP_CLEAR2 = 8 | 16 | 32 | 1024;
-var ZERO = { ...ZERO_VEC3 };
+})(ConfigStringIndex3 || {});
+var MAX_CONFIGSTRINGS3 = ConfigStringIndex3.MaxConfigStrings;
+var WATERJUMP_CLEAR3 = 8 | 16 | 32 | 1024;
+var ZERO = { ...ZERO_VEC33 };
 function copyVec3() {
   return { ...ZERO };
 }
+var DEFAULT_MONSTER_INFO = Object.freeze({ aiflags: 0 });
 var Entity = class {
   constructor(index) {
     this.inUse = false;
@@ -446,17 +1392,20 @@ var Entity = class {
     this.linkNext = null;
     this.classname = "";
     this.spawnflags = 0;
+    this.inventory = {};
     this.origin = copyVec3();
     this.old_origin = copyVec3();
     this.velocity = copyVec3();
     this.avelocity = copyVec3();
     this.angles = copyVec3();
+    this.viewheight = 0;
     this.mins = copyVec3();
     this.maxs = copyVec3();
     this.size = copyVec3();
     this.mass = 0;
     this.gravity = 1;
     this.movetype = 0;
+    this.movedir = copyVec3();
     this.modelindex = 0;
     this.frame = 0;
     this.skin = 0;
@@ -466,20 +1415,35 @@ var Entity = class {
     this.max_health = 0;
     this.takedamage = false;
     this.dmg = 0;
+    this.speed = 0;
     this.deadflag = 0;
+    this.count = 0;
+    this.wait = 0;
+    this.delay = 0;
+    this.timestamp = 0;
+    this.sounds = 0;
+    this.noise_index = 0;
+    this.fly_sound_debounce_time = 0;
     this.enemy = null;
     this.movetarget = null;
+    this.target_ent = null;
     this.goalentity = null;
     this.ideal_yaw = 0;
     this.yaw_speed = 0;
+    this.search_time = 0;
+    this.attack_finished_time = 0;
+    this.pain_finished_time = 0;
+    this.trail_time = 0;
     this.groundentity = null;
     this.groundentity_linkcount = 0;
     this.waterlevel = 0;
     this.watertype = 0;
     this.nextthink = 0;
+    this.activator = null;
     this.solid = 0;
     this.flags = 0;
     this.svflags = 0;
+    this.monsterinfo = { ...DEFAULT_MONSTER_INFO };
     this.index = index;
   }
   reset() {
@@ -491,19 +1455,26 @@ var Entity = class {
     this.spawnflags = 0;
     this.target = void 0;
     this.targetname = void 0;
+    this.killtarget = void 0;
     this.team = void 0;
     this.message = void 0;
+    this.pathtarget = void 0;
+    this.model = void 0;
+    this.item = void 0;
+    this.inventory = {};
     this.origin = copyVec3();
     this.old_origin = copyVec3();
     this.velocity = copyVec3();
     this.avelocity = copyVec3();
     this.angles = copyVec3();
+    this.viewheight = 0;
     this.mins = copyVec3();
     this.maxs = copyVec3();
     this.size = copyVec3();
     this.mass = 0;
     this.gravity = 1;
     this.movetype = 0;
+    this.movedir = copyVec3();
     this.modelindex = 0;
     this.frame = 0;
     this.skin = 0;
@@ -513,12 +1484,25 @@ var Entity = class {
     this.max_health = 0;
     this.takedamage = false;
     this.dmg = 0;
+    this.speed = 0;
     this.deadflag = 0;
+    this.count = 0;
+    this.wait = 0;
+    this.delay = 0;
+    this.timestamp = 0;
+    this.sounds = 0;
+    this.noise_index = 0;
+    this.fly_sound_debounce_time = 0;
     this.enemy = null;
     this.movetarget = null;
+    this.target_ent = null;
     this.goalentity = null;
     this.ideal_yaw = 0;
     this.yaw_speed = 0;
+    this.search_time = 0;
+    this.attack_finished_time = 0;
+    this.pain_finished_time = 0;
+    this.trail_time = 0;
     this.groundentity = null;
     this.groundentity_linkcount = 0;
     this.waterlevel = 0;
@@ -529,11 +1513,80 @@ var Entity = class {
     this.use = void 0;
     this.pain = void 0;
     this.die = void 0;
+    this.activator = null;
     this.solid = 0;
     this.flags = 0;
     this.svflags = 0;
+    this.monsterinfo = { ...DEFAULT_MONSTER_INFO };
   }
 };
+var ENTITY_FIELD_METADATA = [
+  { name: "classname", type: "string", save: true },
+  { name: "spawnflags", type: "int", save: true },
+  { name: "target", type: "string", save: true },
+  { name: "targetname", type: "string", save: true },
+  { name: "killtarget", type: "string", save: true },
+  { name: "team", type: "string", save: true },
+  { name: "message", type: "string", save: true },
+  { name: "pathtarget", type: "string", save: true },
+  { name: "model", type: "string", save: true },
+  { name: "item", type: "string", save: true },
+  { name: "inventory", type: "inventory", save: true },
+  { name: "origin", type: "vec3", save: true },
+  { name: "old_origin", type: "vec3", save: true },
+  { name: "velocity", type: "vec3", save: true },
+  { name: "avelocity", type: "vec3", save: true },
+  { name: "angles", type: "vec3", save: true },
+  { name: "viewheight", type: "int", save: true },
+  { name: "mins", type: "vec3", save: true },
+  { name: "maxs", type: "vec3", save: true },
+  { name: "size", type: "vec3", save: true },
+  { name: "mass", type: "int", save: true },
+  { name: "gravity", type: "float", save: true },
+  { name: "movetype", type: "int", save: true },
+  { name: "movedir", type: "vec3", save: true },
+  { name: "modelindex", type: "int", save: true },
+  { name: "frame", type: "int", save: true },
+  { name: "skin", type: "int", save: true },
+  { name: "effects", type: "int", save: true },
+  { name: "renderfx", type: "int", save: true },
+  { name: "health", type: "int", save: true },
+  { name: "max_health", type: "int", save: true },
+  { name: "takedamage", type: "boolean", save: true },
+  { name: "dmg", type: "int", save: true },
+  { name: "speed", type: "float", save: true },
+  { name: "deadflag", type: "int", save: true },
+  { name: "count", type: "int", save: true },
+  { name: "wait", type: "float", save: true },
+  { name: "delay", type: "float", save: true },
+  { name: "timestamp", type: "float", save: true },
+  { name: "sounds", type: "int", save: true },
+  { name: "noise_index", type: "int", save: true },
+  { name: "fly_sound_debounce_time", type: "float", save: true },
+  { name: "enemy", type: "entity", save: true },
+  { name: "movetarget", type: "entity", save: true },
+  { name: "target_ent", type: "entity", save: true },
+  { name: "goalentity", type: "entity", save: true },
+  { name: "ideal_yaw", type: "float", save: true },
+  { name: "yaw_speed", type: "float", save: true },
+  { name: "search_time", type: "float", save: true },
+  { name: "attack_finished_time", type: "float", save: true },
+  { name: "pain_finished_time", type: "float", save: true },
+  { name: "trail_time", type: "float", save: true },
+  { name: "groundentity", type: "entity", save: true },
+  { name: "groundentity_linkcount", type: "int", save: true },
+  { name: "waterlevel", type: "int", save: true },
+  { name: "watertype", type: "int", save: true },
+  { name: "nextthink", type: "float", save: true },
+  { name: "solid", type: "int", save: true },
+  { name: "flags", type: "int", save: true },
+  { name: "svflags", type: "int", save: true },
+  { name: "think", type: "callback", save: false },
+  { name: "touch", type: "callback", save: false },
+  { name: "use", type: "callback", save: false },
+  { name: "pain", type: "callback", save: false },
+  { name: "die", type: "callback", save: false }
+];
 var MAX_EDICTS = 2048;
 var WORLD_INDEX = 0;
 var EntityPool = class {
@@ -605,6 +1658,17 @@ var EntityPool = class {
     entity.freePending = true;
     this.pendingFree.push(entity.index);
   }
+  freeImmediate(entity) {
+    if (entity.index === WORLD_INDEX) {
+      throw new Error("Cannot free world entity");
+    }
+    if (!entity.inUse) {
+      return;
+    }
+    this.unlink(entity);
+    entity.reset();
+    this.freeList.push(entity.index);
+  }
   flushFreeList() {
     if (this.pendingFree.length === 0) {
       return;
@@ -616,6 +1680,69 @@ var EntityPool = class {
     }
     this.pendingFree.length = 0;
   }
+  createSnapshot() {
+    const activeOrder = Array.from(this, (entity) => entity.index);
+    return {
+      capacity: this.entities.length,
+      activeOrder,
+      freeList: [...this.freeList],
+      pendingFree: [...this.pendingFree]
+    };
+  }
+  restore(snapshot) {
+    if (snapshot.capacity !== this.entities.length) {
+      throw new Error(`Snapshot capacity ${snapshot.capacity} does not match pool capacity ${this.entities.length}`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const noteIndex = (index, label) => {
+      if (index < 0 || index >= this.entities.length) {
+        throw new Error(`Invalid entity index ${index} in ${label}`);
+      }
+      if (seen.has(index)) {
+        throw new Error(`Duplicate entity index ${index} in snapshot`);
+      }
+      seen.add(index);
+    };
+    for (const index of snapshot.activeOrder) {
+      noteIndex(index, "activeOrder");
+    }
+    for (const index of snapshot.freeList) {
+      noteIndex(index, "freeList");
+    }
+    for (const index of snapshot.pendingFree) {
+      noteIndex(index, "pendingFree");
+    }
+    this.activeHead = null;
+    this.freeList.length = 0;
+    this.pendingFree.length = 0;
+    for (const entity of this.entities) {
+      entity.reset();
+    }
+    for (let i = snapshot.activeOrder.length - 1; i >= 0; i -= 1) {
+      const entity = this.entities[snapshot.activeOrder[i]];
+      entity.inUse = true;
+      this.link(entity);
+    }
+    for (const index of snapshot.pendingFree) {
+      const entity = this.entities[index];
+      entity.inUse = false;
+      entity.freePending = true;
+      entity.linkNext = null;
+      entity.linkPrevious = null;
+      this.pendingFree.push(index);
+    }
+    for (const index of snapshot.freeList) {
+      const entity = this.entities[index];
+      entity.inUse = false;
+      entity.freePending = false;
+      entity.linkNext = null;
+      entity.linkPrevious = null;
+      this.freeList.push(index);
+    }
+    if (!snapshot.activeOrder.includes(WORLD_INDEX)) {
+      throw new Error("Snapshot must include the world entity as active");
+    }
+  }
   link(entity) {
     entity.linkNext = this.activeHead;
     if (this.activeHead) {
@@ -657,6 +1784,19 @@ var ThinkScheduler = class {
       }
     }
   }
+  snapshot() {
+    return this.queue.map(({ time, entity }) => ({ time, entityIndex: entity.index }));
+  }
+  restore(entries, resolver) {
+    this.queue.length = 0;
+    for (const entry of entries) {
+      const entity = resolver(entry.entityIndex);
+      if (!entity) {
+        continue;
+      }
+      this.schedule(entity, entry.time);
+    }
+  }
   runDueThinks(currentTimeSeconds) {
     while (this.queue.length > 0) {
       const next = this.queue[0];
@@ -695,8 +1835,41 @@ function computeBounds(entity) {
 function boundsIntersect(a, b) {
   return !(a.min.x > b.max.x || a.max.x < b.min.x || a.min.y > b.max.y || a.max.y < b.min.y || a.min.z > b.max.z || a.max.z < b.min.z);
 }
+var SERIALIZABLE_FIELDS = ENTITY_FIELD_METADATA.filter(
+  (field) => field.save
+);
+var DESCRIPTORS = new Map(SERIALIZABLE_FIELDS.map((descriptor) => [descriptor.name, descriptor]));
+function serializeVec3(vec) {
+  return [vec.x, vec.y, vec.z];
+}
+function deserializeVec3(value) {
+  const vec = value;
+  if (!Array.isArray(vec) || vec.length !== 3) {
+    throw new Error("Invalid vec3 serialization");
+  }
+  const [x, y, z] = vec;
+  return { x, y, z };
+}
+function assignField(entity, name, value) {
+  entity[name] = value;
+}
+function serializeInventory(inventory) {
+  return { ...inventory };
+}
+function deserializeInventory(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid inventory serialization");
+  }
+  const parsed = {};
+  for (const [key, entry] of Object.entries(value)) {
+    parsed[key] = Number(entry);
+  }
+  return parsed;
+}
 var EntitySystem = class {
   constructor(maxEntities) {
+    this.targetNameIndex = /* @__PURE__ */ new Map();
+    this.random = createRandomGenerator();
     this.currentTimeSeconds = 0;
     this.pool = new EntityPool(maxEntities);
     this.thinkScheduler = new ThinkScheduler();
@@ -715,24 +1888,179 @@ var EntitySystem = class {
       callback(entity);
     }
   }
-  spawn() {
-    return this.pool.spawn();
+  spawn() {
+    return this.pool.spawn();
+  }
+  free(entity) {
+    this.unregisterTarget(entity);
+    this.thinkScheduler.cancel(entity);
+    this.pool.deferFree(entity);
+  }
+  freeImmediate(entity) {
+    this.unregisterTarget(entity);
+    this.thinkScheduler.cancel(entity);
+    this.pool.freeImmediate(entity);
+  }
+  scheduleThink(entity, nextThinkSeconds) {
+    this.thinkScheduler.schedule(entity, nextThinkSeconds);
+  }
+  beginFrame(timeSeconds) {
+    this.currentTimeSeconds = timeSeconds;
+  }
+  finalizeSpawn(entity) {
+    if (!entity.inUse || entity.freePending) {
+      return;
+    }
+    this.registerTarget(entity);
+  }
+  findByClassname(classname) {
+    const matches = [];
+    for (const entity of this.pool) {
+      if (entity.classname === classname && entity.inUse && !entity.freePending) {
+        matches.push(entity);
+      }
+    }
+    return matches;
+  }
+  findByTargetName(targetname) {
+    const matches = this.targetNameIndex.get(targetname);
+    if (!matches) {
+      return [];
+    }
+    return Array.from(matches).filter((entity) => entity.inUse && !entity.freePending);
   }
-  free(entity) {
-    this.thinkScheduler.cancel(entity);
-    this.pool.deferFree(entity);
+  pickTarget(targetname) {
+    if (!targetname) {
+      return null;
+    }
+    const matches = this.findByTargetName(targetname);
+    if (matches.length === 0) {
+      return null;
+    }
+    const choice = this.random.randomIndex(matches);
+    return matches[choice] ?? null;
   }
-  scheduleThink(entity, nextThinkSeconds) {
-    this.thinkScheduler.schedule(entity, nextThinkSeconds);
+  killBox(entity) {
+    const targetBounds = computeBounds(entity);
+    for (const other of this.pool) {
+      if (other === entity || other === this.pool.world) {
+        continue;
+      }
+      if (!other.inUse || other.freePending || other.solid === 0) {
+        continue;
+      }
+      if (other.svflags & 2) {
+        continue;
+      }
+      if (!boundsIntersect(targetBounds, computeBounds(other))) {
+        continue;
+      }
+      other.health = 0;
+      other.deadflag = 2;
+      this.free(other);
+    }
   }
-  beginFrame(timeSeconds) {
-    this.currentTimeSeconds = timeSeconds;
+  useTargets(entity, activator = null) {
+    if (entity.delay > 0) {
+      const delayed = this.spawn();
+      delayed.classname = "DelayedUse";
+      delayed.target = entity.target;
+      delayed.killtarget = entity.killtarget;
+      delayed.message = entity.message;
+      delayed.think = (self) => {
+        this.useTargetsImmediate(self, activator ?? entity);
+        this.free(self);
+      };
+      this.scheduleThink(delayed, this.currentTimeSeconds + entity.delay);
+      return;
+    }
+    this.useTargetsImmediate(entity, activator ?? entity);
   }
   runFrame() {
     this.thinkScheduler.runDueThinks(this.currentTimeSeconds);
     this.runTouches();
     this.pool.flushFreeList();
   }
+  createSnapshot() {
+    const entities = [];
+    for (const entity of this.pool) {
+      const fields = {};
+      for (const descriptor of SERIALIZABLE_FIELDS) {
+        const value = entity[descriptor.name];
+        switch (descriptor.type) {
+          case "vec3":
+            fields[descriptor.name] = serializeVec3(value);
+            break;
+          case "entity":
+            fields[descriptor.name] = value?.index ?? null;
+            break;
+          case "inventory":
+            fields[descriptor.name] = serializeInventory(value);
+            break;
+          default:
+            fields[descriptor.name] = value ?? null;
+            break;
+        }
+      }
+      entities.push({
+        index: entity.index,
+        fields
+      });
+    }
+    return {
+      timeSeconds: this.currentTimeSeconds,
+      pool: this.pool.createSnapshot(),
+      entities,
+      thinks: this.thinkScheduler.snapshot()
+    };
+  }
+  restore(snapshot) {
+    this.currentTimeSeconds = snapshot.timeSeconds;
+    this.pool.restore(snapshot.pool);
+    const indexToEntity = /* @__PURE__ */ new Map();
+    for (const entity of this.pool) {
+      indexToEntity.set(entity.index, entity);
+    }
+    const pendingEntityRefs = [];
+    for (const serialized of snapshot.entities) {
+      const entity = indexToEntity.get(serialized.index);
+      if (!entity) {
+        continue;
+      }
+      for (const [name, value] of Object.entries(serialized.fields)) {
+        const descriptor = DESCRIPTORS.get(name);
+        if (!descriptor || value === void 0) {
+          continue;
+        }
+        switch (descriptor.type) {
+          case "vec3":
+            assignField(entity, name, deserializeVec3(value));
+            break;
+          case "entity":
+            pendingEntityRefs.push({
+              entity,
+              name: descriptor.name,
+              targetIndex: value
+            });
+            break;
+          case "inventory":
+            assignField(entity, name, deserializeInventory(value));
+            break;
+          case "boolean":
+            assignField(entity, name, Boolean(value));
+            break;
+          default:
+            assignField(entity, name, value);
+            break;
+        }
+      }
+    }
+    for (const ref of pendingEntityRefs) {
+      const target = ref.targetIndex === null ? null : indexToEntity.get(ref.targetIndex) ?? null;
+      assignField(ref.entity, ref.name, target);
+    }
+    this.thinkScheduler.restore(snapshot.thinks, (index) => indexToEntity.get(index));
+  }
   runTouches() {
     const world = this.pool.world;
     const activeEntities = [];
@@ -740,7 +2068,7 @@ var EntitySystem = class {
       if (entity === world) {
         continue;
       }
-      if (!entity.inUse || entity.freePending) {
+      if (!entity.inUse || entity.freePending || entity.solid === 0) {
         continue;
       }
       activeEntities.push(entity);
@@ -769,7 +2097,97 @@ var EntitySystem = class {
       }
     }
   }
+  registerTarget(entity) {
+    if (!entity.targetname) {
+      return;
+    }
+    let bucket = this.targetNameIndex.get(entity.targetname);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this.targetNameIndex.set(entity.targetname, bucket);
+    }
+    bucket.add(entity);
+  }
+  unregisterTarget(entity) {
+    if (!entity.targetname) {
+      return;
+    }
+    const bucket = this.targetNameIndex.get(entity.targetname);
+    if (!bucket) {
+      return;
+    }
+    bucket.delete(entity);
+    if (bucket.size === 0) {
+      this.targetNameIndex.delete(entity.targetname);
+    }
+  }
+  useTargetsImmediate(entity, activator) {
+    if (entity.target) {
+      for (const target of this.findByTargetName(entity.target)) {
+        if (target === entity) {
+          continue;
+        }
+        target.use?.(target, entity, activator);
+      }
+    }
+    if (entity.killtarget) {
+      for (const victim of this.findByTargetName(entity.killtarget)) {
+        if (victim === entity) {
+          continue;
+        }
+        this.free(victim);
+      }
+    }
+  }
+};
+var FRAME_TIME_SECONDS = 1 / 40;
+var TRIGGER_SPAWNFLAGS = {
+  Monster: 1 << 0,
+  NotPlayer: 1 << 1,
+  Triggered: 1 << 2,
+  Toggle: 1 << 3,
+  Latched: 1 << 4,
+  Clip: 1 << 5
 };
+var RELAY_SPAWNFLAGS = {
+  NoSound: 1 << 0
+};
+var COUNTER_SPAWNFLAGS = {
+  NoMessage: 1 << 0
+};
+var PUSH_SPAWNFLAGS = {
+  Once: 1 << 0,
+  Plus: 1 << 1,
+  Silent: 1 << 2,
+  StartOff: 1 << 3,
+  Clip: 1 << 4
+};
+var HURT_SPAWNFLAGS = {
+  StartOff: 1 << 0,
+  Toggle: 1 << 1,
+  Silent: 1 << 2,
+  NoProtection: 1 << 3,
+  Slow: 1 << 4,
+  NoPlayers: 1 << 5,
+  NoMonsters: 1 << 6,
+  Clip: 1 << 7
+};
+var TELEPORT_SPAWNFLAGS = {
+  StartOn: 1 << 3
+};
+var GRAVITY_SPAWNFLAGS = {
+  Toggle: 1 << 0,
+  StartOff: 1 << 1,
+  Clip: 1 << 2
+};
+var MONSTERJUMP_SPAWNFLAGS = {
+  Toggle: 1 << 0,
+  StartOff: 1 << 1,
+  Clip: 1 << 2
+};
+var FIELD_LOOKUP = new Map(
+  ENTITY_FIELD_METADATA.map((field) => [field.name, field])
+);
 var orderedStageNames = [
   "prep",
   "simulate",
@@ -902,8 +2320,391 @@ var LevelClock = class {
   get current() {
     return this.state;
   }
+  restore(state) {
+    this.state = { ...state };
+  }
 };
-var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+var FL_NOVISIBLE = 1 << 24;
+var SPAWNFLAG_MONSTER_AMBUSH = 1 << 0;
+var SAVE_FORMAT_VERSION = 1;
+var MIN_SUPPORTED_VERSION = 1;
+function ensureObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  return value;
+}
+function ensureNumberOrDefault(value, label, defaultValue) {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return ensureNumber(value, label);
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureNumberArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  for (const element of value) {
+    ensureNumber(element, `${label} element`);
+  }
+  return value;
+}
+function parseLevelState(raw) {
+  if (raw === void 0) {
+    return { frameNumber: 0, timeSeconds: 0, previousTimeSeconds: 0, deltaSeconds: 0 };
+  }
+  const level = ensureObject(raw, "level");
+  return {
+    frameNumber: ensureNumberOrDefault(level.frameNumber, "level.frameNumber", 0),
+    timeSeconds: ensureNumberOrDefault(level.timeSeconds, "level.timeSeconds", 0),
+    previousTimeSeconds: ensureNumberOrDefault(level.previousTimeSeconds, "level.previousTimeSeconds", 0),
+    deltaSeconds: ensureNumberOrDefault(level.deltaSeconds, "level.deltaSeconds", 0)
+  };
+}
+function parseRngState(raw) {
+  if (raw === void 0) {
+    return new RandomGenerator().getState();
+  }
+  const rng = ensureObject(raw, "rng");
+  const mt = ensureObject(rng.mt, "rng.mt");
+  const state = ensureNumberArray(mt.state, "rng.mt.state");
+  return {
+    mt: {
+      index: ensureNumber(mt.index, "rng.mt.index"),
+      state
+    }
+  };
+}
+function parseThinkEntries(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("thinks must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const think = ensureObject(entry, `thinks[${idx}]`);
+    return {
+      time: ensureNumber(think.time, `thinks[${idx}].time`),
+      entityIndex: ensureNumber(think.entityIndex, `thinks[${idx}].entityIndex`)
+    };
+  });
+}
+function parseEntityFields(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  const fields = ensureObject(raw, "entity.fields");
+  const parsed = {};
+  for (const [name, value] of Object.entries(fields)) {
+    if (value === null) {
+      parsed[name] = null;
+      continue;
+    }
+    switch (typeof value) {
+      case "number":
+      case "string":
+      case "boolean":
+        parsed[name] = value;
+        break;
+      default: {
+        if (!Array.isArray(value)) {
+          const object = ensureObject(value, name);
+          const inventory = {};
+          for (const [entryName, entryValue] of Object.entries(object)) {
+            inventory[entryName] = ensureNumber(entryValue, `${name}.${entryName}`);
+          }
+          parsed[name] = inventory;
+          break;
+        }
+        if (Array.isArray(value) && value.length === 3) {
+          const [x, y, z] = value;
+          parsed[name] = [
+            ensureNumber(x, `${name}[0]`),
+            ensureNumber(y, `${name}[1]`),
+            ensureNumber(z, `${name}[2]`)
+          ];
+          break;
+        }
+        throw new Error(`Unsupported entity field value for ${name}`);
+      }
+    }
+  }
+  return parsed;
+}
+function parseEntities(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("entities must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const entity = ensureObject(entry, `entities[${idx}]`);
+    return {
+      index: ensureNumber(entity.index, `entities[${idx}].index`),
+      fields: parseEntityFields(entity.fields)
+    };
+  });
+}
+function parsePool(raw) {
+  const pool = ensureObject(raw, "pool");
+  return {
+    capacity: ensureNumber(pool.capacity, "pool.capacity"),
+    activeOrder: ensureNumberArray(pool.activeOrder, "pool.activeOrder"),
+    freeList: ensureNumberArray(pool.freeList, "pool.freeList"),
+    pendingFree: ensureNumberArray(pool.pendingFree, "pool.pendingFree")
+  };
+}
+function parseEntitySnapshot(raw) {
+  const snapshot = ensureObject(raw, "entities");
+  return {
+    timeSeconds: ensureNumber(snapshot.timeSeconds, "entities.timeSeconds"),
+    pool: parsePool(snapshot.pool),
+    entities: parseEntities(snapshot.entities),
+    thinks: parseThinkEntries(snapshot.thinks)
+  };
+}
+function parseCvars(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("cvars must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const cvar = ensureObject(entry, `cvars[${idx}]`);
+    return {
+      name: ensureString(cvar.name, `cvars[${idx}].name`),
+      value: ensureString(cvar.value, `cvars[${idx}].value`),
+      flags: ensureNumber(cvar.flags, `cvars[${idx}].flags`)
+    };
+  });
+}
+function parseConfigstrings(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("configstrings must be an array");
+  }
+  return raw.map((value, idx) => ensureString(value, `configstrings[${idx}]`));
+}
+function parseGameState(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  return ensureObject(raw, "gameState");
+}
+function parseSaveFile(serialized, options = {}) {
+  const { allowNewerVersion = true } = options;
+  const raw = typeof serialized === "string" ? JSON.parse(serialized) : serialized;
+  const save = ensureObject(raw, "save");
+  const versionValue = save.version ?? SAVE_FORMAT_VERSION;
+  const version = ensureNumber(versionValue, "version");
+  if (version < MIN_SUPPORTED_VERSION) {
+    throw new Error(`Unsupported save version ${version}`);
+  }
+  if (version > SAVE_FORMAT_VERSION && !allowNewerVersion) {
+    throw new Error(`Save version ${version} is newer than supported ${SAVE_FORMAT_VERSION}`);
+  }
+  return {
+    version,
+    timestamp: ensureNumber(save.timestamp, "timestamp"),
+    map: ensureString(save.map, "map"),
+    difficulty: ensureNumber(save.difficulty, "difficulty"),
+    playtimeSeconds: ensureNumber(save.playtimeSeconds, "playtimeSeconds"),
+    gameState: parseGameState(save.gameState),
+    level: parseLevelState(save.level),
+    rng: parseRngState(save.rng),
+    entities: parseEntitySnapshot(save.entities),
+    cvars: parseCvars(save.cvars),
+    configstrings: parseConfigstrings(save.configstrings)
+  };
+}
+var TEXT_ENCODER_CTOR = globalThis.TextEncoder;
+function cloneSave(save) {
+  return parseSaveFile({ ...save }, { allowNewerVersion: true });
+}
+function estimateSizeBytes(save) {
+  if (TEXT_ENCODER_CTOR) {
+    const encoder = new TEXT_ENCODER_CTOR();
+    return encoder.encode(JSON.stringify(save)).length;
+  }
+  return JSON.stringify(save).length;
+}
+var MemorySaveAdapter = class {
+  constructor() {
+    this.records = /* @__PURE__ */ new Map();
+  }
+  async init() {
+    return Promise.resolve();
+  }
+  async put(record) {
+    const copy = {
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    };
+    this.records.set(record.id, copy);
+  }
+  async get(id) {
+    const record = this.records.get(id);
+    if (!record) {
+      return null;
+    }
+    return {
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    };
+  }
+  async delete(id) {
+    return this.records.delete(id);
+  }
+  async list() {
+    return Array.from(this.records.values()).map((record) => ({
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    }));
+  }
+};
+var IndexedDbSaveAdapter = class {
+  constructor(indexedDB2, dbName, storeName) {
+    this.indexedDB = indexedDB2;
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.db = null;
+  }
+  async init() {
+    if (this.db) {
+      return;
+    }
+    this.db = await new Promise((resolve, reject) => {
+      const request = this.indexedDB.open(this.dbName, 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore(this.storeName, { keyPath: "id" });
+      };
+      request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  async runTransaction(mode, operation) {
+    await this.init();
+    const database = this.db;
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(this.storeName, mode);
+      const store = transaction.objectStore(this.storeName);
+      const request = operation(store);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+    });
+  }
+  async put(record) {
+    await this.runTransaction("readwrite", (store) => store.put(record));
+  }
+  async get(id) {
+    const record = await this.runTransaction("readonly", (store) => store.get(id));
+    if (!record) {
+      return null;
+    }
+    return {
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    };
+  }
+  async delete(id) {
+    const existing = await this.get(id);
+    if (!existing) {
+      return false;
+    }
+    await this.runTransaction("readwrite", (store) => store.delete(id));
+    return true;
+  }
+  async list() {
+    const all = await this.runTransaction("readonly", (store) => store.getAll());
+    return all.map((record) => ({
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    }));
+  }
+};
+var _SaveStorage = class _SaveStorage2 {
+  constructor(options = {}) {
+    const { dbName = _SaveStorage2.DEFAULT_DB_NAME, storeName = _SaveStorage2.DEFAULT_STORE } = options;
+    const indexedDBFactory = options.indexedDB ?? globalThis.indexedDB;
+    if (indexedDBFactory) {
+      this.adapter = new IndexedDbSaveAdapter(indexedDBFactory, dbName, storeName);
+    } else {
+      this.adapter = new MemorySaveAdapter();
+    }
+  }
+  async save(slotId, save, options = {}) {
+    const normalized = cloneSave(save);
+    const metadata = {
+      id: slotId,
+      name: options.name ?? slotId,
+      map: normalized.map,
+      difficulty: normalized.difficulty,
+      playtimeSeconds: normalized.playtimeSeconds,
+      timestamp: normalized.timestamp,
+      version: normalized.version,
+      bytes: estimateSizeBytes(normalized)
+    };
+    await this.adapter.init();
+    await this.adapter.put({ id: slotId, metadata, save: normalized });
+    return metadata;
+  }
+  async load(slotId, options = {}) {
+    await this.adapter.init();
+    const record = await this.adapter.get(slotId);
+    if (!record) {
+      throw new Error(`Save slot ${slotId} not found`);
+    }
+    return parseSaveFile(record.save, options);
+  }
+  async delete(slotId) {
+    await this.adapter.init();
+    return this.adapter.delete(slotId);
+  }
+  async list() {
+    await this.adapter.init();
+    const records = await this.adapter.list();
+    return records.map((record) => ({ ...record.metadata })).sort((a, b) => b.timestamp - a.timestamp || a.id.localeCompare(b.id));
+  }
+  async quickSave(save) {
+    return this.save(_SaveStorage2.QUICK_SLOT, save, { name: "Quick Save" });
+  }
+  async quickLoad(options = {}) {
+    return this.load(_SaveStorage2.QUICK_SLOT, options);
+  }
+};
+_SaveStorage.DEFAULT_DB_NAME = "quake2ts-saves";
+_SaveStorage.DEFAULT_STORE = "saves";
+_SaveStorage.QUICK_SLOT = "quicksave";
+var AmmoType = /* @__PURE__ */ ((AmmoType2) => {
+  AmmoType2[AmmoType2["Bullets"] = 0] = "Bullets";
+  AmmoType2[AmmoType2["Shells"] = 1] = "Shells";
+  AmmoType2[AmmoType2["Rockets"] = 2] = "Rockets";
+  AmmoType2[AmmoType2["Grenades"] = 3] = "Grenades";
+  AmmoType2[AmmoType2["Cells"] = 4] = "Cells";
+  AmmoType2[AmmoType2["Slugs"] = 5] = "Slugs";
+  return AmmoType2;
+})(AmmoType || {});
+var AMMO_TYPE_COUNT = Object.keys(AmmoType).length / 2;
+var ZERO_VEC322 = { x: 0, y: 0, z: 0 };
 function createGame(engine, options) {
   const gravity = options.gravity;
   const levelClock = new LevelClock();
@@ -926,8 +2727,8 @@ function createGame(engine, options) {
     };
     entities.runFrame();
   });
-  let origin = { ...ZERO_VEC32 };
-  let velocity = { ...ZERO_VEC32 };
+  let origin = { ...ZERO_VEC322 };
+  let velocity = { ...ZERO_VEC322 };
   const snapshot = (frame) => ({
     frame,
     timeMs: frameLoop.time,
@@ -945,8 +2746,8 @@ function createGame(engine, options) {
   const resetState = (startTimeMs) => {
     frameLoop.reset(startTimeMs);
     levelClock.start(startTimeMs);
-    origin = { ...ZERO_VEC32 };
-    velocity = { ...ZERO_VEC32 };
+    origin = { ...ZERO_VEC322 };
+    velocity = { ...ZERO_VEC322 };
     entities.beginFrame(startTimeMs / 1e3);
     entities.runFrame();
   };
@@ -969,72 +2770,73 @@ function createGame(engine, options) {
 }
 
 // ../../packages/shared/dist/esm/index.js
-var ZERO_VEC33 = { x: 0, y: 0, z: 0 };
-var DEG_TO_RAD3 = Math.PI / 180;
-var DEG2RAD_FACTOR3 = Math.PI / 180;
-var RAD2DEG_FACTOR3 = 180 / Math.PI;
-var CONTENTS_SOLID3 = 1 << 0;
-var CONTENTS_WINDOW3 = 1 << 1;
-var CONTENTS_AUX3 = 1 << 2;
-var CONTENTS_LAVA3 = 1 << 3;
-var CONTENTS_SLIME3 = 1 << 4;
-var CONTENTS_WATER3 = 1 << 5;
-var CONTENTS_MIST3 = 1 << 6;
-var CONTENTS_NO_WATERJUMP3 = 1 << 13;
-var CONTENTS_PROJECTILECLIP3 = 1 << 14;
-var CONTENTS_AREAPORTAL3 = 1 << 15;
-var CONTENTS_PLAYERCLIP3 = 1 << 16;
-var CONTENTS_MONSTERCLIP3 = 1 << 17;
-var CONTENTS_CURRENT_03 = 1 << 18;
-var CONTENTS_CURRENT_903 = 1 << 19;
-var CONTENTS_CURRENT_1803 = 1 << 20;
-var CONTENTS_CURRENT_2703 = 1 << 21;
-var CONTENTS_CURRENT_UP3 = 1 << 22;
-var CONTENTS_CURRENT_DOWN3 = 1 << 23;
-var CONTENTS_ORIGIN3 = 1 << 24;
-var CONTENTS_MONSTER3 = 1 << 25;
-var CONTENTS_DEADMONSTER3 = 1 << 26;
-var CONTENTS_DETAIL3 = 1 << 27;
-var CONTENTS_TRANSLUCENT3 = 1 << 28;
-var CONTENTS_LADDER3 = 1 << 29;
-var CONTENTS_PLAYER3 = 1 << 30;
-var CONTENTS_PROJECTILE3 = 1 << 31;
-var SURF_LIGHT3 = 1 << 0;
-var SURF_SLICK3 = 1 << 1;
-var SURF_SKY3 = 1 << 2;
-var SURF_WARP3 = 1 << 3;
-var SURF_TRANS333 = 1 << 4;
-var SURF_TRANS663 = 1 << 5;
-var SURF_FLOWING3 = 1 << 6;
-var SURF_NODRAW3 = 1 << 7;
-var SURF_ALPHATEST3 = 1 << 25;
-var SURF_N64_UV3 = 1 << 28;
-var SURF_N64_SCROLL_X3 = 1 << 29;
-var SURF_N64_SCROLL_Y3 = 1 << 30;
-var SURF_N64_SCROLL_FLIP3 = 1 << 31;
-var MASK_SOLID3 = CONTENTS_SOLID3 | CONTENTS_WINDOW3;
-var MASK_PLAYERSOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
-var MASK_DEADSOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3;
-var MASK_MONSTERSOLID3 = CONTENTS_SOLID3 | CONTENTS_MONSTERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
-var MASK_WATER3 = CONTENTS_WATER3 | CONTENTS_LAVA3 | CONTENTS_SLIME3;
-var MASK_OPAQUE3 = CONTENTS_SOLID3 | CONTENTS_SLIME3 | CONTENTS_LAVA3;
-var MASK_SHOT3 = CONTENTS_SOLID3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3 | CONTENTS_WINDOW3 | CONTENTS_DEADMONSTER3;
-var MASK_CURRENT3 = CONTENTS_CURRENT_03 | CONTENTS_CURRENT_903 | CONTENTS_CURRENT_1803 | CONTENTS_CURRENT_2703 | CONTENTS_CURRENT_UP3 | CONTENTS_CURRENT_DOWN3;
-var MASK_BLOCK_SIGHT3 = CONTENTS_SOLID3 | CONTENTS_LAVA3 | CONTENTS_SLIME3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
-var MASK_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3;
-var MASK_LADDER_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_WINDOW3;
-var MASK_WALK_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTERCLIP3;
-var MASK_PROJECTILE3 = MASK_SHOT3 | CONTENTS_PROJECTILECLIP3;
-var MAX_CLIENTS3 = 256;
-var MAX_LIGHTSTYLES3 = 256;
-var MAX_MODELS3 = 8192;
-var MAX_SOUNDS3 = 2048;
-var MAX_IMAGES3 = 512;
-var MAX_ITEMS3 = 256;
-var MAX_GENERAL3 = MAX_CLIENTS3 * 2;
-var MAX_SHADOW_LIGHTS3 = 256;
-var MAX_WHEEL_ITEMS3 = 32;
-var ConfigStringIndex3 = ((ConfigStringIndex22) => {
+var ZERO_VEC34 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD4 = Math.PI / 180;
+var DEG2RAD_FACTOR4 = Math.PI / 180;
+var RAD2DEG_FACTOR4 = 180 / Math.PI;
+var CONTENTS_SOLID4 = 1 << 0;
+var CONTENTS_WINDOW4 = 1 << 1;
+var CONTENTS_AUX4 = 1 << 2;
+var CONTENTS_LAVA4 = 1 << 3;
+var CONTENTS_SLIME4 = 1 << 4;
+var CONTENTS_WATER4 = 1 << 5;
+var CONTENTS_MIST4 = 1 << 6;
+var CONTENTS_NO_WATERJUMP4 = 1 << 13;
+var CONTENTS_PROJECTILECLIP4 = 1 << 14;
+var CONTENTS_AREAPORTAL4 = 1 << 15;
+var CONTENTS_PLAYERCLIP4 = 1 << 16;
+var CONTENTS_MONSTERCLIP4 = 1 << 17;
+var CONTENTS_CURRENT_04 = 1 << 18;
+var CONTENTS_CURRENT_904 = 1 << 19;
+var CONTENTS_CURRENT_1804 = 1 << 20;
+var CONTENTS_CURRENT_2704 = 1 << 21;
+var CONTENTS_CURRENT_UP4 = 1 << 22;
+var CONTENTS_CURRENT_DOWN4 = 1 << 23;
+var CONTENTS_ORIGIN4 = 1 << 24;
+var CONTENTS_MONSTER4 = 1 << 25;
+var CONTENTS_DEADMONSTER4 = 1 << 26;
+var CONTENTS_DETAIL4 = 1 << 27;
+var CONTENTS_TRANSLUCENT4 = 1 << 28;
+var CONTENTS_LADDER4 = 1 << 29;
+var CONTENTS_PLAYER4 = 1 << 30;
+var CONTENTS_PROJECTILE4 = 1 << 31;
+var SURF_LIGHT4 = 1 << 0;
+var SURF_SLICK4 = 1 << 1;
+var SURF_SKY4 = 1 << 2;
+var SURF_WARP4 = 1 << 3;
+var SURF_TRANS334 = 1 << 4;
+var SURF_TRANS664 = 1 << 5;
+var SURF_FLOWING4 = 1 << 6;
+var SURF_NODRAW4 = 1 << 7;
+var SURF_ALPHATEST4 = 1 << 25;
+var SURF_N64_UV4 = 1 << 28;
+var SURF_N64_SCROLL_X4 = 1 << 29;
+var SURF_N64_SCROLL_Y4 = 1 << 30;
+var SURF_N64_SCROLL_FLIP4 = 1 << 31;
+var MASK_SOLID4 = CONTENTS_SOLID4 | CONTENTS_WINDOW4;
+var MASK_PLAYERSOLID4 = CONTENTS_SOLID4 | CONTENTS_PLAYERCLIP4 | CONTENTS_WINDOW4 | CONTENTS_MONSTER4 | CONTENTS_PLAYER4;
+var MASK_DEADSOLID4 = CONTENTS_SOLID4 | CONTENTS_PLAYERCLIP4 | CONTENTS_WINDOW4;
+var MASK_MONSTERSOLID4 = CONTENTS_SOLID4 | CONTENTS_MONSTERCLIP4 | CONTENTS_WINDOW4 | CONTENTS_MONSTER4 | CONTENTS_PLAYER4;
+var MASK_WATER4 = CONTENTS_WATER4 | CONTENTS_LAVA4 | CONTENTS_SLIME4;
+var MASK_OPAQUE4 = CONTENTS_SOLID4 | CONTENTS_SLIME4 | CONTENTS_LAVA4;
+var MASK_SHOT4 = CONTENTS_SOLID4 | CONTENTS_MONSTER4 | CONTENTS_PLAYER4 | CONTENTS_WINDOW4 | CONTENTS_DEADMONSTER4;
+var MASK_CURRENT4 = CONTENTS_CURRENT_04 | CONTENTS_CURRENT_904 | CONTENTS_CURRENT_1804 | CONTENTS_CURRENT_2704 | CONTENTS_CURRENT_UP4 | CONTENTS_CURRENT_DOWN4;
+var MASK_BLOCK_SIGHT4 = CONTENTS_SOLID4 | CONTENTS_LAVA4 | CONTENTS_SLIME4 | CONTENTS_MONSTER4 | CONTENTS_PLAYER4;
+var MASK_NAV_SOLID4 = CONTENTS_SOLID4 | CONTENTS_PLAYERCLIP4 | CONTENTS_WINDOW4;
+var MASK_LADDER_NAV_SOLID4 = CONTENTS_SOLID4 | CONTENTS_WINDOW4;
+var MASK_WALK_NAV_SOLID4 = CONTENTS_SOLID4 | CONTENTS_PLAYERCLIP4 | CONTENTS_WINDOW4 | CONTENTS_MONSTERCLIP4;
+var MASK_PROJECTILE4 = MASK_SHOT4 | CONTENTS_PROJECTILECLIP4;
+var MAX_CHECKCOUNT4 = Number.MAX_SAFE_INTEGER - 1;
+var MAX_CLIENTS4 = 256;
+var MAX_LIGHTSTYLES4 = 256;
+var MAX_MODELS4 = 8192;
+var MAX_SOUNDS4 = 2048;
+var MAX_IMAGES4 = 512;
+var MAX_ITEMS4 = 256;
+var MAX_GENERAL4 = MAX_CLIENTS4 * 2;
+var MAX_SHADOW_LIGHTS4 = 256;
+var MAX_WHEEL_ITEMS4 = 32;
+var ConfigStringIndex4 = ((ConfigStringIndex22) => {
   ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
   ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
   ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
@@ -1045,23 +2847,23 @@ var ConfigStringIndex3 = ((ConfigStringIndex22) => {
   ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
   ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
   ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
-  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS3] = "Sounds";
-  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS3] = "Images";
-  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES3] = "Lights";
-  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES3] = "ShadowLights";
-  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS3] = "Items";
-  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS3] = "PlayerSkins";
-  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS3] = "General";
-  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL3] = "WheelWeapons";
-  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS3] = "WheelAmmo";
-  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS3] = "WheelPowerups";
-  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS3] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS4] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS4] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES4] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES4] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS4] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS4] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS4] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL4] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS4] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS4] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS4] = "CdLoopCount";
   ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
   ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
   return ConfigStringIndex22;
-})(ConfigStringIndex3 || {});
-var MAX_CONFIGSTRINGS3 = ConfigStringIndex3.MaxConfigStrings;
-var WATERJUMP_CLEAR3 = 8 | 16 | 32 | 1024;
+})(ConfigStringIndex4 || {});
+var MAX_CONFIGSTRINGS4 = ConfigStringIndex4.MaxConfigStrings;
+var WATERJUMP_CLEAR4 = 8 | 16 | 32 | 1024;
 
 // src/index.ts
 function bootstrapViewer() {
@@ -1074,8 +2876,8 @@ function bootstrapViewer() {
     trace(start, end) {
       return { start, end, fraction: 1 };
     }
-  }, { gravity: ZERO_VEC33 });
-  const client = createClient({ engine: { trace: () => ({ start: ZERO_VEC33, end: ZERO_VEC33, fraction: 1 }) } });
+  }, { gravity: ZERO_VEC34 });
+  const client = createClient({ engine: { trace: () => ({ start: ZERO_VEC34, end: ZERO_VEC34, fraction: 1 }) } });
   const runtime = createEngineRuntime(engine, game, client);
   runtime.start();
   return { engine, game, client, runtime };