quake2ts 0.0.561 → 0.0.563

package/packages/test-utils/dist/index.cjs

@@ -32,12 +32,16 @@ var index_exports = {};
 __export(index_exports, {
   InputInjector: () => InputInjector,
   MockPointerLock: () => MockPointerLock,
+  MockTransport: () => MockTransport,
   captureAudioEvents: () => captureAudioEvents,
   captureCanvasDrawCalls: () => captureCanvasDrawCalls,
+  captureGameScreenshot: () => captureGameScreenshot,
   captureGameState: () => captureGameState,
+  compareScreenshots: () => compareScreenshots,
   createBinaryStreamMock: () => createBinaryStreamMock,
   createBinaryWriterMock: () => createBinaryWriterMock,
   createControlledTimer: () => createControlledTimer,
+  createCustomNetworkCondition: () => createCustomNetworkCondition,
   createEntity: () => createEntity,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
@@ -46,13 +50,21 @@ __export(index_exports, {
   createMockCanvasContext2D: () => createMockCanvasContext2D,
   createMockEngine: () => createMockEngine,
   createMockGame: () => createMockGame,
+  createMockGameState: () => createMockGameState,
   createMockImage: () => createMockImage,
   createMockImageData: () => createMockImageData,
   createMockIndexedDB: () => createMockIndexedDB,
   createMockLocalStorage: () => createMockLocalStorage,
+  createMockNetworkAddress: () => createMockNetworkAddress,
   createMockPerformance: () => createMockPerformance,
   createMockRAF: () => createMockRAF,
+  createMockServer: () => createMockServer,
+  createMockServerClient: () => createMockServerClient,
+  createMockServerState: () => createMockServerState,
+  createMockServerStatic: () => createMockServerStatic,
   createMockSessionStorage: () => createMockSessionStorage,
+  createMockTransport: () => createMockTransport,
+  createMockUDPSocket: () => createMockUDPSocket,
   createMockWebGL2Context: () => createMockWebGL2Context,
   createNetChanMock: () => createNetChanMock,
   createPlayerStateFactory: () => createPlayerStateFactory,
@@ -60,6 +72,7 @@ __export(index_exports, {
   createSpawnContext: () => createSpawnContext,
   createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
+  createVisualTestScenario: () => createVisualTestScenario,
   intersects: () => import_shared3.intersects,
   ladderTrace: () => import_shared3.ladderTrace,
   makeAxisBrush: () => makeAxisBrush,
@@ -74,1297 +87,1695 @@ __export(index_exports, {
   setupNodeEnvironment: () => setupNodeEnvironment,
   simulateFrames: () => simulateFrames,
   simulateFramesWithMock: () => simulateFramesWithMock,
+  simulateNetworkCondition: () => simulateNetworkCondition,
   stairTrace: () => import_shared3.stairTrace,
   teardownBrowserEnvironment: () => teardownBrowserEnvironment,
   teardownMockAudioContext: () => teardownMockAudioContext,
+  throttleBandwidth: () => throttleBandwidth,
   waitForGameReady: () => waitForGameReady
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/setup/browser.ts
-var import_jsdom = require("jsdom");
-var import_canvas = require("@napi-rs/canvas");
-var import_auto = require("fake-indexeddb/auto");
-
-// src/e2e/input.ts
-var MockPointerLock = class {
-  static setup(doc) {
-    let _pointerLockElement = null;
-    Object.defineProperty(doc, "pointerLockElement", {
-      get: () => _pointerLockElement,
-      configurable: true
-    });
-    doc.exitPointerLock = () => {
-      if (_pointerLockElement) {
-        _pointerLockElement = null;
-        doc.dispatchEvent(new Event("pointerlockchange"));
-      }
-    };
-    global.HTMLElement.prototype.requestPointerLock = function() {
-      _pointerLockElement = this;
-      doc.dispatchEvent(new Event("pointerlockchange"));
-    };
-  }
-};
-var InputInjector = class {
-  constructor(doc, win) {
-    this.doc = doc;
-    this.win = win;
-  }
-  keyDown(key, code) {
-    const event = new this.win.KeyboardEvent("keydown", {
-      key,
-      code: code || key,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    this.doc.dispatchEvent(event);
-  }
-  keyUp(key, code) {
-    const event = new this.win.KeyboardEvent("keyup", {
-      key,
-      code: code || key,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    this.doc.dispatchEvent(event);
-  }
-  mouseMove(movementX, movementY, clientX = 0, clientY = 0) {
-    const event = new this.win.MouseEvent("mousemove", {
-      bubbles: true,
-      cancelable: true,
-      view: this.win,
-      clientX,
-      clientY,
-      movementX,
-      // Note: JSDOM might not support this standard property fully on event init
-      movementY
-    });
-    Object.defineProperty(event, "movementX", { value: movementX });
-    Object.defineProperty(event, "movementY", { value: movementY });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
-  }
-  mouseDown(button = 0) {
-    const event = new this.win.MouseEvent("mousedown", {
-      button,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
-  }
-  mouseUp(button = 0) {
-    const event = new this.win.MouseEvent("mouseup", {
-      button,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
-  }
-  wheel(deltaY) {
-    const event = new this.win.WheelEvent("wheel", {
-      deltaY,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
-  }
-};
-
-// src/setup/webgl.ts
-function createMockWebGL2Context(canvas) {
-  const gl = {
-    canvas,
-    drawingBufferWidth: canvas.width,
-    drawingBufferHeight: canvas.height,
-    // Constants
-    VERTEX_SHADER: 35633,
-    FRAGMENT_SHADER: 35632,
-    COMPILE_STATUS: 35713,
-    LINK_STATUS: 35714,
-    ARRAY_BUFFER: 34962,
-    ELEMENT_ARRAY_BUFFER: 34963,
-    STATIC_DRAW: 35044,
-    DYNAMIC_DRAW: 35048,
-    FLOAT: 5126,
-    DEPTH_TEST: 2929,
-    BLEND: 3042,
-    SRC_ALPHA: 770,
-    ONE_MINUS_SRC_ALPHA: 771,
-    TEXTURE_2D: 3553,
-    RGBA: 6408,
-    UNSIGNED_BYTE: 5121,
-    COLOR_BUFFER_BIT: 16384,
-    DEPTH_BUFFER_BIT: 256,
-    TRIANGLES: 4,
-    TRIANGLE_STRIP: 5,
-    TRIANGLE_FAN: 6,
-    // Methods
-    createShader: () => ({}),
-    shaderSource: () => {
-    },
-    compileShader: () => {
-    },
-    getShaderParameter: (_, param) => {
-      if (param === 35713) return true;
-      return true;
-    },
-    getShaderInfoLog: () => "",
-    createProgram: () => ({}),
-    attachShader: () => {
-    },
-    linkProgram: () => {
-    },
-    getProgramParameter: (_, param) => {
-      if (param === 35714) return true;
-      return true;
-    },
-    getProgramInfoLog: () => "",
-    useProgram: () => {
-    },
-    createBuffer: () => ({}),
-    bindBuffer: () => {
-    },
-    bufferData: () => {
-    },
-    enableVertexAttribArray: () => {
-    },
-    vertexAttribPointer: () => {
-    },
-    enable: () => {
-    },
-    disable: () => {
-    },
-    depthMask: () => {
-    },
-    blendFunc: () => {
-    },
-    viewport: () => {
-    },
-    clearColor: () => {
-    },
-    clear: () => {
-    },
-    createTexture: () => ({}),
-    bindTexture: () => {
-    },
-    texImage2D: () => {
-    },
-    texParameteri: () => {
-    },
-    activeTexture: () => {
-    },
-    uniform1i: () => {
-    },
-    uniform1f: () => {
-    },
-    uniform2f: () => {
-    },
-    uniform3f: () => {
-    },
-    uniform4f: () => {
-    },
-    uniformMatrix4fv: () => {
-    },
-    getUniformLocation: () => ({}),
-    getAttribLocation: () => 0,
-    drawArrays: () => {
-    },
-    drawElements: () => {
-    },
-    createVertexArray: () => ({}),
-    bindVertexArray: () => {
-    },
-    deleteShader: () => {
-    },
-    deleteProgram: () => {
-    },
-    deleteBuffer: () => {
-    },
-    deleteTexture: () => {
-    },
-    deleteVertexArray: () => {
-    },
-    // WebGL2 specific
-    texImage3D: () => {
-    },
-    uniformBlockBinding: () => {
-    },
-    getExtension: () => null
-  };
-  return gl;
-}
-
-// src/setup/browser.ts
-function setupBrowserEnvironment(options = {}) {
-  const {
-    url = "http://localhost",
-    pretendToBeVisual = true,
-    resources = void 0,
-    enableWebGL2 = false,
-    enablePointerLock = false
-  } = options;
-  const dom = new import_jsdom.JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
-    url,
-    pretendToBeVisual,
-    resources
-  });
-  global.window = dom.window;
-  global.document = dom.window.document;
-  try {
-    global.navigator = dom.window.navigator;
-  } catch (e) {
-    try {
-      Object.defineProperty(global, "navigator", {
-        value: dom.window.navigator,
-        writable: true,
-        configurable: true
-      });
-    } catch (e2) {
-      console.warn("Could not assign global.navigator, skipping.");
-    }
-  }
-  global.location = dom.window.location;
-  global.HTMLElement = dom.window.HTMLElement;
-  global.HTMLCanvasElement = dom.window.HTMLCanvasElement;
-  global.Event = dom.window.Event;
-  global.CustomEvent = dom.window.CustomEvent;
-  global.DragEvent = dom.window.DragEvent;
-  global.MouseEvent = dom.window.MouseEvent;
-  global.KeyboardEvent = dom.window.KeyboardEvent;
-  global.FocusEvent = dom.window.FocusEvent;
-  global.WheelEvent = dom.window.WheelEvent;
-  global.InputEvent = dom.window.InputEvent;
-  global.UIEvent = dom.window.UIEvent;
-  try {
-    global.localStorage = dom.window.localStorage;
-  } catch (e) {
-  }
-  if (!global.localStorage) {
-    const storage = /* @__PURE__ */ new Map();
-    global.localStorage = {
-      getItem: (key) => storage.get(key) || null,
-      setItem: (key, value) => storage.set(key, value),
-      removeItem: (key) => storage.delete(key),
-      clear: () => storage.clear(),
-      key: (index) => Array.from(storage.keys())[index] || null,
-      get length() {
-        return storage.size;
-      }
-    };
-  }
-  const originalCreateElement = document.createElement.bind(document);
-  document.createElement = function(tagName, options2) {
-    if (tagName.toLowerCase() === "canvas") {
-      const napiCanvas = new import_canvas.Canvas(300, 150);
-      const domCanvas = originalCreateElement("canvas", options2);
-      Object.defineProperty(domCanvas, "width", {
-        get: () => napiCanvas.width,
-        set: (value) => {
-          napiCanvas.width = value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      Object.defineProperty(domCanvas, "height", {
-        get: () => napiCanvas.height,
-        set: (value) => {
-          napiCanvas.height = value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      const originalGetContext = domCanvas.getContext.bind(domCanvas);
-      domCanvas.getContext = function(contextId, options3) {
-        if (contextId === "2d") {
-          return napiCanvas.getContext("2d", options3);
-        }
-        if (enableWebGL2 && contextId === "webgl2") {
-          return createMockWebGL2Context(domCanvas);
-        }
-        if (contextId === "webgl" || contextId === "webgl2") {
-          return originalGetContext(contextId, options3);
-        }
-        return napiCanvas.getContext(contextId, options3);
-      };
-      domCanvas.__napiCanvas = napiCanvas;
-      return domCanvas;
-    }
-    return originalCreateElement(tagName, options2);
+// src/shared/mocks.ts
+var import_vitest = require("vitest");
+var createBinaryWriterMock = () => ({
+  writeByte: import_vitest.vi.fn(),
+  writeShort: import_vitest.vi.fn(),
+  writeLong: import_vitest.vi.fn(),
+  writeString: import_vitest.vi.fn(),
+  writeBytes: import_vitest.vi.fn(),
+  getBuffer: import_vitest.vi.fn(() => new Uint8Array(0)),
+  reset: import_vitest.vi.fn(),
+  // Legacy methods (if any)
+  writeInt8: import_vitest.vi.fn(),
+  writeUint8: import_vitest.vi.fn(),
+  writeInt16: import_vitest.vi.fn(),
+  writeUint16: import_vitest.vi.fn(),
+  writeInt32: import_vitest.vi.fn(),
+  writeUint32: import_vitest.vi.fn(),
+  writeFloat: import_vitest.vi.fn(),
+  getData: import_vitest.vi.fn(() => new Uint8Array(0))
+});
+var createNetChanMock = () => ({
+  qport: 1234,
+  // Sequencing
+  incomingSequence: 0,
+  outgoingSequence: 0,
+  incomingAcknowledged: 0,
+  // Reliable messaging
+  incomingReliableAcknowledged: false,
+  incomingReliableSequence: 0,
+  outgoingReliableSequence: 0,
+  reliableMessage: createBinaryWriterMock(),
+  reliableLength: 0,
+  // Fragmentation
+  fragmentSendOffset: 0,
+  fragmentBuffer: null,
+  fragmentLength: 0,
+  fragmentReceived: 0,
+  // Timing
+  lastReceived: 0,
+  lastSent: 0,
+  remoteAddress: { type: "IP", port: 1234 },
+  // Methods
+  setup: import_vitest.vi.fn(),
+  reset: import_vitest.vi.fn(),
+  transmit: import_vitest.vi.fn(),
+  process: import_vitest.vi.fn(),
+  canSendReliable: import_vitest.vi.fn(() => true),
+  writeReliableByte: import_vitest.vi.fn(),
+  writeReliableShort: import_vitest.vi.fn(),
+  writeReliableLong: import_vitest.vi.fn(),
+  writeReliableString: import_vitest.vi.fn(),
+  getReliableData: import_vitest.vi.fn(() => new Uint8Array(0)),
+  needsKeepalive: import_vitest.vi.fn(() => false),
+  isTimedOut: import_vitest.vi.fn(() => false)
+});
+var createBinaryStreamMock = () => ({
+  getPosition: import_vitest.vi.fn(() => 0),
+  getReadPosition: import_vitest.vi.fn(() => 0),
+  getLength: import_vitest.vi.fn(() => 0),
+  getRemaining: import_vitest.vi.fn(() => 0),
+  seek: import_vitest.vi.fn(),
+  setReadPosition: import_vitest.vi.fn(),
+  hasMore: import_vitest.vi.fn(() => true),
+  hasBytes: import_vitest.vi.fn((amount) => true),
+  readChar: import_vitest.vi.fn(() => 0),
+  readByte: import_vitest.vi.fn(() => 0),
+  readShort: import_vitest.vi.fn(() => 0),
+  readUShort: import_vitest.vi.fn(() => 0),
+  readLong: import_vitest.vi.fn(() => 0),
+  readULong: import_vitest.vi.fn(() => 0),
+  readFloat: import_vitest.vi.fn(() => 0),
+  readString: import_vitest.vi.fn(() => ""),
+  readStringLine: import_vitest.vi.fn(() => ""),
+  readCoord: import_vitest.vi.fn(() => 0),
+  readAngle: import_vitest.vi.fn(() => 0),
+  readAngle16: import_vitest.vi.fn(() => 0),
+  readData: import_vitest.vi.fn((length) => new Uint8Array(length)),
+  readPos: import_vitest.vi.fn(),
+  readDir: import_vitest.vi.fn()
+});
+
+// src/shared/bsp.ts
+var import_shared = require("@quake2ts/shared");
+function makePlane(normal, dist) {
+  return {
+    normal,
+    dist,
+    type: Math.abs(normal.x) === 1 ? 0 : Math.abs(normal.y) === 1 ? 1 : Math.abs(normal.z) === 1 ? 2 : 3,
+    signbits: (0, import_shared.computePlaneSignBits)(normal)
   };
-  if (enableWebGL2) {
-    const originalProtoGetContext = global.HTMLCanvasElement.prototype.getContext;
-    global.HTMLCanvasElement.prototype.getContext = function(contextId, options2) {
-      if (contextId === "webgl2") {
-        return createMockWebGL2Context(this);
-      }
-      return originalProtoGetContext.call(this, contextId, options2);
-    };
-  }
-  global.Image = import_canvas.Image;
-  global.ImageData = import_canvas.ImageData;
-  if (typeof global.createImageBitmap === "undefined") {
-    global.createImageBitmap = async function(image, _options) {
-      if (image && typeof image.width === "number" && typeof image.height === "number") {
-        const canvas2 = new import_canvas.Canvas(image.width, image.height);
-        const ctx = canvas2.getContext("2d");
-        if (image.data) {
-          ctx.putImageData(image, 0, 0);
-        }
-        return canvas2;
-      }
-      const canvas = new import_canvas.Canvas(100, 100);
-      return canvas;
-    };
-  }
-  if (typeof global.btoa === "undefined") {
-    global.btoa = function(str) {
-      return Buffer.from(str, "binary").toString("base64");
-    };
-  }
-  if (typeof global.atob === "undefined") {
-    global.atob = function(str) {
-      return Buffer.from(str, "base64").toString("binary");
-    };
-  }
-  if (enablePointerLock) {
-    MockPointerLock.setup(global.document);
-  }
-  if (typeof global.requestAnimationFrame === "undefined") {
-    let lastTime = 0;
-    global.requestAnimationFrame = (callback) => {
-      const currTime = Date.now();
-      const timeToCall = Math.max(0, 16 - (currTime - lastTime));
-      const id = setTimeout(() => {
-        callback(currTime + timeToCall);
-      }, timeToCall);
-      lastTime = currTime + timeToCall;
-      return id;
-    };
-    global.cancelAnimationFrame = (id) => {
-      clearTimeout(id);
-    };
-  }
-}
-function teardownBrowserEnvironment() {
-  delete global.window;
-  delete global.document;
-  delete global.navigator;
-  delete global.localStorage;
-  delete global.location;
-  delete global.HTMLElement;
-  delete global.HTMLCanvasElement;
-  delete global.Image;
-  delete global.ImageData;
-  delete global.createImageBitmap;
-  delete global.Event;
-  delete global.CustomEvent;
-  delete global.DragEvent;
-  delete global.MouseEvent;
-  delete global.KeyboardEvent;
-  delete global.FocusEvent;
-  delete global.WheelEvent;
-  delete global.InputEvent;
-  delete global.UIEvent;
 }
-
-// src/setup/canvas.ts
-var import_canvas2 = require("@napi-rs/canvas");
-function createMockCanvas(width = 300, height = 150) {
-  if (typeof document !== "undefined" && document.createElement) {
-    const canvas2 = document.createElement("canvas");
-    canvas2.width = width;
-    canvas2.height = height;
-    return canvas2;
-  }
-  const canvas = new import_canvas2.Canvas(width, height);
-  const originalGetContext = canvas.getContext.bind(canvas);
-  canvas.getContext = function(contextId, options) {
-    if (contextId === "webgl2") {
-      return createMockWebGL2Context(canvas);
-    }
-    if (contextId === "2d") {
-      return originalGetContext("2d", options);
-    }
-    return originalGetContext(contextId, options);
+function makeAxisBrush(size, contents = import_shared.CONTENTS_SOLID) {
+  const half = size / 2;
+  const planes = [
+    makePlane({ x: 1, y: 0, z: 0 }, half),
+    makePlane({ x: -1, y: 0, z: 0 }, half),
+    makePlane({ x: 0, y: 1, z: 0 }, half),
+    makePlane({ x: 0, y: -1, z: 0 }, half),
+    makePlane({ x: 0, y: 0, z: 1 }, half),
+    makePlane({ x: 0, y: 0, z: -1 }, half)
+  ];
+  return {
+    contents,
+    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
   };
-  return canvas;
 }
-function createMockCanvasContext2D(canvas) {
-  if (!canvas) {
-    canvas = createMockCanvas();
-  }
-  return canvas.getContext("2d");
+function makeNode(plane, children) {
+  return { plane, children };
 }
-function captureCanvasDrawCalls(context) {
-  const drawCalls = [];
-  const methodsToSpy = [
-    "fillRect",
-    "strokeRect",
-    "clearRect",
-    "fillText",
-    "strokeText",
-    "drawImage",
-    "beginPath",
-    "closePath",
-    "moveTo",
-    "lineTo",
-    "arc",
-    "arcTo",
-    "bezierCurveTo",
-    "quadraticCurveTo",
-    "stroke",
-    "fill",
-    "putImageData"
-  ];
-  methodsToSpy.forEach((method) => {
-    const original = context[method];
-    if (typeof original === "function") {
-      context[method] = function(...args) {
-        drawCalls.push({ method, args });
-        return original.apply(this, args);
-      };
-    }
-  });
-  return drawCalls;
+function makeBspModel(planes, nodes, leaves, brushes, leafBrushes) {
+  return {
+    planes,
+    nodes,
+    leaves,
+    brushes,
+    leafBrushes,
+    bmodels: []
+  };
 }
-function createMockImageData(width, height, fillColor) {
-  const imageData = new import_canvas2.ImageData(width, height);
-  if (fillColor) {
-    const [r, g, b, a] = fillColor;
-    for (let i = 0; i < imageData.data.length; i += 4) {
-      imageData.data[i] = r;
-      imageData.data[i + 1] = g;
-      imageData.data[i + 2] = b;
-      imageData.data[i + 3] = a;
-    }
-  }
-  return imageData;
+function makeLeaf(contents, firstLeafBrush, numLeafBrushes) {
+  return { contents, cluster: 0, area: 0, firstLeafBrush, numLeafBrushes };
 }
-function createMockImage(width, height, src) {
-  const img = new import_canvas2.Image();
-  if (width) img.width = width;
-  if (height) img.height = height;
-  if (src) img.src = src;
-  return img;
+function makeLeafModel(brushes) {
+  const planes = brushes.flatMap((brush) => brush.sides.map((side) => side.plane));
+  return {
+    planes,
+    nodes: [],
+    leaves: [makeLeaf(0, 0, brushes.length)],
+    brushes,
+    leafBrushes: brushes.map((_, i) => i),
+    bmodels: []
+  };
 }
-
-// src/setup/node.ts
-function setupNodeEnvironment() {
-  if (typeof global.fetch === "undefined") {
-  }
+function makeBrushFromMinsMaxs(mins, maxs, contents = import_shared.CONTENTS_SOLID) {
+  const planes = [
+    makePlane({ x: 1, y: 0, z: 0 }, maxs.x),
+    makePlane({ x: -1, y: 0, z: 0 }, -mins.x),
+    makePlane({ x: 0, y: 1, z: 0 }, maxs.y),
+    makePlane({ x: 0, y: -1, z: 0 }, -mins.y),
+    makePlane({ x: 0, y: 0, z: 1 }, maxs.z),
+    makePlane({ x: 0, y: 0, z: -1 }, -mins.z)
+  ];
+  return {
+    contents,
+    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
+  };
 }
 
-// src/setup/storage.ts
-var import_auto2 = require("fake-indexeddb/auto");
-function createMockLocalStorage(initialData = {}) {
-  const storage = new Map(Object.entries(initialData));
-  return {
-    getItem: (key) => storage.get(key) || null,
-    setItem: (key, value) => storage.set(key, value),
-    removeItem: (key) => storage.delete(key),
-    clear: () => storage.clear(),
-    key: (index) => Array.from(storage.keys())[index] || null,
-    get length() {
-      return storage.size;
-    }
-  };
-}
-function createMockSessionStorage(initialData = {}) {
-  return createMockLocalStorage(initialData);
-}
-function createMockIndexedDB() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
-  }
-  return indexedDB;
-}
-function createStorageTestScenario(storageType = "local") {
-  const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
-  return {
-    storage,
-    populate(data) {
-      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
-    },
-    verify(key, value) {
-      return storage.getItem(key) === value;
-    }
+// src/game/factories.ts
+var createPlayerStateFactory = (overrides) => ({
+  pm_type: 0,
+  pm_time: 0,
+  pm_flags: 0,
+  origin: { x: 0, y: 0, z: 0 },
+  velocity: { x: 0, y: 0, z: 0 },
+  viewAngles: { x: 0, y: 0, z: 0 },
+  onGround: false,
+  waterLevel: 0,
+  watertype: 0,
+  mins: { x: 0, y: 0, z: 0 },
+  maxs: { x: 0, y: 0, z: 0 },
+  damageAlpha: 0,
+  damageIndicators: [],
+  blend: [0, 0, 0, 0],
+  stats: [],
+  kick_angles: { x: 0, y: 0, z: 0 },
+  kick_origin: { x: 0, y: 0, z: 0 },
+  gunoffset: { x: 0, y: 0, z: 0 },
+  gunangles: { x: 0, y: 0, z: 0 },
+  gunindex: 0,
+  gun_frame: 0,
+  rdflags: 0,
+  fov: 90,
+  renderfx: 0,
+  ...overrides
+});
+var createEntityStateFactory = (overrides) => ({
+  number: 0,
+  origin: { x: 0, y: 0, z: 0 },
+  angles: { x: 0, y: 0, z: 0 },
+  oldOrigin: { x: 0, y: 0, z: 0 },
+  modelIndex: 0,
+  modelIndex2: 0,
+  modelIndex3: 0,
+  modelIndex4: 0,
+  frame: 0,
+  skinNum: 0,
+  effects: 0,
+  renderfx: 0,
+  solid: 0,
+  sound: 0,
+  event: 0,
+  ...overrides
+});
+var createGameStateSnapshotFactory = (overrides) => ({
+  gravity: { x: 0, y: 0, z: -800 },
+  origin: { x: 0, y: 0, z: 0 },
+  velocity: { x: 0, y: 0, z: 0 },
+  viewangles: { x: 0, y: 0, z: 0 },
+  level: { timeSeconds: 0, frameNumber: 0, previousTimeSeconds: 0, deltaSeconds: 0.1 },
+  entities: {
+    activeCount: 0,
+    worldClassname: "worldspawn"
+  },
+  packetEntities: [],
+  pmFlags: 0,
+  pmType: 0,
+  waterlevel: 0,
+  watertype: 0,
+  deltaAngles: { x: 0, y: 0, z: 0 },
+  health: 100,
+  armor: 0,
+  ammo: 0,
+  blend: [0, 0, 0, 0],
+  damageAlpha: 0,
+  damageIndicators: [],
+  stats: [],
+  kick_angles: { x: 0, y: 0, z: 0 },
+  kick_origin: { x: 0, y: 0, z: 0 },
+  gunoffset: { x: 0, y: 0, z: 0 },
+  gunangles: { x: 0, y: 0, z: 0 },
+  gunindex: 0,
+  pm_time: 0,
+  gun_frame: 0,
+  rdflags: 0,
+  fov: 90,
+  renderfx: 0,
+  pm_flags: 0,
+  pm_type: 0,
+  ...overrides
+});
+
+// src/game/helpers.ts
+var import_vitest2 = require("vitest");
+var import_game = require("@quake2ts/game");
+var import_shared2 = require("@quake2ts/shared");
+var import_shared3 = require("@quake2ts/shared");
+var createMockEngine = () => ({
+  sound: import_vitest2.vi.fn(),
+  soundIndex: import_vitest2.vi.fn((sound) => 0),
+  modelIndex: import_vitest2.vi.fn((model) => 0),
+  centerprintf: import_vitest2.vi.fn()
+});
+var createMockGame = (seed = 12345) => {
+  const spawnRegistry = new import_game.SpawnRegistry();
+  const hooks = new import_game.ScriptHookRegistry();
+  const game = {
+    random: (0, import_shared2.createRandomGenerator)({ seed }),
+    registerEntitySpawn: import_vitest2.vi.fn((classname, spawnFunc) => {
+      spawnRegistry.register(classname, (entity) => spawnFunc(entity));
+    }),
+    unregisterEntitySpawn: import_vitest2.vi.fn((classname) => {
+      spawnRegistry.unregister(classname);
+    }),
+    getCustomEntities: import_vitest2.vi.fn(() => Array.from(spawnRegistry.keys())),
+    hooks,
+    registerHooks: import_vitest2.vi.fn((newHooks) => hooks.register(newHooks)),
+    spawnWorld: import_vitest2.vi.fn(() => {
+      hooks.onMapLoad("q2dm1");
+    }),
+    clientBegin: import_vitest2.vi.fn((client) => {
+      hooks.onPlayerSpawn({});
+    }),
+    damage: import_vitest2.vi.fn((amount) => {
+      hooks.onDamage({}, null, null, amount, 0, 0);
+    })
   };
-}
-
-// src/setup/audio.ts
-function createMockAudioContext() {
-  return {
-    createGain: () => ({
-      connect: () => {
-      },
-      gain: { value: 1, setValueAtTime: () => {
-      } }
+  return { game, spawnRegistry };
+};
+function createTestContext(options) {
+  const engine = createMockEngine();
+  const seed = options?.seed ?? 12345;
+  const { game, spawnRegistry } = createMockGame(seed);
+  const traceFn = import_vitest2.vi.fn((start, end, mins, maxs) => ({
+    fraction: 1,
+    ent: null,
+    allsolid: false,
+    startsolid: false,
+    endpos: end,
+    plane: { normal: { x: 0, y: 0, z: 1 }, dist: 0 },
+    surfaceFlags: 0,
+    contents: 0
+  }));
+  const entityList = options?.initialEntities ? [...options.initialEntities] : [];
+  const hooks = game.hooks;
+  const entities = {
+    spawn: import_vitest2.vi.fn(() => {
+      const ent = new import_game.Entity(entityList.length + 1);
+      entityList.push(ent);
+      hooks.onEntitySpawn(ent);
+      return ent;
     }),
-    createOscillator: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      frequency: { value: 440 }
+    free: import_vitest2.vi.fn((ent) => {
+      const idx = entityList.indexOf(ent);
+      if (idx !== -1) {
+        entityList.splice(idx, 1);
+      }
+      hooks.onEntityRemove(ent);
     }),
-    createBufferSource: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      buffer: null,
-      playbackRate: { value: 1 },
-      loop: false
+    finalizeSpawn: import_vitest2.vi.fn(),
+    freeImmediate: import_vitest2.vi.fn((ent) => {
+      const idx = entityList.indexOf(ent);
+      if (idx !== -1) {
+        entityList.splice(idx, 1);
+      }
     }),
-    destination: {},
-    currentTime: 0,
-    state: "running",
-    resume: async () => {
-    },
-    suspend: async () => {
+    setSpawnRegistry: import_vitest2.vi.fn(),
+    timeSeconds: 10,
+    deltaSeconds: 0.1,
+    modelIndex: import_vitest2.vi.fn(() => 0),
+    scheduleThink: import_vitest2.vi.fn((entity, time) => {
+      entity.nextthink = time;
+    }),
+    linkentity: import_vitest2.vi.fn(),
+    trace: traceFn,
+    pointcontents: import_vitest2.vi.fn(() => 0),
+    multicast: import_vitest2.vi.fn(),
+    unicast: import_vitest2.vi.fn(),
+    engine,
+    game,
+    sound: import_vitest2.vi.fn((ent, chan, sound, vol, attn, timeofs) => {
+      engine.sound(ent, chan, sound, vol, attn, timeofs);
+    }),
+    soundIndex: import_vitest2.vi.fn((sound) => engine.soundIndex(sound)),
+    useTargets: import_vitest2.vi.fn((entity, activator) => {
+    }),
+    findByTargetName: import_vitest2.vi.fn(() => []),
+    pickTarget: import_vitest2.vi.fn(() => null),
+    killBox: import_vitest2.vi.fn(),
+    rng: (0, import_shared2.createRandomGenerator)({ seed }),
+    imports: {
+      configstring: import_vitest2.vi.fn(),
+      trace: traceFn,
+      pointcontents: import_vitest2.vi.fn(() => 0)
     },
-    close: async () => {
+    level: {
+      intermission_angle: { x: 0, y: 0, z: 0 },
+      intermission_origin: { x: 0, y: 0, z: 0 },
+      next_auto_save: 0,
+      health_bar_entities: null
     },
-    decodeAudioData: async (buffer) => ({
-      duration: 1,
-      length: 44100,
-      sampleRate: 44100,
-      numberOfChannels: 2,
-      getChannelData: () => new Float32Array(44100)
+    targetNameIndex: /* @__PURE__ */ new Map(),
+    forEachEntity: import_vitest2.vi.fn((callback) => {
+      entityList.forEach(callback);
     }),
-    createBuffer: (channels, length, sampleRate) => ({
-      duration: length / sampleRate,
-      length,
-      sampleRate,
-      numberOfChannels: channels,
-      getChannelData: () => new Float32Array(length)
-    })
+    find: import_vitest2.vi.fn((predicate) => {
+      return entityList.find(predicate);
+    }),
+    findByClassname: import_vitest2.vi.fn((classname) => {
+      return entityList.find((e) => e.classname === classname);
+    }),
+    beginFrame: import_vitest2.vi.fn((timeSeconds) => {
+      entities.timeSeconds = timeSeconds;
+    }),
+    targetAwareness: {
+      timeSeconds: 10,
+      frameNumber: 1,
+      sightEntity: null,
+      soundEntity: null
+    },
+    // Adding missing properties to satisfy EntitySystem interface partially or fully
+    // We cast to unknown first anyway, but filling these in makes it safer for consumers
+    skill: 1,
+    deathmatch: false,
+    coop: false,
+    activeCount: entityList.length,
+    world: entityList.find((e) => e.classname === "worldspawn") || new import_game.Entity(0)
+    // ... other EntitySystem properties would go here
+  };
+  return {
+    keyValues: {},
+    entities,
+    game,
+    engine,
+    health_multiplier: 1,
+    warn: import_vitest2.vi.fn(),
+    free: import_vitest2.vi.fn(),
+    // Mock precache functions if they are part of SpawnContext in future or TestContext extensions
+    precacheModel: import_vitest2.vi.fn(),
+    precacheSound: import_vitest2.vi.fn(),
+    precacheImage: import_vitest2.vi.fn()
   };
 }
-function setupMockAudioContext() {
-  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
-    global.AudioContext = class {
-      constructor() {
-        return createMockAudioContext();
-      }
-    };
-    global.window.AudioContext = global.AudioContext;
-    global.window.webkitAudioContext = global.AudioContext;
-  }
+function createSpawnContext() {
+  return createTestContext();
 }
-function teardownMockAudioContext() {
-  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
-    delete global.AudioContext;
-    delete global.window.AudioContext;
-    delete global.window.webkitAudioContext;
+function createEntity() {
+  return new import_game.Entity(1);
+}
+
+// src/game/mocks.ts
+function createMockGameState(overrides) {
+  return {
+    levelName: "test_level",
+    time: 0,
+    entities: [],
+    clients: [],
+    ...overrides
+  };
+}
+
+// src/server/mocks/transport.ts
+var import_vitest3 = require("vitest");
+var MockTransport = class {
+  constructor() {
+    this.address = "127.0.0.1";
+    this.port = 27910;
+    this.sentMessages = [];
+    this.receivedMessages = [];
+    this.listening = false;
+    this.listenSpy = import_vitest3.vi.fn().mockImplementation(async (port) => {
+      this.port = port;
+      this.listening = true;
+    });
+    this.closeSpy = import_vitest3.vi.fn().mockImplementation(() => {
+      this.listening = false;
+    });
+  }
+  /**
+   * Start listening on the specified port.
+   */
+  async listen(port) {
+    return this.listenSpy(port);
+  }
+  /**
+   * Close the transport.
+   */
+  close() {
+    this.closeSpy();
+  }
+  /**
+   * Register a callback for new connections.
+   */
+  onConnection(callback) {
+    this.onConnectionCallback = callback;
+  }
+  /**
+   * Register a callback for errors.
+   */
+  onError(callback) {
+    this.onErrorCallback = callback;
   }
+  /**
+   * Check if the transport is currently listening.
+   */
+  isListening() {
+    return this.listening;
+  }
+  /**
+   * Helper to simulate a new connection.
+   * @param driver The network driver for the connection.
+   * @param info Optional connection info.
+   */
+  simulateConnection(driver, info) {
+    if (this.onConnectionCallback) {
+      this.onConnectionCallback(driver, info);
+    }
+  }
+  /**
+   * Helper to simulate an error.
+   * @param error The error to simulate.
+   */
+  simulateError(error) {
+    if (this.onErrorCallback) {
+      this.onErrorCallback(error);
+    }
+  }
+};
+function createMockUDPSocket(overrides) {
+  const socket = {
+    send: import_vitest3.vi.fn(),
+    on: import_vitest3.vi.fn(),
+    close: import_vitest3.vi.fn(),
+    bind: import_vitest3.vi.fn(),
+    address: import_vitest3.vi.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
+    ...overrides
+  };
+  return socket;
 }
-function captureAudioEvents(context) {
-  return [];
+function createMockNetworkAddress(ip = "127.0.0.1", port = 27910) {
+  return { ip, port };
+}
+function createMockTransport(address = "127.0.0.1", port = 27910, overrides) {
+  const transport = new MockTransport();
+  transport.address = address;
+  transport.port = port;
+  Object.assign(transport, overrides);
+  return transport;
 }
 
-// src/setup/timing.ts
-var activeMockRAF;
-function createMockRAF() {
-  let callbacks = [];
-  let nextId = 1;
-  let currentTime = 0;
-  const originalRAF = global.requestAnimationFrame;
-  const originalCancelRAF = global.cancelAnimationFrame;
-  const raf = (callback) => {
-    const id = nextId++;
-    callbacks.push({ id, callback });
-    return id;
+// src/server/mocks/state.ts
+var import_server = require("@quake2ts/server");
+var import_shared4 = require("@quake2ts/shared");
+var import_vitest4 = require("vitest");
+function createMockServerState(overrides) {
+  return {
+    state: import_server.ServerState.Game,
+    attractLoop: false,
+    loadGame: false,
+    startTime: Date.now(),
+    time: 0,
+    frame: 0,
+    name: "test_map",
+    collisionModel: null,
+    configStrings: new Array(import_shared4.MAX_CONFIGSTRINGS).fill(""),
+    baselines: new Array(import_shared4.MAX_EDICTS).fill(null),
+    multicastBuf: new Uint8Array(0),
+    ...overrides
   };
-  const cancel = (id) => {
-    callbacks = callbacks.filter((cb) => cb.id !== id);
+}
+function createMockServerStatic(maxClients = 16, overrides) {
+  return {
+    initialized: true,
+    realTime: Date.now(),
+    mapCmd: "",
+    spawnCount: 1,
+    clients: new Array(maxClients).fill(null),
+    lastHeartbeat: 0,
+    challenges: [],
+    ...overrides
   };
-  const mock = {
-    tick(timestamp) {
-      if (typeof timestamp !== "number") {
-        currentTime += 16.6;
-      } else {
-        currentTime = timestamp;
+}
+function createMockServerClient(clientNum, overrides) {
+  const mockNet = {
+    connect: import_vitest4.vi.fn(),
+    disconnect: import_vitest4.vi.fn(),
+    send: import_vitest4.vi.fn(),
+    onMessage: import_vitest4.vi.fn(),
+    onClose: import_vitest4.vi.fn(),
+    onError: import_vitest4.vi.fn(),
+    isConnected: import_vitest4.vi.fn().mockReturnValue(true)
+  };
+  return {
+    index: clientNum,
+    state: import_server.ClientState.Connected,
+    edict: { index: clientNum + 1 },
+    net: mockNet,
+    netchan: {
+      qport: 0,
+      remoteAddress: "127.0.0.1",
+      incomingSequence: 0,
+      outgoingSequence: 0,
+      lastReceived: 0,
+      process: import_vitest4.vi.fn(),
+      transmit: import_vitest4.vi.fn(),
+      writeReliableByte: import_vitest4.vi.fn(),
+      writeReliableShort: import_vitest4.vi.fn(),
+      writeReliableLong: import_vitest4.vi.fn(),
+      writeReliableString: import_vitest4.vi.fn(),
+      writeReliableData: import_vitest4.vi.fn()
+    },
+    // Cast as any because NetChan might be complex to fully mock here
+    userInfo: "",
+    lastMessage: 0,
+    lastCommandTime: 0,
+    commandCount: 0,
+    messageQueue: [],
+    frames: [],
+    lastFrame: 0,
+    lastPacketEntities: [],
+    challenge: 0,
+    lastConnect: 0,
+    ping: 0,
+    rate: 0,
+    name: `Client${clientNum}`,
+    messageLevel: 0,
+    datagram: new Uint8Array(0),
+    downloadSize: 0,
+    downloadCount: 0,
+    commandMsec: 0,
+    frameLatency: [],
+    messageSize: [],
+    suppressCount: 0,
+    commandQueue: [],
+    lastCmd: {
+      msec: 0,
+      buttons: 0,
+      angles: { x: 0, y: 0, z: 0 },
+      forwardmove: 0,
+      sidemove: 0,
+      upmove: 0,
+      sequence: 0,
+      lightlevel: 0,
+      impulse: 0,
+      serverFrame: 0
+    },
+    ...overrides
+  };
+}
+function createMockServer(overrides) {
+  return {
+    start: import_vitest4.vi.fn().mockResolvedValue(void 0),
+    stop: import_vitest4.vi.fn(),
+    multicast: import_vitest4.vi.fn(),
+    unicast: import_vitest4.vi.fn(),
+    configstring: import_vitest4.vi.fn(),
+    kickPlayer: import_vitest4.vi.fn(),
+    changeMap: import_vitest4.vi.fn().mockResolvedValue(void 0),
+    ...overrides
+  };
+}
+
+// src/setup/browser.ts
+var import_jsdom = require("jsdom");
+var import_canvas = require("@napi-rs/canvas");
+var import_auto = require("fake-indexeddb/auto");
+
+// src/e2e/input.ts
+var MockPointerLock = class {
+  static setup(doc) {
+    let _pointerLockElement = null;
+    Object.defineProperty(doc, "pointerLockElement", {
+      get: () => _pointerLockElement,
+      configurable: true
+    });
+    doc.exitPointerLock = () => {
+      if (_pointerLockElement) {
+        _pointerLockElement = null;
+        doc.dispatchEvent(new Event("pointerlockchange"));
       }
-      const currentCallbacks = [...callbacks];
-      callbacks = [];
-      currentCallbacks.forEach(({ callback }) => {
-        callback(currentTime);
-      });
+    };
+    global.HTMLElement.prototype.requestPointerLock = function() {
+      _pointerLockElement = this;
+      doc.dispatchEvent(new Event("pointerlockchange"));
+    };
+  }
+};
+var InputInjector = class {
+  constructor(doc, win) {
+    this.doc = doc;
+    this.win = win;
+  }
+  keyDown(key, code) {
+    const event = new this.win.KeyboardEvent("keydown", {
+      key,
+      code: code || key,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    this.doc.dispatchEvent(event);
+  }
+  keyUp(key, code) {
+    const event = new this.win.KeyboardEvent("keyup", {
+      key,
+      code: code || key,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    this.doc.dispatchEvent(event);
+  }
+  mouseMove(movementX, movementY, clientX = 0, clientY = 0) {
+    const event = new this.win.MouseEvent("mousemove", {
+      bubbles: true,
+      cancelable: true,
+      view: this.win,
+      clientX,
+      clientY,
+      movementX,
+      // Note: JSDOM might not support this standard property fully on event init
+      movementY
+    });
+    Object.defineProperty(event, "movementX", { value: movementX });
+    Object.defineProperty(event, "movementY", { value: movementY });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+  mouseDown(button = 0) {
+    const event = new this.win.MouseEvent("mousedown", {
+      button,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+  mouseUp(button = 0) {
+    const event = new this.win.MouseEvent("mouseup", {
+      button,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+  wheel(deltaY) {
+    const event = new this.win.WheelEvent("wheel", {
+      deltaY,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+};
+
+// src/setup/webgl.ts
+function createMockWebGL2Context(canvas) {
+  const gl = {
+    canvas,
+    drawingBufferWidth: canvas.width,
+    drawingBufferHeight: canvas.height,
+    // Constants
+    VERTEX_SHADER: 35633,
+    FRAGMENT_SHADER: 35632,
+    COMPILE_STATUS: 35713,
+    LINK_STATUS: 35714,
+    ARRAY_BUFFER: 34962,
+    ELEMENT_ARRAY_BUFFER: 34963,
+    STATIC_DRAW: 35044,
+    DYNAMIC_DRAW: 35048,
+    FLOAT: 5126,
+    DEPTH_TEST: 2929,
+    BLEND: 3042,
+    SRC_ALPHA: 770,
+    ONE_MINUS_SRC_ALPHA: 771,
+    TEXTURE_2D: 3553,
+    RGBA: 6408,
+    UNSIGNED_BYTE: 5121,
+    COLOR_BUFFER_BIT: 16384,
+    DEPTH_BUFFER_BIT: 256,
+    TRIANGLES: 4,
+    TRIANGLE_STRIP: 5,
+    TRIANGLE_FAN: 6,
+    // Methods
+    createShader: () => ({}),
+    shaderSource: () => {
+    },
+    compileShader: () => {
+    },
+    getShaderParameter: (_, param) => {
+      if (param === 35713) return true;
+      return true;
+    },
+    getShaderInfoLog: () => "",
+    createProgram: () => ({}),
+    attachShader: () => {
+    },
+    linkProgram: () => {
+    },
+    getProgramParameter: (_, param) => {
+      if (param === 35714) return true;
+      return true;
+    },
+    getProgramInfoLog: () => "",
+    useProgram: () => {
+    },
+    createBuffer: () => ({}),
+    bindBuffer: () => {
+    },
+    bufferData: () => {
+    },
+    enableVertexAttribArray: () => {
+    },
+    vertexAttribPointer: () => {
+    },
+    enable: () => {
+    },
+    disable: () => {
+    },
+    depthMask: () => {
+    },
+    blendFunc: () => {
+    },
+    viewport: () => {
+    },
+    clearColor: () => {
     },
-    advance(deltaMs = 16.6) {
-      this.tick(currentTime + deltaMs);
+    clear: () => {
     },
-    getCallbacks() {
-      return callbacks.map((c) => c.callback);
+    createTexture: () => ({}),
+    bindTexture: () => {
     },
-    reset() {
-      callbacks = [];
-      nextId = 1;
-      currentTime = 0;
+    texImage2D: () => {
     },
-    enable() {
-      activeMockRAF = this;
-      global.requestAnimationFrame = raf;
-      global.cancelAnimationFrame = cancel;
+    texParameteri: () => {
     },
-    disable() {
-      if (activeMockRAF === this) {
-        activeMockRAF = void 0;
-      }
-      if (originalRAF) {
-        global.requestAnimationFrame = originalRAF;
-      } else {
-        delete global.requestAnimationFrame;
-      }
-      if (originalCancelRAF) {
-        global.cancelAnimationFrame = originalCancelRAF;
-      } else {
-        delete global.cancelAnimationFrame;
-      }
-    }
-  };
-  return mock;
-}
-function createMockPerformance(startTime = 0) {
-  let currentTime = startTime;
-  const mockPerf = {
-    now: () => currentTime,
-    timeOrigin: startTime,
-    timing: {
-      navigationStart: startTime
+    activeTexture: () => {
     },
-    clearMarks: () => {
+    uniform1i: () => {
     },
-    clearMeasures: () => {
+    uniform1f: () => {
     },
-    clearResourceTimings: () => {
+    uniform2f: () => {
     },
-    getEntries: () => [],
-    getEntriesByName: () => [],
-    getEntriesByType: () => [],
-    mark: () => {
+    uniform3f: () => {
     },
-    measure: () => {
+    uniform4f: () => {
     },
-    setResourceTimingBufferSize: () => {
+    uniformMatrix4fv: () => {
     },
-    toJSON: () => ({}),
-    addEventListener: () => {
+    getUniformLocation: () => ({}),
+    getAttribLocation: () => 0,
+    drawArrays: () => {
     },
-    removeEventListener: () => {
+    drawElements: () => {
     },
-    dispatchEvent: () => true
-  };
-  mockPerf.advance = (deltaMs) => {
-    currentTime += deltaMs;
-  };
-  mockPerf.setTime = (time) => {
-    currentTime = time;
+    createVertexArray: () => ({}),
+    bindVertexArray: () => {
+    },
+    deleteShader: () => {
+    },
+    deleteProgram: () => {
+    },
+    deleteBuffer: () => {
+    },
+    deleteTexture: () => {
+    },
+    deleteVertexArray: () => {
+    },
+    // WebGL2 specific
+    texImage3D: () => {
+    },
+    uniformBlockBinding: () => {
+    },
+    getExtension: () => null
   };
-  return mockPerf;
+  return gl;
 }
-function createControlledTimer() {
-  let currentTime = 0;
-  let timers = [];
-  let nextId = 1;
-  const originalSetTimeout = global.setTimeout;
-  const originalClearTimeout = global.clearTimeout;
-  const originalSetInterval = global.setInterval;
-  const originalClearInterval = global.clearInterval;
-  const mockSetTimeout = (callback, delay = 0, ...args) => {
-    const id = nextId++;
-    timers.push({ id, callback, dueTime: currentTime + delay, args });
-    return id;
-  };
-  const mockClearTimeout = (id) => {
-    timers = timers.filter((t) => t.id !== id);
-  };
-  const mockSetInterval = (callback, delay = 0, ...args) => {
-    const id = nextId++;
-    timers.push({ id, callback, dueTime: currentTime + delay, interval: delay, args });
-    return id;
-  };
-  const mockClearInterval = (id) => {
-    timers = timers.filter((t) => t.id !== id);
-  };
-  global.setTimeout = mockSetTimeout;
-  global.clearTimeout = mockClearTimeout;
-  global.setInterval = mockSetInterval;
-  global.clearInterval = mockClearInterval;
-  return {
-    tick() {
-      this.advanceBy(0);
-    },
-    advanceBy(ms) {
-      const targetTime = currentTime + ms;
-      while (true) {
-        let earliest = null;
-        for (const t of timers) {
-          if (!earliest || t.dueTime < earliest.dueTime) {
-            earliest = t;
-          }
+
+// src/setup/browser.ts
+function setupBrowserEnvironment(options = {}) {
+  const {
+    url = "http://localhost",
+    pretendToBeVisual = true,
+    resources = void 0,
+    enableWebGL2 = false,
+    enablePointerLock = false
+  } = options;
+  const dom = new import_jsdom.JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
+    url,
+    pretendToBeVisual,
+    resources
+  });
+  global.window = dom.window;
+  global.document = dom.window.document;
+  try {
+    global.navigator = dom.window.navigator;
+  } catch (e) {
+    try {
+      Object.defineProperty(global, "navigator", {
+        value: dom.window.navigator,
+        writable: true,
+        configurable: true
+      });
+    } catch (e2) {
+      console.warn("Could not assign global.navigator, skipping.");
+    }
+  }
+  global.location = dom.window.location;
+  global.HTMLElement = dom.window.HTMLElement;
+  global.HTMLCanvasElement = dom.window.HTMLCanvasElement;
+  global.Event = dom.window.Event;
+  global.CustomEvent = dom.window.CustomEvent;
+  global.DragEvent = dom.window.DragEvent;
+  global.MouseEvent = dom.window.MouseEvent;
+  global.KeyboardEvent = dom.window.KeyboardEvent;
+  global.FocusEvent = dom.window.FocusEvent;
+  global.WheelEvent = dom.window.WheelEvent;
+  global.InputEvent = dom.window.InputEvent;
+  global.UIEvent = dom.window.UIEvent;
+  try {
+    global.localStorage = dom.window.localStorage;
+  } catch (e) {
+  }
+  if (!global.localStorage) {
+    const storage = /* @__PURE__ */ new Map();
+    global.localStorage = {
+      getItem: (key) => storage.get(key) || null,
+      setItem: (key, value) => storage.set(key, value),
+      removeItem: (key) => storage.delete(key),
+      clear: () => storage.clear(),
+      key: (index) => Array.from(storage.keys())[index] || null,
+      get length() {
+        return storage.size;
+      }
+    };
+  }
+  const originalCreateElement = document.createElement.bind(document);
+  document.createElement = function(tagName, options2) {
+    if (tagName.toLowerCase() === "canvas") {
+      const napiCanvas = new import_canvas.Canvas(300, 150);
+      const domCanvas = originalCreateElement("canvas", options2);
+      Object.defineProperty(domCanvas, "width", {
+        get: () => napiCanvas.width,
+        set: (value) => {
+          napiCanvas.width = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(domCanvas, "height", {
+        get: () => napiCanvas.height,
+        set: (value) => {
+          napiCanvas.height = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      const originalGetContext = domCanvas.getContext.bind(domCanvas);
+      domCanvas.getContext = function(contextId, options3) {
+        if (contextId === "2d") {
+          return napiCanvas.getContext("2d", options3);
         }
-        if (!earliest || earliest.dueTime > targetTime) {
-          break;
+        if (enableWebGL2 && contextId === "webgl2") {
+          return createMockWebGL2Context(domCanvas);
         }
-        currentTime = earliest.dueTime;
-        const { callback, args, interval, id } = earliest;
-        if (interval !== void 0) {
-          earliest.dueTime += interval;
-          if (interval === 0) earliest.dueTime += 1;
-        } else {
-          timers = timers.filter((t) => t.id !== id);
+        if (contextId === "webgl" || contextId === "webgl2") {
+          return originalGetContext(contextId, options3);
+        }
+        return napiCanvas.getContext(contextId, options3);
+      };
+      domCanvas.__napiCanvas = napiCanvas;
+      return domCanvas;
+    }
+    return originalCreateElement(tagName, options2);
+  };
+  if (enableWebGL2) {
+    const originalProtoGetContext = global.HTMLCanvasElement.prototype.getContext;
+    global.HTMLCanvasElement.prototype.getContext = function(contextId, options2) {
+      if (contextId === "webgl2") {
+        return createMockWebGL2Context(this);
+      }
+      return originalProtoGetContext.call(this, contextId, options2);
+    };
+  }
+  global.Image = import_canvas.Image;
+  global.ImageData = import_canvas.ImageData;
+  if (typeof global.createImageBitmap === "undefined") {
+    global.createImageBitmap = async function(image, _options) {
+      if (image && typeof image.width === "number" && typeof image.height === "number") {
+        const canvas2 = new import_canvas.Canvas(image.width, image.height);
+        const ctx = canvas2.getContext("2d");
+        if (image.data) {
+          ctx.putImageData(image, 0, 0);
         }
-        callback(...args);
+        return canvas2;
       }
-      currentTime = targetTime;
-    },
-    clear() {
-      timers = [];
-    },
-    restore() {
-      global.setTimeout = originalSetTimeout;
-      global.clearTimeout = originalClearTimeout;
-      global.setInterval = originalSetInterval;
-      global.clearInterval = originalClearInterval;
-    }
-  };
-}
-function simulateFrames(count, frameTimeMs = 16.6, callback) {
-  if (!activeMockRAF) {
-    throw new Error("simulateFrames requires an active MockRAF. Ensure createMockRAF().enable() is called.");
+      const canvas = new import_canvas.Canvas(100, 100);
+      return canvas;
+    };
   }
-  for (let i = 0; i < count; i++) {
-    if (callback) callback(i);
-    activeMockRAF.advance(frameTimeMs);
+  if (typeof global.btoa === "undefined") {
+    global.btoa = function(str) {
+      return Buffer.from(str, "binary").toString("base64");
+    };
   }
-}
-function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
-  for (let i = 0; i < count; i++) {
-    if (callback) callback(i);
-    mock.advance(frameTimeMs);
+  if (typeof global.atob === "undefined") {
+    global.atob = function(str) {
+      return Buffer.from(str, "base64").toString("binary");
+    };
+  }
+  if (enablePointerLock) {
+    MockPointerLock.setup(global.document);
+  }
+  if (typeof global.requestAnimationFrame === "undefined") {
+    let lastTime = 0;
+    global.requestAnimationFrame = (callback) => {
+      const currTime = Date.now();
+      const timeToCall = Math.max(0, 16 - (currTime - lastTime));
+      const id = setTimeout(() => {
+        callback(currTime + timeToCall);
+      }, timeToCall);
+      lastTime = currTime + timeToCall;
+      return id;
+    };
+    global.cancelAnimationFrame = (id) => {
+      clearTimeout(id);
+    };
   }
 }
+function teardownBrowserEnvironment() {
+  delete global.window;
+  delete global.document;
+  delete global.navigator;
+  delete global.localStorage;
+  delete global.location;
+  delete global.HTMLElement;
+  delete global.HTMLCanvasElement;
+  delete global.Image;
+  delete global.ImageData;
+  delete global.createImageBitmap;
+  delete global.Event;
+  delete global.CustomEvent;
+  delete global.DragEvent;
+  delete global.MouseEvent;
+  delete global.KeyboardEvent;
+  delete global.FocusEvent;
+  delete global.WheelEvent;
+  delete global.InputEvent;
+  delete global.UIEvent;
+}
 
-// src/e2e/playwright.ts
-var import_playwright = require("playwright");
-var import_http = require("http");
-var import_serve_handler = __toESM(require("serve-handler"), 1);
-async function createPlaywrightTestClient(options = {}) {
-  let staticServer;
-  let clientUrl = options.clientUrl;
-  const rootPath = options.rootPath || process.cwd();
-  if (!clientUrl) {
-    staticServer = (0, import_http.createServer)((request, response) => {
-      return (0, import_serve_handler.default)(request, response, {
-        public: rootPath,
-        cleanUrls: false,
-        headers: [
-          {
-            source: "**/*",
-            headers: [
-              { key: "Cache-Control", value: "no-cache" },
-              { key: "Access-Control-Allow-Origin", value: "*" },
-              { key: "Cross-Origin-Opener-Policy", value: "same-origin" },
-              { key: "Cross-Origin-Embedder-Policy", value: "require-corp" }
-            ]
-          }
-        ]
-      });
-    });
-    await new Promise((resolve) => {
-      if (!staticServer) return;
-      staticServer.listen(0, () => {
-        const addr = staticServer?.address();
-        const port = typeof addr === "object" ? addr?.port : 0;
-        clientUrl = `http://localhost:${port}`;
-        console.log(`Test client serving from ${rootPath} at ${clientUrl}`);
-        resolve();
-      });
-    });
+// src/setup/canvas.ts
+var import_canvas2 = require("@napi-rs/canvas");
+function createMockCanvas(width = 300, height = 150) {
+  if (typeof document !== "undefined" && document.createElement) {
+    const canvas2 = document.createElement("canvas");
+    canvas2.width = width;
+    canvas2.height = height;
+    return canvas2;
   }
-  const browser = await import_playwright.chromium.launch({
-    headless: options.headless ?? true,
-    args: [
-      "--use-gl=egl",
-      "--ignore-gpu-blocklist",
-      ...options.launchOptions?.args || []
-    ],
-    ...options.launchOptions
-  });
-  const width = options.width || 1280;
-  const height = options.height || 720;
-  const context = await browser.newContext({
-    viewport: { width, height },
-    deviceScaleFactor: 1,
-    ...options.contextOptions
-  });
-  const page = await context.newPage();
-  const close = async () => {
-    await browser.close();
-    if (staticServer) {
-      staticServer.close();
-    }
-  };
-  const navigate = async (url) => {
-    const targetUrl = url || clientUrl;
-    if (!targetUrl) throw new Error("No URL to navigate to");
-    let finalUrl = targetUrl;
-    if (options.serverUrl && !targetUrl.includes("connect=")) {
-      const separator = targetUrl.includes("?") ? "&" : "?";
-      finalUrl = `${targetUrl}${separator}connect=${encodeURIComponent(options.serverUrl)}`;
+  const canvas = new import_canvas2.Canvas(width, height);
+  const originalGetContext = canvas.getContext.bind(canvas);
+  canvas.getContext = function(contextId, options) {
+    if (contextId === "webgl2") {
+      return createMockWebGL2Context(canvas);
     }
-    console.log(`Navigating to: ${finalUrl}`);
-    await page.goto(finalUrl, { waitUntil: "domcontentloaded" });
-  };
-  return {
-    browser,
-    context,
-    page,
-    server: staticServer,
-    close,
-    navigate,
-    waitForGame: async (timeout = 1e4) => {
-      await waitForGameReady(page, timeout);
-    },
-    injectInput: async (type, data) => {
-      await page.evaluate(({ type: type2, data: data2 }) => {
-        if (window.injectGameInput) window.injectGameInput(type2, data2);
-      }, { type, data });
+    if (contextId === "2d") {
+      return originalGetContext("2d", options);
     }
+    return originalGetContext(contextId, options);
   };
+  return canvas;
 }
-async function waitForGameReady(page, timeout = 1e4) {
-  try {
-    await page.waitForFunction(() => {
-      return window.gameInstance && window.gameInstance.isReady;
-    }, null, { timeout });
-  } catch (e) {
-    await page.waitForSelector("canvas", { timeout });
+function createMockCanvasContext2D(canvas) {
+  if (!canvas) {
+    canvas = createMockCanvas();
   }
+  return canvas.getContext("2d");
 }
-async function captureGameState(page) {
-  return await page.evaluate(() => {
-    if (window.gameInstance && window.gameInstance.getState) {
-      return window.gameInstance.getState();
+function captureCanvasDrawCalls(context) {
+  const drawCalls = [];
+  const methodsToSpy = [
+    "fillRect",
+    "strokeRect",
+    "clearRect",
+    "fillText",
+    "strokeText",
+    "drawImage",
+    "beginPath",
+    "closePath",
+    "moveTo",
+    "lineTo",
+    "arc",
+    "arcTo",
+    "bezierCurveTo",
+    "quadraticCurveTo",
+    "stroke",
+    "fill",
+    "putImageData"
+  ];
+  methodsToSpy.forEach((method) => {
+    const original = context[method];
+    if (typeof original === "function") {
+      context[method] = function(...args) {
+        drawCalls.push({ method, args });
+        return original.apply(this, args);
+      };
     }
-    return {};
   });
+  return drawCalls;
 }
-
-// src/shared/bsp.ts
-var import_shared = require("@quake2ts/shared");
-function makePlane(normal, dist) {
-  return {
-    normal,
-    dist,
-    type: Math.abs(normal.x) === 1 ? 0 : Math.abs(normal.y) === 1 ? 1 : Math.abs(normal.z) === 1 ? 2 : 3,
-    signbits: (0, import_shared.computePlaneSignBits)(normal)
-  };
-}
-function makeAxisBrush(size, contents = import_shared.CONTENTS_SOLID) {
-  const half = size / 2;
-  const planes = [
-    makePlane({ x: 1, y: 0, z: 0 }, half),
-    makePlane({ x: -1, y: 0, z: 0 }, half),
-    makePlane({ x: 0, y: 1, z: 0 }, half),
-    makePlane({ x: 0, y: -1, z: 0 }, half),
-    makePlane({ x: 0, y: 0, z: 1 }, half),
-    makePlane({ x: 0, y: 0, z: -1 }, half)
-  ];
-  return {
-    contents,
-    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
-  };
+function createMockImageData(width, height, fillColor) {
+  const imageData = new import_canvas2.ImageData(width, height);
+  if (fillColor) {
+    const [r, g, b, a] = fillColor;
+    for (let i = 0; i < imageData.data.length; i += 4) {
+      imageData.data[i] = r;
+      imageData.data[i + 1] = g;
+      imageData.data[i + 2] = b;
+      imageData.data[i + 3] = a;
+    }
+  }
+  return imageData;
 }
-function makeNode(plane, children) {
-  return { plane, children };
+function createMockImage(width, height, src) {
+  const img = new import_canvas2.Image();
+  if (width) img.width = width;
+  if (height) img.height = height;
+  if (src) img.src = src;
+  return img;
 }
-function makeBspModel(planes, nodes, leaves, brushes, leafBrushes) {
+
+// src/setup/node.ts
+function setupNodeEnvironment(options = {}) {
+  if (options.polyfillFetch && typeof global.fetch === "undefined") {
+  }
+}
+
+// src/setup/storage.ts
+var import_auto2 = require("fake-indexeddb/auto");
+function createMockLocalStorage(initialData = {}) {
+  const storage = new Map(Object.entries(initialData));
   return {
-    planes,
-    nodes,
-    leaves,
-    brushes,
-    leafBrushes,
-    bmodels: []
+    getItem: (key) => storage.get(key) || null,
+    setItem: (key, value) => storage.set(key, value),
+    removeItem: (key) => storage.delete(key),
+    clear: () => storage.clear(),
+    key: (index) => Array.from(storage.keys())[index] || null,
+    get length() {
+      return storage.size;
+    }
   };
 }
-function makeLeaf(contents, firstLeafBrush, numLeafBrushes) {
-  return { contents, cluster: 0, area: 0, firstLeafBrush, numLeafBrushes };
+function createMockSessionStorage(initialData = {}) {
+  return createMockLocalStorage(initialData);
 }
-function makeLeafModel(brushes) {
-  const planes = brushes.flatMap((brush) => brush.sides.map((side) => side.plane));
-  return {
-    planes,
-    nodes: [],
-    leaves: [makeLeaf(0, 0, brushes.length)],
-    brushes,
-    leafBrushes: brushes.map((_, i) => i),
-    bmodels: []
-  };
+function createMockIndexedDB() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
+  }
+  return indexedDB;
 }
-function makeBrushFromMinsMaxs(mins, maxs, contents = import_shared.CONTENTS_SOLID) {
-  const planes = [
-    makePlane({ x: 1, y: 0, z: 0 }, maxs.x),
-    makePlane({ x: -1, y: 0, z: 0 }, -mins.x),
-    makePlane({ x: 0, y: 1, z: 0 }, maxs.y),
-    makePlane({ x: 0, y: -1, z: 0 }, -mins.y),
-    makePlane({ x: 0, y: 0, z: 1 }, maxs.z),
-    makePlane({ x: 0, y: 0, z: -1 }, -mins.z)
-  ];
+function createStorageTestScenario(storageType = "local") {
+  if (storageType === "indexed") {
+    const dbName = `test-db-${Math.random().toString(36).substring(7)}`;
+    const storeName = "test-store";
+    const storage2 = createMockIndexedDB();
+    return {
+      storage: storage2,
+      populate: async (data) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onupgradeneeded = (e) => {
+            const db = e.target.result;
+            db.createObjectStore(storeName);
+          };
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            const tx = db.transaction(storeName, "readwrite");
+            const store = tx.objectStore(storeName);
+            Object.entries(data).forEach(([k, v]) => store.put(v, k));
+            tx.oncomplete = () => {
+              db.close();
+              resolve();
+            };
+            tx.onerror = () => reject(tx.error);
+          };
+          req.onerror = () => reject(req.error);
+        });
+      },
+      verify: async (key, value) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+              db.close();
+              resolve(false);
+              return;
+            }
+            const tx = db.transaction(storeName, "readonly");
+            const store = tx.objectStore(storeName);
+            const getReq = store.get(key);
+            getReq.onsuccess = () => {
+              const result = getReq.result === value;
+              db.close();
+              resolve(result);
+            };
+            getReq.onerror = () => {
+              db.close();
+              resolve(false);
+            };
+          };
+          req.onerror = () => reject(req.error);
+        });
+      }
+    };
+  }
+  const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
   return {
-    contents,
-    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
-  };
-}
-
-// src/shared/mocks.ts
-var import_vitest = require("vitest");
-var createBinaryWriterMock = () => ({
-  writeByte: import_vitest.vi.fn(),
-  writeShort: import_vitest.vi.fn(),
-  writeLong: import_vitest.vi.fn(),
-  writeString: import_vitest.vi.fn(),
-  writeBytes: import_vitest.vi.fn(),
-  getBuffer: import_vitest.vi.fn(() => new Uint8Array(0)),
-  reset: import_vitest.vi.fn(),
-  // Legacy methods (if any)
-  writeInt8: import_vitest.vi.fn(),
-  writeUint8: import_vitest.vi.fn(),
-  writeInt16: import_vitest.vi.fn(),
-  writeUint16: import_vitest.vi.fn(),
-  writeInt32: import_vitest.vi.fn(),
-  writeUint32: import_vitest.vi.fn(),
-  writeFloat: import_vitest.vi.fn(),
-  getData: import_vitest.vi.fn(() => new Uint8Array(0))
-});
-var createNetChanMock = () => ({
-  qport: 1234,
-  // Sequencing
-  incomingSequence: 0,
-  outgoingSequence: 0,
-  incomingAcknowledged: 0,
-  // Reliable messaging
-  incomingReliableAcknowledged: false,
-  incomingReliableSequence: 0,
-  outgoingReliableSequence: 0,
-  reliableMessage: createBinaryWriterMock(),
-  reliableLength: 0,
-  // Fragmentation
-  fragmentSendOffset: 0,
-  fragmentBuffer: null,
-  fragmentLength: 0,
-  fragmentReceived: 0,
-  // Timing
-  lastReceived: 0,
-  lastSent: 0,
-  remoteAddress: { type: "IP", port: 1234 },
-  // Methods
-  setup: import_vitest.vi.fn(),
-  reset: import_vitest.vi.fn(),
-  transmit: import_vitest.vi.fn(),
-  process: import_vitest.vi.fn(),
-  canSendReliable: import_vitest.vi.fn(() => true),
-  writeReliableByte: import_vitest.vi.fn(),
-  writeReliableShort: import_vitest.vi.fn(),
-  writeReliableLong: import_vitest.vi.fn(),
-  writeReliableString: import_vitest.vi.fn(),
-  getReliableData: import_vitest.vi.fn(() => new Uint8Array(0)),
-  needsKeepalive: import_vitest.vi.fn(() => false),
-  isTimedOut: import_vitest.vi.fn(() => false)
-});
-var createBinaryStreamMock = () => ({
-  getPosition: import_vitest.vi.fn(() => 0),
-  getReadPosition: import_vitest.vi.fn(() => 0),
-  getLength: import_vitest.vi.fn(() => 0),
-  getRemaining: import_vitest.vi.fn(() => 0),
-  seek: import_vitest.vi.fn(),
-  setReadPosition: import_vitest.vi.fn(),
-  hasMore: import_vitest.vi.fn(() => true),
-  hasBytes: import_vitest.vi.fn((amount) => true),
-  readChar: import_vitest.vi.fn(() => 0),
-  readByte: import_vitest.vi.fn(() => 0),
-  readShort: import_vitest.vi.fn(() => 0),
-  readUShort: import_vitest.vi.fn(() => 0),
-  readLong: import_vitest.vi.fn(() => 0),
-  readULong: import_vitest.vi.fn(() => 0),
-  readFloat: import_vitest.vi.fn(() => 0),
-  readString: import_vitest.vi.fn(() => ""),
-  readStringLine: import_vitest.vi.fn(() => ""),
-  readCoord: import_vitest.vi.fn(() => 0),
-  readAngle: import_vitest.vi.fn(() => 0),
-  readAngle16: import_vitest.vi.fn(() => 0),
-  readData: import_vitest.vi.fn((length) => new Uint8Array(length)),
-  readPos: import_vitest.vi.fn(),
-  readDir: import_vitest.vi.fn()
-});
-
-// src/game/factories.ts
-var createPlayerStateFactory = (overrides) => ({
-  pm_type: 0,
-  pm_time: 0,
-  pm_flags: 0,
-  origin: { x: 0, y: 0, z: 0 },
-  velocity: { x: 0, y: 0, z: 0 },
-  viewAngles: { x: 0, y: 0, z: 0 },
-  onGround: false,
-  waterLevel: 0,
-  watertype: 0,
-  mins: { x: 0, y: 0, z: 0 },
-  maxs: { x: 0, y: 0, z: 0 },
-  damageAlpha: 0,
-  damageIndicators: [],
-  blend: [0, 0, 0, 0],
-  stats: [],
-  kick_angles: { x: 0, y: 0, z: 0 },
-  kick_origin: { x: 0, y: 0, z: 0 },
-  gunoffset: { x: 0, y: 0, z: 0 },
-  gunangles: { x: 0, y: 0, z: 0 },
-  gunindex: 0,
-  gun_frame: 0,
-  rdflags: 0,
-  fov: 90,
-  renderfx: 0,
-  ...overrides
-});
-var createEntityStateFactory = (overrides) => ({
-  number: 0,
-  origin: { x: 0, y: 0, z: 0 },
-  angles: { x: 0, y: 0, z: 0 },
-  oldOrigin: { x: 0, y: 0, z: 0 },
-  modelIndex: 0,
-  modelIndex2: 0,
-  modelIndex3: 0,
-  modelIndex4: 0,
-  frame: 0,
-  skinNum: 0,
-  effects: 0,
-  renderfx: 0,
-  solid: 0,
-  sound: 0,
-  event: 0,
-  ...overrides
-});
-var createGameStateSnapshotFactory = (overrides) => ({
-  gravity: { x: 0, y: 0, z: -800 },
-  origin: { x: 0, y: 0, z: 0 },
-  velocity: { x: 0, y: 0, z: 0 },
-  viewangles: { x: 0, y: 0, z: 0 },
-  level: { timeSeconds: 0, frameNumber: 0, previousTimeSeconds: 0, deltaSeconds: 0.1 },
-  entities: {
-    activeCount: 0,
-    worldClassname: "worldspawn"
-  },
-  packetEntities: [],
-  pmFlags: 0,
-  pmType: 0,
-  waterlevel: 0,
-  watertype: 0,
-  deltaAngles: { x: 0, y: 0, z: 0 },
-  health: 100,
-  armor: 0,
-  ammo: 0,
-  blend: [0, 0, 0, 0],
-  damageAlpha: 0,
-  damageIndicators: [],
-  stats: [],
-  kick_angles: { x: 0, y: 0, z: 0 },
-  kick_origin: { x: 0, y: 0, z: 0 },
-  gunoffset: { x: 0, y: 0, z: 0 },
-  gunangles: { x: 0, y: 0, z: 0 },
-  gunindex: 0,
-  pm_time: 0,
-  gun_frame: 0,
-  rdflags: 0,
-  fov: 90,
-  renderfx: 0,
-  pm_flags: 0,
-  pm_type: 0,
-  ...overrides
-});
-
-// src/game/helpers.ts
-var import_vitest2 = require("vitest");
-var import_game = require("@quake2ts/game");
-var import_shared2 = require("@quake2ts/shared");
-var import_shared3 = require("@quake2ts/shared");
-var createMockEngine = () => ({
-  sound: import_vitest2.vi.fn(),
-  soundIndex: import_vitest2.vi.fn((sound) => 0),
-  modelIndex: import_vitest2.vi.fn((model) => 0),
-  centerprintf: import_vitest2.vi.fn()
-});
-var createMockGame = (seed = 12345) => {
-  const spawnRegistry = new import_game.SpawnRegistry();
-  const hooks = new import_game.ScriptHookRegistry();
-  const game = {
-    random: (0, import_shared2.createRandomGenerator)({ seed }),
-    registerEntitySpawn: import_vitest2.vi.fn((classname, spawnFunc) => {
-      spawnRegistry.register(classname, (entity) => spawnFunc(entity));
+    storage,
+    populate(data) {
+      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
+    },
+    verify(key, value) {
+      return storage.getItem(key) === value;
+    }
+  };
+}
+
+// src/setup/audio.ts
+function createMockAudioContext() {
+  const context = {
+    createGain: () => ({
+      connect: () => {
+      },
+      gain: { value: 1, setValueAtTime: () => {
+      } }
     }),
-    unregisterEntitySpawn: import_vitest2.vi.fn((classname) => {
-      spawnRegistry.unregister(classname);
+    createOscillator: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      frequency: { value: 440 }
     }),
-    getCustomEntities: import_vitest2.vi.fn(() => Array.from(spawnRegistry.keys())),
-    hooks,
-    registerHooks: import_vitest2.vi.fn((newHooks) => hooks.register(newHooks)),
-    spawnWorld: import_vitest2.vi.fn(() => {
-      hooks.onMapLoad("q2dm1");
+    createBufferSource: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      buffer: null,
+      playbackRate: { value: 1 },
+      loop: false
     }),
-    clientBegin: import_vitest2.vi.fn((client) => {
-      hooks.onPlayerSpawn({});
+    destination: {},
+    currentTime: 0,
+    state: "running",
+    resume: async () => {
+    },
+    suspend: async () => {
+    },
+    close: async () => {
+    },
+    decodeAudioData: async (buffer) => ({
+      duration: 1,
+      length: 44100,
+      sampleRate: 44100,
+      numberOfChannels: 2,
+      getChannelData: () => new Float32Array(44100)
     }),
-    damage: import_vitest2.vi.fn((amount) => {
-      hooks.onDamage({}, null, null, amount, 0, 0);
-    })
-  };
-  return { game, spawnRegistry };
-};
-function createTestContext(options) {
-  const engine = createMockEngine();
-  const seed = options?.seed ?? 12345;
-  const { game, spawnRegistry } = createMockGame(seed);
-  const traceFn = import_vitest2.vi.fn((start, end, mins, maxs) => ({
-    fraction: 1,
-    ent: null,
-    allsolid: false,
-    startsolid: false,
-    endpos: end,
-    plane: { normal: { x: 0, y: 0, z: 1 }, dist: 0 },
-    surfaceFlags: 0,
-    contents: 0
-  }));
-  const entityList = options?.initialEntities ? [...options.initialEntities] : [];
-  const hooks = game.hooks;
-  const entities = {
-    spawn: import_vitest2.vi.fn(() => {
-      const ent = new import_game.Entity(entityList.length + 1);
-      entityList.push(ent);
-      hooks.onEntitySpawn(ent);
-      return ent;
+    createBuffer: (channels, length, sampleRate) => ({
+      duration: length / sampleRate,
+      length,
+      sampleRate,
+      numberOfChannels: channels,
+      getChannelData: () => new Float32Array(length)
     }),
-    free: import_vitest2.vi.fn((ent) => {
-      const idx = entityList.indexOf(ent);
-      if (idx !== -1) {
-        entityList.splice(idx, 1);
+    // Helper to track events if needed
+    _events: []
+  };
+  return new Proxy(context, {
+    get(target, prop, receiver) {
+      if (prop === "_events") return target._events;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return (...args) => {
+          target._events.push({ type: String(prop), args });
+          return Reflect.apply(value, target, args);
+        };
       }
-      hooks.onEntityRemove(ent);
-    }),
-    finalizeSpawn: import_vitest2.vi.fn(),
-    freeImmediate: import_vitest2.vi.fn((ent) => {
-      const idx = entityList.indexOf(ent);
-      if (idx !== -1) {
-        entityList.splice(idx, 1);
+      return value;
+    }
+  });
+}
+function setupMockAudioContext() {
+  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
+    global.AudioContext = class {
+      constructor() {
+        return createMockAudioContext();
+      }
+    };
+    global.window.AudioContext = global.AudioContext;
+    global.window.webkitAudioContext = global.AudioContext;
+  }
+}
+function teardownMockAudioContext() {
+  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
+    delete global.AudioContext;
+    delete global.window.AudioContext;
+    delete global.window.webkitAudioContext;
+  }
+}
+function captureAudioEvents(context) {
+  return context._events || [];
+}
+
+// src/setup/timing.ts
+var activeMockRAF;
+function createMockRAF() {
+  let callbacks = [];
+  let nextId = 1;
+  let currentTime = 0;
+  const originalRAF = global.requestAnimationFrame;
+  const originalCancelRAF = global.cancelAnimationFrame;
+  const raf = (callback) => {
+    const id = nextId++;
+    callbacks.push({ id, callback });
+    return id;
+  };
+  const cancel = (id) => {
+    callbacks = callbacks.filter((cb) => cb.id !== id);
+  };
+  const mock = {
+    tick(timestamp) {
+      if (typeof timestamp !== "number") {
+        currentTime += 16.6;
+      } else {
+        currentTime = timestamp;
+      }
+      const currentCallbacks = [...callbacks];
+      callbacks = [];
+      currentCallbacks.forEach(({ callback }) => {
+        callback(currentTime);
+      });
+    },
+    advance(deltaMs = 16.6) {
+      this.tick(currentTime + deltaMs);
+    },
+    getCallbacks() {
+      return callbacks.map((c) => c.callback);
+    },
+    reset() {
+      callbacks = [];
+      nextId = 1;
+      currentTime = 0;
+    },
+    enable() {
+      activeMockRAF = this;
+      global.requestAnimationFrame = raf;
+      global.cancelAnimationFrame = cancel;
+    },
+    disable() {
+      if (activeMockRAF === this) {
+        activeMockRAF = void 0;
+      }
+      if (originalRAF) {
+        global.requestAnimationFrame = originalRAF;
+      } else {
+        delete global.requestAnimationFrame;
+      }
+      if (originalCancelRAF) {
+        global.cancelAnimationFrame = originalCancelRAF;
+      } else {
+        delete global.cancelAnimationFrame;
+      }
+    }
+  };
+  return mock;
+}
+function createMockPerformance(startTime = 0) {
+  let currentTime = startTime;
+  const mockPerf = {
+    now: () => currentTime,
+    timeOrigin: startTime,
+    timing: {
+      navigationStart: startTime
+    },
+    clearMarks: () => {
+    },
+    clearMeasures: () => {
+    },
+    clearResourceTimings: () => {
+    },
+    getEntries: () => [],
+    getEntriesByName: () => [],
+    getEntriesByType: () => [],
+    mark: () => {
+    },
+    measure: () => {
+    },
+    setResourceTimingBufferSize: () => {
+    },
+    toJSON: () => ({}),
+    addEventListener: () => {
+    },
+    removeEventListener: () => {
+    },
+    dispatchEvent: () => true
+  };
+  mockPerf.advance = (deltaMs) => {
+    currentTime += deltaMs;
+  };
+  mockPerf.setTime = (time) => {
+    currentTime = time;
+  };
+  return mockPerf;
+}
+function createControlledTimer() {
+  let currentTime = 0;
+  let timers = [];
+  let nextId = 1;
+  const originalSetTimeout = global.setTimeout;
+  const originalClearTimeout = global.clearTimeout;
+  const originalSetInterval = global.setInterval;
+  const originalClearInterval = global.clearInterval;
+  const mockSetTimeout = (callback, delay = 0, ...args) => {
+    const id = nextId++;
+    timers.push({ id, callback, dueTime: currentTime + delay, args });
+    return id;
+  };
+  const mockClearTimeout = (id) => {
+    timers = timers.filter((t) => t.id !== id);
+  };
+  const mockSetInterval = (callback, delay = 0, ...args) => {
+    const id = nextId++;
+    timers.push({ id, callback, dueTime: currentTime + delay, interval: delay, args });
+    return id;
+  };
+  const mockClearInterval = (id) => {
+    timers = timers.filter((t) => t.id !== id);
+  };
+  global.setTimeout = mockSetTimeout;
+  global.clearTimeout = mockClearTimeout;
+  global.setInterval = mockSetInterval;
+  global.clearInterval = mockClearInterval;
+  return {
+    tick() {
+      this.advanceBy(0);
+    },
+    advanceBy(ms) {
+      const targetTime = currentTime + ms;
+      while (true) {
+        let earliest = null;
+        for (const t of timers) {
+          if (!earliest || t.dueTime < earliest.dueTime) {
+            earliest = t;
+          }
+        }
+        if (!earliest || earliest.dueTime > targetTime) {
+          break;
+        }
+        currentTime = earliest.dueTime;
+        const { callback, args, interval, id } = earliest;
+        if (interval !== void 0) {
+          earliest.dueTime += interval;
+          if (interval === 0) earliest.dueTime += 1;
+        } else {
+          timers = timers.filter((t) => t.id !== id);
+        }
+        callback(...args);
       }
-    }),
-    setSpawnRegistry: import_vitest2.vi.fn(),
-    timeSeconds: 10,
-    deltaSeconds: 0.1,
-    modelIndex: import_vitest2.vi.fn(() => 0),
-    scheduleThink: import_vitest2.vi.fn((entity, time) => {
-      entity.nextthink = time;
-    }),
-    linkentity: import_vitest2.vi.fn(),
-    trace: traceFn,
-    pointcontents: import_vitest2.vi.fn(() => 0),
-    multicast: import_vitest2.vi.fn(),
-    unicast: import_vitest2.vi.fn(),
-    engine,
-    game,
-    sound: import_vitest2.vi.fn((ent, chan, sound, vol, attn, timeofs) => {
-      engine.sound(ent, chan, sound, vol, attn, timeofs);
-    }),
-    soundIndex: import_vitest2.vi.fn((sound) => engine.soundIndex(sound)),
-    useTargets: import_vitest2.vi.fn((entity, activator) => {
-    }),
-    findByTargetName: import_vitest2.vi.fn(() => []),
-    pickTarget: import_vitest2.vi.fn(() => null),
-    killBox: import_vitest2.vi.fn(),
-    rng: (0, import_shared2.createRandomGenerator)({ seed }),
-    imports: {
-      configstring: import_vitest2.vi.fn(),
-      trace: traceFn,
-      pointcontents: import_vitest2.vi.fn(() => 0)
+      currentTime = targetTime;
     },
-    level: {
-      intermission_angle: { x: 0, y: 0, z: 0 },
-      intermission_origin: { x: 0, y: 0, z: 0 },
-      next_auto_save: 0,
-      health_bar_entities: null
+    clear() {
+      timers = [];
     },
-    targetNameIndex: /* @__PURE__ */ new Map(),
-    forEachEntity: import_vitest2.vi.fn((callback) => {
-      entityList.forEach(callback);
-    }),
-    find: import_vitest2.vi.fn((predicate) => {
-      return entityList.find(predicate);
-    }),
-    findByClassname: import_vitest2.vi.fn((classname) => {
-      return entityList.find((e) => e.classname === classname);
-    }),
-    beginFrame: import_vitest2.vi.fn((timeSeconds) => {
-      entities.timeSeconds = timeSeconds;
-    }),
-    targetAwareness: {
-      timeSeconds: 10,
-      frameNumber: 1,
-      sightEntity: null,
-      soundEntity: null
+    restore() {
+      global.setTimeout = originalSetTimeout;
+      global.clearTimeout = originalClearTimeout;
+      global.setInterval = originalSetInterval;
+      global.clearInterval = originalClearInterval;
+    }
+  };
+}
+function simulateFrames(count, frameTimeMs = 16.6, callback) {
+  if (!activeMockRAF) {
+    throw new Error("simulateFrames requires an active MockRAF. Ensure createMockRAF().enable() is called.");
+  }
+  for (let i = 0; i < count; i++) {
+    if (callback) callback(i);
+    activeMockRAF.advance(frameTimeMs);
+  }
+}
+function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
+  for (let i = 0; i < count; i++) {
+    if (callback) callback(i);
+    mock.advance(frameTimeMs);
+  }
+}
+
+// src/e2e/playwright.ts
+var import_playwright = require("playwright");
+var import_http = require("http");
+var import_serve_handler = __toESM(require("serve-handler"), 1);
+async function createPlaywrightTestClient(options = {}) {
+  let staticServer;
+  let clientUrl = options.clientUrl;
+  const rootPath = options.rootPath || process.cwd();
+  if (!clientUrl) {
+    staticServer = (0, import_http.createServer)((request, response) => {
+      return (0, import_serve_handler.default)(request, response, {
+        public: rootPath,
+        cleanUrls: false,
+        headers: [
+          {
+            source: "**/*",
+            headers: [
+              { key: "Cache-Control", value: "no-cache" },
+              { key: "Access-Control-Allow-Origin", value: "*" },
+              { key: "Cross-Origin-Opener-Policy", value: "same-origin" },
+              { key: "Cross-Origin-Embedder-Policy", value: "require-corp" }
+            ]
+          }
+        ]
+      });
+    });
+    await new Promise((resolve) => {
+      if (!staticServer) return;
+      staticServer.listen(0, () => {
+        const addr = staticServer?.address();
+        const port = typeof addr === "object" ? addr?.port : 0;
+        clientUrl = `http://localhost:${port}`;
+        console.log(`Test client serving from ${rootPath} at ${clientUrl}`);
+        resolve();
+      });
+    });
+  }
+  const browser = await import_playwright.chromium.launch({
+    headless: options.headless ?? true,
+    args: [
+      "--use-gl=egl",
+      "--ignore-gpu-blocklist",
+      ...options.launchOptions?.args || []
+    ],
+    ...options.launchOptions
+  });
+  const width = options.width || 1280;
+  const height = options.height || 720;
+  const context = await browser.newContext({
+    viewport: { width, height },
+    deviceScaleFactor: 1,
+    ...options.contextOptions
+  });
+  const page = await context.newPage();
+  const close = async () => {
+    await browser.close();
+    if (staticServer) {
+      staticServer.close();
+    }
+  };
+  const navigate = async (url) => {
+    const targetUrl = url || clientUrl;
+    if (!targetUrl) throw new Error("No URL to navigate to");
+    let finalUrl = targetUrl;
+    if (options.serverUrl && !targetUrl.includes("connect=")) {
+      const separator = targetUrl.includes("?") ? "&" : "?";
+      finalUrl = `${targetUrl}${separator}connect=${encodeURIComponent(options.serverUrl)}`;
+    }
+    console.log(`Navigating to: ${finalUrl}`);
+    await page.goto(finalUrl, { waitUntil: "domcontentloaded" });
+  };
+  return {
+    browser,
+    context,
+    page,
+    server: staticServer,
+    close,
+    navigate,
+    waitForGame: async (timeout = 1e4) => {
+      await waitForGameReady(page, timeout);
     },
-    // Adding missing properties to satisfy EntitySystem interface partially or fully
-    // We cast to unknown first anyway, but filling these in makes it safer for consumers
-    skill: 1,
-    deathmatch: false,
-    coop: false,
-    activeCount: entityList.length,
-    world: entityList.find((e) => e.classname === "worldspawn") || new import_game.Entity(0)
-    // ... other EntitySystem properties would go here
+    injectInput: async (type, data) => {
+      await page.evaluate(({ type: type2, data: data2 }) => {
+        if (window.injectGameInput) window.injectGameInput(type2, data2);
+      }, { type, data });
+    }
   };
+}
+async function waitForGameReady(page, timeout = 1e4) {
+  try {
+    await page.waitForFunction(() => {
+      return window.gameInstance && window.gameInstance.isReady;
+    }, null, { timeout });
+  } catch (e) {
+    await page.waitForSelector("canvas", { timeout });
+  }
+}
+async function captureGameState(page) {
+  return await page.evaluate(() => {
+    if (window.gameInstance && window.gameInstance.getState) {
+      return window.gameInstance.getState();
+    }
+    return {};
+  });
+}
+
+// src/e2e/network.ts
+var CONDITIONS = {
+  "good": {
+    offline: false,
+    downloadThroughput: 10 * 1024 * 1024,
+    // 10 Mbps
+    uploadThroughput: 5 * 1024 * 1024,
+    // 5 Mbps
+    latency: 20
+  },
+  "slow": {
+    offline: false,
+    downloadThroughput: 500 * 1024,
+    // 500 Kbps
+    uploadThroughput: 500 * 1024,
+    latency: 400
+  },
+  "unstable": {
+    offline: false,
+    downloadThroughput: 1 * 1024 * 1024,
+    uploadThroughput: 1 * 1024 * 1024,
+    latency: 100
+  },
+  "offline": {
+    offline: true,
+    downloadThroughput: 0,
+    uploadThroughput: 0,
+    latency: 0
+  }
+};
+function simulateNetworkCondition(condition) {
+  const config = CONDITIONS[condition];
+  return createCustomNetworkCondition(config.latency, 0, 0, config);
+}
+function createCustomNetworkCondition(latency, jitter = 0, packetLoss = 0, baseConfig) {
   return {
-    keyValues: {},
-    entities,
-    game,
-    engine,
-    health_multiplier: 1,
-    warn: import_vitest2.vi.fn(),
-    free: import_vitest2.vi.fn(),
-    // Mock precache functions if they are part of SpawnContext in future or TestContext extensions
-    precacheModel: import_vitest2.vi.fn(),
-    precacheSound: import_vitest2.vi.fn(),
-    precacheImage: import_vitest2.vi.fn()
+    async apply(page) {
+      const client = await page.context().newCDPSession(page);
+      await client.send("Network.enable");
+      await client.send("Network.emulateNetworkConditions", {
+        offline: baseConfig?.offline || false,
+        latency: latency + Math.random() * jitter,
+        downloadThroughput: baseConfig?.downloadThroughput || -1,
+        uploadThroughput: baseConfig?.uploadThroughput || -1
+      });
+    },
+    async clear(page) {
+      const client = await page.context().newCDPSession(page);
+      await client.send("Network.emulateNetworkConditions", {
+        offline: false,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1
+      });
+    }
   };
 }
-function createSpawnContext() {
-  return createTestContext();
+async function throttleBandwidth(page, bytesPerSecond) {
+  const simulator = createCustomNetworkCondition(0, 0, 0, {
+    offline: false,
+    latency: 0,
+    downloadThroughput: bytesPerSecond,
+    uploadThroughput: bytesPerSecond
+  });
+  await simulator.apply(page);
 }
-function createEntity() {
-  return new import_game.Entity(1);
+
+// src/e2e/visual.ts
+var import_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+async function captureGameScreenshot(page, name, options = {}) {
+  const dir = options.dir || "__screenshots__";
+  const screenshotPath = import_path.default.join(dir, `${name}.png`);
+  await import_promises.default.mkdir(dir, { recursive: true });
+  return await page.screenshot({
+    path: screenshotPath,
+    fullPage: options.fullPage ?? false,
+    animations: "disabled",
+    caret: "hide"
+  });
+}
+async function compareScreenshots(baseline, current, threshold = 0.1) {
+  if (baseline.equals(current)) {
+    return { pixelDiff: 0, matched: true };
+  }
+  return {
+    pixelDiff: -1,
+    // Unknown magnitude
+    matched: false
+  };
+}
+function createVisualTestScenario(page, sceneName) {
+  return {
+    async capture(snapshotName) {
+      return await captureGameScreenshot(page, `${sceneName}-${snapshotName}`);
+    },
+    async compare(snapshotName, baselineDir) {
+      const name = `${sceneName}-${snapshotName}`;
+      const current = await captureGameScreenshot(page, name, { dir: "__screenshots__/current" });
+      try {
+        const baselinePath = import_path.default.join(baselineDir, `${name}.png`);
+        const baseline = await import_promises.default.readFile(baselinePath);
+        return await compareScreenshots(baseline, current);
+      } catch (e) {
+        return { pixelDiff: -1, matched: false };
+      }
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InputInjector,
   MockPointerLock,
+  MockTransport,
   captureAudioEvents,
   captureCanvasDrawCalls,
+  captureGameScreenshot,
   captureGameState,
+  compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
   createControlledTimer,
+  createCustomNetworkCondition,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
@@ -1373,13 +1784,21 @@ function createEntity() {
   createMockCanvasContext2D,
   createMockEngine,
   createMockGame,
+  createMockGameState,
   createMockImage,
   createMockImageData,
   createMockIndexedDB,
   createMockLocalStorage,
+  createMockNetworkAddress,
   createMockPerformance,
   createMockRAF,
+  createMockServer,
+  createMockServerClient,
+  createMockServerState,
+  createMockServerStatic,
   createMockSessionStorage,
+  createMockTransport,
+  createMockUDPSocket,
   createMockWebGL2Context,
   createNetChanMock,
   createPlayerStateFactory,
@@ -1387,6 +1806,7 @@ function createEntity() {
   createSpawnContext,
   createStorageTestScenario,
   createTestContext,
+  createVisualTestScenario,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -1401,9 +1821,11 @@ function createEntity() {
   setupNodeEnvironment,
   simulateFrames,
   simulateFramesWithMock,
+  simulateNetworkCondition,
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
+  throttleBandwidth,
   waitForGameReady
 });
 //# sourceMappingURL=index.cjs.map