quake2ts 0.0.556 → 0.0.561

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

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,17 +32,33 @@ var index_exports = {};
 __export(index_exports, {
   InputInjector: () => InputInjector,
   MockPointerLock: () => MockPointerLock,
+  captureAudioEvents: () => captureAudioEvents,
+  captureCanvasDrawCalls: () => captureCanvasDrawCalls,
+  captureGameState: () => captureGameState,
   createBinaryStreamMock: () => createBinaryStreamMock,
   createBinaryWriterMock: () => createBinaryWriterMock,
+  createControlledTimer: () => createControlledTimer,
   createEntity: () => createEntity,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
+  createMockAudioContext: () => createMockAudioContext,
+  createMockCanvas: () => createMockCanvas,
+  createMockCanvasContext2D: () => createMockCanvasContext2D,
   createMockEngine: () => createMockEngine,
   createMockGame: () => createMockGame,
+  createMockImage: () => createMockImage,
+  createMockImageData: () => createMockImageData,
+  createMockIndexedDB: () => createMockIndexedDB,
+  createMockLocalStorage: () => createMockLocalStorage,
+  createMockPerformance: () => createMockPerformance,
+  createMockRAF: () => createMockRAF,
+  createMockSessionStorage: () => createMockSessionStorage,
   createMockWebGL2Context: () => createMockWebGL2Context,
   createNetChanMock: () => createNetChanMock,
   createPlayerStateFactory: () => createPlayerStateFactory,
+  createPlaywrightTestClient: () => createPlaywrightTestClient,
   createSpawnContext: () => createSpawnContext,
+  createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
   intersects: () => import_shared3.intersects,
   ladderTrace: () => import_shared3.ladderTrace,
@@ -44,417 +70,271 @@ __export(index_exports, {
   makeNode: () => makeNode,
   makePlane: () => makePlane,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
+  setupMockAudioContext: () => setupMockAudioContext,
   setupNodeEnvironment: () => setupNodeEnvironment,
+  simulateFrames: () => simulateFrames,
+  simulateFramesWithMock: () => simulateFramesWithMock,
   stairTrace: () => import_shared3.stairTrace,
-  teardownBrowserEnvironment: () => teardownBrowserEnvironment
+  teardownBrowserEnvironment: () => teardownBrowserEnvironment,
+  teardownMockAudioContext: () => teardownMockAudioContext,
+  waitForGameReady: () => waitForGameReady
 });
 module.exports = __toCommonJS(index_exports);
 
-// 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/setup/browser.ts
+var import_jsdom = require("jsdom");
+var import_canvas = require("@napi-rs/canvas");
+var import_auto = require("fake-indexeddb/auto");
 
-// 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 makeNode(plane, children) {
-  return { plane, children };
-}
-function makeBspModel(planes, nodes, leaves, brushes, leafBrushes) {
-  return {
-    planes,
-    nodes,
-    leaves,
-    brushes,
-    leafBrushes,
-    bmodels: []
-  };
-}
-function makeLeaf(contents, firstLeafBrush, numLeafBrushes) {
-  return { contents, cluster: 0, area: 0, firstLeafBrush, numLeafBrushes };
-}
-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 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/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/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);
-    })
-  };
-  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;
-    }),
-    free: import_vitest2.vi.fn((ent) => {
-      const idx = entityList.indexOf(ent);
-      if (idx !== -1) {
-        entityList.splice(idx, 1);
-      }
-      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);
-      }
-    }),
-    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)
+// 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: () => {
     },
-    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
+    compileShader: () => {
     },
-    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
+    getShaderParameter: (_, param) => {
+      if (param === 35713) return true;
+      return true;
     },
-    // 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 createSpawnContext() {
-  return createTestContext();
-}
-function createEntity() {
-  return new import_game.Entity(1);
+    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
-var import_jsdom = require("jsdom");
-var import_canvas = require("@napi-rs/canvas");
-var import_auto = require("fake-indexeddb/auto");
 function setupBrowserEnvironment(options = {}) {
-  const { url = "http://localhost", pretendToBeVisual = true } = 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
+    pretendToBeVisual,
+    resources
   });
   global.window = dom.window;
   global.document = dom.window.document;
-  global.navigator = dom.window.navigator;
+  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;
@@ -507,6 +387,9 @@ function setupBrowserEnvironment(options = {}) {
         if (contextId === "2d") {
           return napiCanvas.getContext("2d", options3);
         }
+        if (enableWebGL2 && contextId === "webgl2") {
+          return createMockWebGL2Context(domCanvas);
+        }
         if (contextId === "webgl" || contextId === "webgl2") {
           return originalGetContext(contextId, options3);
         }
@@ -517,6 +400,15 @@ function setupBrowserEnvironment(options = {}) {
     }
     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") {
@@ -543,6 +435,24 @@ function setupBrowserEnvironment(options = {}) {
       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;
@@ -551,9 +461,100 @@ function teardownBrowserEnvironment() {
   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);
+  };
+  return canvas;
+}
+function createMockCanvasContext2D(canvas) {
+  if (!canvas) {
+    canvas = createMockCanvas();
+  }
+  return canvas.getContext("2d");
+}
+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 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 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;
 }
 
 // src/setup/node.ts
@@ -562,237 +563,829 @@ function setupNodeEnvironment() {
   }
 }
 
-// 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: () => {
+// 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));
     },
-    getShaderParameter: (_, param) => {
-      if (param === 35713) return true;
-      return true;
+    verify(key, value) {
+      return storage.getItem(key) === value;
+    }
+  };
+}
+
+// src/setup/audio.ts
+function createMockAudioContext() {
+  return {
+    createGain: () => ({
+      connect: () => {
+      },
+      gain: { value: 1, setValueAtTime: () => {
+      } }
+    }),
+    createOscillator: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      frequency: { value: 440 }
+    }),
+    createBufferSource: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      buffer: null,
+      playbackRate: { value: 1 },
+      loop: false
+    }),
+    destination: {},
+    currentTime: 0,
+    state: "running",
+    resume: async () => {
     },
-    getShaderInfoLog: () => "",
-    createProgram: () => ({}),
-    attachShader: () => {
+    suspend: async () => {
     },
-    linkProgram: () => {
+    close: async () => {
     },
-    getProgramParameter: (_, param) => {
-      if (param === 35714) return true;
-      return true;
+    decodeAudioData: async (buffer) => ({
+      duration: 1,
+      length: 44100,
+      sampleRate: 44100,
+      numberOfChannels: 2,
+      getChannelData: () => new Float32Array(44100)
+    }),
+    createBuffer: (channels, length, sampleRate) => ({
+      duration: length / sampleRate,
+      length,
+      sampleRate,
+      numberOfChannels: channels,
+      getChannelData: () => new Float32Array(length)
+    })
+  };
+}
+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 [];
+}
+
+// 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);
+      });
     },
-    getProgramInfoLog: () => "",
-    useProgram: () => {
+    advance(deltaMs = 16.6) {
+      this.tick(currentTime + deltaMs);
     },
-    createBuffer: () => ({}),
-    bindBuffer: () => {
+    getCallbacks() {
+      return callbacks.map((c) => c.callback);
     },
-    bufferData: () => {
+    reset() {
+      callbacks = [];
+      nextId = 1;
+      currentTime = 0;
     },
-    enableVertexAttribArray: () => {
+    enable() {
+      activeMockRAF = this;
+      global.requestAnimationFrame = raf;
+      global.cancelAnimationFrame = cancel;
     },
-    vertexAttribPointer: () => {
+    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
     },
-    enable: () => {
+    clearMarks: () => {
     },
-    disable: () => {
+    clearMeasures: () => {
     },
-    depthMask: () => {
+    clearResourceTimings: () => {
     },
-    blendFunc: () => {
+    getEntries: () => [],
+    getEntriesByName: () => [],
+    getEntriesByType: () => [],
+    mark: () => {
     },
-    viewport: () => {
+    measure: () => {
     },
-    clearColor: () => {
+    setResourceTimingBufferSize: () => {
     },
-    clear: () => {
+    toJSON: () => ({}),
+    addEventListener: () => {
     },
-    createTexture: () => ({}),
-    bindTexture: () => {
+    removeEventListener: () => {
     },
-    texImage2D: () => {
+    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);
     },
-    texParameteri: () => {
+    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);
+      }
+      currentTime = targetTime;
     },
-    activeTexture: () => {
+    clear() {
+      timers = [];
     },
-    uniform1i: () => {
+    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);
     },
-    uniform1f: () => {
-    },
-    uniform2f: () => {
-    },
-    uniform3f: () => {
-    },
-    uniform4f: () => {
-    },
-    uniformMatrix4fv: () => {
-    },
-    getUniformLocation: () => ({}),
-    getAttribLocation: () => 0,
-    drawArrays: () => {
-    },
-    drawElements: () => {
-    },
-    createVertexArray: () => ({}),
-    bindVertexArray: () => {
-    },
-    deleteShader: () => {
-    },
-    deleteProgram: () => {
-    },
-    deleteBuffer: () => {
-    },
-    deleteTexture: () => {
-    },
-    deleteVertexArray: () => {
+    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/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 makeNode(plane, children) {
+  return { plane, children };
+}
+function makeBspModel(planes, nodes, leaves, brushes, leafBrushes) {
+  return {
+    planes,
+    nodes,
+    leaves,
+    brushes,
+    leafBrushes,
+    bmodels: []
+  };
+}
+function makeLeaf(contents, firstLeafBrush, numLeafBrushes) {
+  return { contents, cluster: 0, area: 0, firstLeafBrush, numLeafBrushes };
+}
+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 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/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));
+    }),
+    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);
+    })
+  };
+  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;
+    }),
+    free: import_vitest2.vi.fn((ent) => {
+      const idx = entityList.indexOf(ent);
+      if (idx !== -1) {
+        entityList.splice(idx, 1);
+      }
+      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);
+      }
+    }),
+    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)
     },
-    // WebGL2 specific
-    texImage3D: () => {
+    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
     },
-    uniformBlockBinding: () => {
+    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
     },
-    getExtension: () => 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()
   };
-  return gl;
 }
-
-// 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);
-  }
-};
+function createSpawnContext() {
+  return createTestContext();
+}
+function createEntity() {
+  return new import_game.Entity(1);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InputInjector,
   MockPointerLock,
+  captureAudioEvents,
+  captureCanvasDrawCalls,
+  captureGameState,
   createBinaryStreamMock,
   createBinaryWriterMock,
+  createControlledTimer,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
+  createMockAudioContext,
+  createMockCanvas,
+  createMockCanvasContext2D,
   createMockEngine,
   createMockGame,
+  createMockImage,
+  createMockImageData,
+  createMockIndexedDB,
+  createMockLocalStorage,
+  createMockPerformance,
+  createMockRAF,
+  createMockSessionStorage,
   createMockWebGL2Context,
   createNetChanMock,
   createPlayerStateFactory,
+  createPlaywrightTestClient,
   createSpawnContext,
+  createStorageTestScenario,
   createTestContext,
   intersects,
   ladderTrace,
@@ -804,8 +1397,13 @@ var InputInjector = class {
   makeNode,
   makePlane,
   setupBrowserEnvironment,
+  setupMockAudioContext,
   setupNodeEnvironment,
+  simulateFrames,
+  simulateFramesWithMock,
   stairTrace,
-  teardownBrowserEnvironment
+  teardownBrowserEnvironment,
+  teardownMockAudioContext,
+  waitForGameReady
 });
 //# sourceMappingURL=index.cjs.map