@quake2ts/test-utils 0.0.1 → 0.0.740

package/dist/index.cjs

@@ -62,7 +62,6 @@ __export(index_exports, {
   captureGameState: () => captureGameState,
   captureTexture: () => captureTexture,
   compareSaveGames: () => compareSaveGames,
-  compareScreenshot: () => compareScreenshot,
   compareScreenshots: () => compareScreenshots,
   compareSnapshots: () => compareSnapshots,
   createBandwidthTestScenario: () => createBandwidthTestScenario,
@@ -723,6 +722,24 @@ function createPlayerEntityFactory(overrides = {}) {
     movetype: import_game.MoveType.Walk,
     svflags: import_game.ServerFlags.Player,
     viewheight: 22,
+    client: {
+      inventory: {
+        ammo: { counts: [], caps: [] },
+        ownedWeapons: /* @__PURE__ */ new Set(),
+        powerups: /* @__PURE__ */ new Map(),
+        keys: /* @__PURE__ */ new Set(),
+        items: /* @__PURE__ */ new Set()
+      },
+      weaponStates: {
+        currentWeapon: null,
+        lastFireTime: 0,
+        weaponFrame: 0,
+        weaponIdleTime: 0,
+        states: /* @__PURE__ */ new Map(),
+        // Initialize states map correctly
+        activeWeaponId: null
+      }
+    },
     ...overrides
   });
 }
@@ -975,6 +992,33 @@ function createGameImportsAndEngine(overrides) {
   };
   return { imports, engine };
 }
+function createMockGameExports(overrides = {}) {
+  return {
+    init: import_vitest2.vi.fn(),
+    shutdown: import_vitest2.vi.fn(),
+    frame: import_vitest2.vi.fn().mockReturnValue({ state: {} }),
+    clientThink: import_vitest2.vi.fn(),
+    time: 0,
+    spawnWorld: import_vitest2.vi.fn(),
+    deathmatch: false,
+    coop: false,
+    gameImports: {},
+    gameEngine: {},
+    entities: {
+      spawn: import_vitest2.vi.fn(),
+      free: import_vitest2.vi.fn(),
+      find: import_vitest2.vi.fn(),
+      findByClassname: import_vitest2.vi.fn(),
+      findByRadius: import_vitest2.vi.fn(() => []),
+      forEachEntity: import_vitest2.vi.fn(),
+      timeSeconds: 0,
+      ...overrides.entities
+    },
+    multicast: import_vitest2.vi.fn(),
+    unicast: import_vitest2.vi.fn(),
+    ...overrides
+  };
+}
 
 // src/game/helpers/physics.ts
 var import_game3 = require("@quake2ts/game");
@@ -1403,96 +1447,8 @@ function createMockPowerupItem(id, duration, overrides = {}) {
   return { ...base, ...overrides };
 }
 
-// src/game/mocks.ts
-var import_vitest5 = require("vitest");
-function createMockGameState(overrides) {
-  return {
-    levelName: "test_level",
-    time: 0,
-    entities: [],
-    clients: [],
-    ...overrides
-  };
-}
-function createMockGameExports(overrides) {
-  return {
-    init: import_vitest5.vi.fn(),
-    shutdown: import_vitest5.vi.fn(),
-    spawnWorld: import_vitest5.vi.fn(),
-    frame: import_vitest5.vi.fn().mockReturnValue({ state: {} }),
-    clientConnect: import_vitest5.vi.fn().mockReturnValue(true),
-    clientBegin: import_vitest5.vi.fn().mockReturnValue({ index: 1, origin: { x: 0, y: 0, z: 0 } }),
-    clientDisconnect: import_vitest5.vi.fn(),
-    clientThink: import_vitest5.vi.fn(),
-    respawn: import_vitest5.vi.fn(),
-    entities: {
-      getByIndex: import_vitest5.vi.fn(),
-      forEachEntity: import_vitest5.vi.fn(),
-      findByRadius: import_vitest5.vi.fn(),
-      find: import_vitest5.vi.fn(),
-      checkAnyCollision: import_vitest5.vi.fn(),
-      trace: import_vitest5.vi.fn(),
-      pointcontents: import_vitest5.vi.fn(),
-      link: import_vitest5.vi.fn(),
-      unlink: import_vitest5.vi.fn(),
-      spawn: import_vitest5.vi.fn(),
-      free: import_vitest5.vi.fn(),
-      activeCount: 0,
-      world: { classname: "worldspawn" }
-    },
-    multicast: import_vitest5.vi.fn(),
-    unicast: import_vitest5.vi.fn(),
-    configstring: import_vitest5.vi.fn(),
-    serverCommand: import_vitest5.vi.fn(),
-    sound: import_vitest5.vi.fn(),
-    soundIndex: import_vitest5.vi.fn(),
-    centerprintf: import_vitest5.vi.fn(),
-    trace: import_vitest5.vi.fn(),
-    time: 0,
-    deathmatch: false,
-    skill: 1,
-    rogue: false,
-    xatrix: false,
-    coop: false,
-    friendlyFire: false,
-    random: {
-      next: import_vitest5.vi.fn(),
-      nextFloat: import_vitest5.vi.fn(),
-      range: import_vitest5.vi.fn(),
-      crandom: import_vitest5.vi.fn(),
-      getState: import_vitest5.vi.fn(),
-      setState: import_vitest5.vi.fn()
-    },
-    createSave: import_vitest5.vi.fn(),
-    loadSave: import_vitest5.vi.fn(),
-    serialize: import_vitest5.vi.fn(),
-    loadState: import_vitest5.vi.fn(),
-    setGodMode: import_vitest5.vi.fn(),
-    setNoclip: import_vitest5.vi.fn(),
-    setNotarget: import_vitest5.vi.fn(),
-    giveItem: import_vitest5.vi.fn(),
-    damage: import_vitest5.vi.fn(),
-    teleport: import_vitest5.vi.fn(),
-    registerHooks: import_vitest5.vi.fn(),
-    hooks: {
-      onMapLoad: import_vitest5.vi.fn(),
-      onMapUnload: import_vitest5.vi.fn(),
-      onPlayerSpawn: import_vitest5.vi.fn(),
-      onPlayerDeath: import_vitest5.vi.fn(),
-      register: import_vitest5.vi.fn(),
-      onPickup: import_vitest5.vi.fn()
-      // Added onPickup mock
-    },
-    setSpectator: import_vitest5.vi.fn(),
-    registerEntitySpawn: import_vitest5.vi.fn(),
-    unregisterEntitySpawn: import_vitest5.vi.fn(),
-    getCustomEntities: import_vitest5.vi.fn(),
-    ...overrides
-  };
-}
-
 // src/server/mocks/transport.ts
-var import_vitest6 = require("vitest");
+var import_vitest5 = require("vitest");
 var MockTransport = class {
   constructor() {
     this.address = "127.0.0.1";
@@ -1500,11 +1456,11 @@ var MockTransport = class {
     this.sentMessages = [];
     this.receivedMessages = [];
     this.listening = false;
-    this.listenSpy = import_vitest6.vi.fn().mockImplementation(async (port) => {
+    this.listenSpy = import_vitest5.vi.fn().mockImplementation(async (port) => {
       this.port = port;
       this.listening = true;
     });
-    this.closeSpy = import_vitest6.vi.fn().mockImplementation(() => {
+    this.closeSpy = import_vitest5.vi.fn().mockImplementation(() => {
       this.listening = false;
     });
   }
@@ -1560,11 +1516,11 @@ var MockTransport = class {
 };
 function createMockUDPSocket(overrides) {
   const socket = {
-    send: import_vitest6.vi.fn(),
-    on: import_vitest6.vi.fn(),
-    close: import_vitest6.vi.fn(),
-    bind: import_vitest6.vi.fn(),
-    address: import_vitest6.vi.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
+    send: import_vitest5.vi.fn(),
+    on: import_vitest5.vi.fn(),
+    close: import_vitest5.vi.fn(),
+    bind: import_vitest5.vi.fn(),
+    address: import_vitest5.vi.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
     ...overrides
   };
   return socket;
@@ -1581,13 +1537,13 @@ function createMockTransport(address = "127.0.0.1", port = 27910, overrides) {
 }
 function createMockNetDriver(overrides) {
   return {
-    connect: import_vitest6.vi.fn().mockResolvedValue(void 0),
-    disconnect: import_vitest6.vi.fn(),
-    send: import_vitest6.vi.fn(),
-    onMessage: import_vitest6.vi.fn(),
-    onClose: import_vitest6.vi.fn(),
-    onError: import_vitest6.vi.fn(),
-    isConnected: import_vitest6.vi.fn().mockReturnValue(true),
+    connect: import_vitest5.vi.fn().mockResolvedValue(void 0),
+    disconnect: import_vitest5.vi.fn(),
+    send: import_vitest5.vi.fn(),
+    onMessage: import_vitest5.vi.fn(),
+    onClose: import_vitest5.vi.fn(),
+    onError: import_vitest5.vi.fn(),
+    isConnected: import_vitest5.vi.fn().mockReturnValue(true),
     ...overrides
   };
 }
@@ -1632,7 +1588,7 @@ var MockNetworkTransport = class {
 };
 
 // src/server/mockNetDriver.ts
-var import_vitest7 = require("vitest");
+var import_vitest6 = require("vitest");
 var MockNetDriver = class {
   constructor() {
     this.state = {
@@ -1642,14 +1598,14 @@ var MockNetDriver = class {
       closeHandlers: [],
       errorHandlers: []
     };
-    this.connectSpy = import_vitest7.vi.fn().mockImplementation(async (url) => {
+    this.connectSpy = import_vitest6.vi.fn().mockImplementation(async (url) => {
       this.state.connected = true;
     });
-    this.disconnectSpy = import_vitest7.vi.fn().mockImplementation(() => {
+    this.disconnectSpy = import_vitest6.vi.fn().mockImplementation(() => {
       this.state.connected = false;
       this.state.closeHandlers.forEach((h) => h());
     });
-    this.sendSpy = import_vitest7.vi.fn().mockImplementation((data) => {
+    this.sendSpy = import_vitest6.vi.fn().mockImplementation((data) => {
       this.state.messagesSent.push(new Uint8Array(data));
     });
   }
@@ -1711,7 +1667,16 @@ var MockNetDriver = class {
 // src/server/mocks/state.ts
 var import_server = require("@quake2ts/server");
 var import_shared7 = require("@quake2ts/shared");
-var import_vitest8 = require("vitest");
+var import_vitest7 = require("vitest");
+function createMockGameState(overrides) {
+  return {
+    levelName: "test_level",
+    time: 0,
+    entities: [],
+    clients: [],
+    ...overrides
+  };
+}
 function createMockServerState(overrides) {
   return {
     state: import_server.ServerState.Game,
@@ -1753,13 +1718,13 @@ function createMockServerClient(clientNum, overrides) {
       incomingSequence: 0,
       outgoingSequence: 0,
       lastReceived: 0,
-      process: import_vitest8.vi.fn(),
-      transmit: import_vitest8.vi.fn(),
-      writeReliableByte: import_vitest8.vi.fn(),
-      writeReliableShort: import_vitest8.vi.fn(),
-      writeReliableLong: import_vitest8.vi.fn(),
-      writeReliableString: import_vitest8.vi.fn(),
-      writeReliableData: import_vitest8.vi.fn()
+      process: import_vitest7.vi.fn(),
+      transmit: import_vitest7.vi.fn(),
+      writeReliableByte: import_vitest7.vi.fn(),
+      writeReliableShort: import_vitest7.vi.fn(),
+      writeReliableLong: import_vitest7.vi.fn(),
+      writeReliableString: import_vitest7.vi.fn(),
+      writeReliableData: import_vitest7.vi.fn()
     },
     // Cast as any because NetChan might be complex to fully mock here
     userInfo: "",
@@ -1801,16 +1766,16 @@ function createMockServerClient(clientNum, overrides) {
 }
 function createMockServer(overrides) {
   return {
-    start: import_vitest8.vi.fn().mockResolvedValue(void 0),
-    stop: import_vitest8.vi.fn(),
-    multicast: import_vitest8.vi.fn(),
-    unicast: import_vitest8.vi.fn(),
-    configstring: import_vitest8.vi.fn(),
-    kickPlayer: import_vitest8.vi.fn(),
-    changeMap: import_vitest8.vi.fn().mockResolvedValue(void 0),
-    getClient: import_vitest8.vi.fn().mockReturnValue(null),
-    broadcast: import_vitest8.vi.fn(),
-    tick: import_vitest8.vi.fn(),
+    start: import_vitest7.vi.fn().mockResolvedValue(void 0),
+    stop: import_vitest7.vi.fn(),
+    multicast: import_vitest7.vi.fn(),
+    unicast: import_vitest7.vi.fn(),
+    configstring: import_vitest7.vi.fn(),
+    kickPlayer: import_vitest7.vi.fn(),
+    changeMap: import_vitest7.vi.fn().mockResolvedValue(void 0),
+    getClient: import_vitest7.vi.fn().mockReturnValue(null),
+    broadcast: import_vitest7.vi.fn(),
+    tick: import_vitest7.vi.fn(),
     ...overrides
   };
 }
@@ -1872,19 +1837,19 @@ async function simulateHandshake(client, server) {
 }
 
 // src/server/mocks/commands.ts
-var import_vitest9 = require("vitest");
+var import_vitest8 = require("vitest");
 function createMockServerConsole(overrides) {
   const outputBuffer = [];
   const commandBuffer = [];
   return {
-    exec: import_vitest9.vi.fn((cmd) => {
+    exec: import_vitest8.vi.fn((cmd) => {
       commandBuffer.push(cmd);
       return `Executed: ${cmd}`;
     }),
-    print: import_vitest9.vi.fn((text) => {
+    print: import_vitest8.vi.fn((text) => {
       outputBuffer.push(text);
     }),
-    broadcast: import_vitest9.vi.fn((text) => {
+    broadcast: import_vitest8.vi.fn((text) => {
       outputBuffer.push(`Broadcast: ${text}`);
     }),
     commandBuffer,
@@ -1897,13 +1862,13 @@ function createMockRConClient(password = "") {
     connected: false,
     lastCommand: "",
     lastResponse: "",
-    connect: import_vitest9.vi.fn(async (address, port, pwd) => {
+    connect: import_vitest8.vi.fn(async (address, port, pwd) => {
       return pwd === password;
     }),
-    sendCommand: import_vitest9.vi.fn(async (cmd) => {
+    sendCommand: import_vitest8.vi.fn(async (cmd) => {
       return `RCON Response for: ${cmd}`;
     }),
-    disconnect: import_vitest9.vi.fn()
+    disconnect: import_vitest8.vi.fn()
   };
 }
 function simulateServerCommand(server, command) {
@@ -1972,19 +1937,19 @@ async function simulateServerRegistration(server, master) {
 }
 
 // src/server/mocks/physics.ts
-var import_vitest10 = require("vitest");
+var import_vitest9 = require("vitest");
 function createMockCollisionEntityIndex(overrides) {
   return {
-    trace: import_vitest10.vi.fn().mockReturnValue({
+    trace: import_vitest9.vi.fn().mockReturnValue({
       fraction: 1,
       allsolid: false,
       startsolid: false,
       endpos: { x: 0, y: 0, z: 0 },
       entityId: null
     }),
-    link: import_vitest10.vi.fn(),
-    unlink: import_vitest10.vi.fn(),
-    gatherTriggerTouches: import_vitest10.vi.fn().mockReturnValue([]),
+    link: import_vitest9.vi.fn(),
+    unlink: import_vitest9.vi.fn(),
+    gatherTriggerTouches: import_vitest9.vi.fn().mockReturnValue([]),
     ...overrides
   };
 }
@@ -2480,7 +2445,7 @@ function createInputInjector(target) {
 }
 
 // src/engine/mocks/webgl.ts
-var import_vitest11 = require("vitest");
+var import_vitest10 = require("vitest");
 var MockWebGL2RenderingContext = class {
   constructor(canvas) {
     this.ARRAY_BUFFER = 34962;
@@ -2539,139 +2504,139 @@ var MockWebGL2RenderingContext = class {
     this.calls = [];
     this.uniformLocations = /* @__PURE__ */ new Map();
     this.attributeLocations = /* @__PURE__ */ new Map();
-    this.enable = import_vitest11.vi.fn((cap) => this.calls.push(`enable:${cap}`));
-    this.disable = import_vitest11.vi.fn((cap) => this.calls.push(`disable:${cap}`));
-    this.depthFunc = import_vitest11.vi.fn((func) => this.calls.push(`depthFunc:${func}`));
-    this.cullFace = import_vitest11.vi.fn((mode) => this.calls.push(`cullFace:${mode}`));
-    this.depthMask = import_vitest11.vi.fn((flag) => this.calls.push(`depthMask:${flag}`));
-    this.blendFuncSeparate = import_vitest11.vi.fn(
+    this.enable = import_vitest10.vi.fn((cap) => this.calls.push(`enable:${cap}`));
+    this.disable = import_vitest10.vi.fn((cap) => this.calls.push(`disable:${cap}`));
+    this.depthFunc = import_vitest10.vi.fn((func) => this.calls.push(`depthFunc:${func}`));
+    this.cullFace = import_vitest10.vi.fn((mode) => this.calls.push(`cullFace:${mode}`));
+    this.depthMask = import_vitest10.vi.fn((flag) => this.calls.push(`depthMask:${flag}`));
+    this.blendFuncSeparate = import_vitest10.vi.fn(
       (srcRGB, dstRGB, srcAlpha, dstAlpha) => this.calls.push(`blendFuncSeparate:${srcRGB}:${dstRGB}:${srcAlpha}:${dstAlpha}`)
     );
-    this.blendFunc = import_vitest11.vi.fn((sfactor, dfactor) => this.calls.push(`blendFunc:${sfactor}:${dfactor}`));
-    this.getExtension = import_vitest11.vi.fn((name) => this.extensions.get(name) ?? null);
-    this.viewport = import_vitest11.vi.fn((x, y, w, h) => this.calls.push(`viewport:${x}:${y}:${w}:${h}`));
-    this.clear = import_vitest11.vi.fn((mask) => this.calls.push(`clear:${mask}`));
-    this.clearColor = import_vitest11.vi.fn((r, g, b, a) => this.calls.push(`clearColor:${r}:${g}:${b}:${a}`));
-    this.createShader = import_vitest11.vi.fn((type) => ({ id: ++this.shaderCounter, type }));
-    this.shaderSource = import_vitest11.vi.fn((shader, source) => this.calls.push(`shaderSource:${shader.id}:${source}`));
-    this.compileShader = import_vitest11.vi.fn((shader) => this.calls.push(`compileShader:${shader.id}`));
-    this.getShaderParameter = import_vitest11.vi.fn(
+    this.blendFunc = import_vitest10.vi.fn((sfactor, dfactor) => this.calls.push(`blendFunc:${sfactor}:${dfactor}`));
+    this.getExtension = import_vitest10.vi.fn((name) => this.extensions.get(name) ?? null);
+    this.viewport = import_vitest10.vi.fn((x, y, w, h) => this.calls.push(`viewport:${x}:${y}:${w}:${h}`));
+    this.clear = import_vitest10.vi.fn((mask) => this.calls.push(`clear:${mask}`));
+    this.clearColor = import_vitest10.vi.fn((r, g, b, a) => this.calls.push(`clearColor:${r}:${g}:${b}:${a}`));
+    this.createShader = import_vitest10.vi.fn((type) => ({ id: ++this.shaderCounter, type }));
+    this.shaderSource = import_vitest10.vi.fn((shader, source) => this.calls.push(`shaderSource:${shader.id}:${source}`));
+    this.compileShader = import_vitest10.vi.fn((shader) => this.calls.push(`compileShader:${shader.id}`));
+    this.getShaderParameter = import_vitest10.vi.fn(
       (shader, pname) => pname === this.COMPILE_STATUS ? this.compileSucceeds : null
     );
-    this.getShaderInfoLog = import_vitest11.vi.fn(() => this.compileSucceeds ? "" : this.shaderInfoLog);
-    this.deleteShader = import_vitest11.vi.fn((shader) => this.calls.push(`deleteShader:${shader.id}`));
-    this.createProgram = import_vitest11.vi.fn(() => ({ id: ++this.programCounter }));
-    this.attachShader = import_vitest11.vi.fn(
+    this.getShaderInfoLog = import_vitest10.vi.fn(() => this.compileSucceeds ? "" : this.shaderInfoLog);
+    this.deleteShader = import_vitest10.vi.fn((shader) => this.calls.push(`deleteShader:${shader.id}`));
+    this.createProgram = import_vitest10.vi.fn(() => ({ id: ++this.programCounter }));
+    this.attachShader = import_vitest10.vi.fn(
       (program, shader) => this.calls.push(`attach:${program.id}:${shader.id}`)
     );
-    this.bindAttribLocation = import_vitest11.vi.fn(
+    this.bindAttribLocation = import_vitest10.vi.fn(
       (program, index, name) => this.calls.push(`bindAttribLocation:${program.id}:${index}:${name}`)
     );
-    this.linkProgram = import_vitest11.vi.fn((program) => this.calls.push(`link:${program.id}`));
-    this.getProgramParameter = import_vitest11.vi.fn(
+    this.linkProgram = import_vitest10.vi.fn((program) => this.calls.push(`link:${program.id}`));
+    this.getProgramParameter = import_vitest10.vi.fn(
       (program, pname) => pname === this.LINK_STATUS ? this.linkSucceeds : null
     );
-    this.getProgramInfoLog = import_vitest11.vi.fn(() => this.linkSucceeds ? "" : this.programInfoLog);
-    this.deleteProgram = import_vitest11.vi.fn((program) => this.calls.push(`deleteProgram:${program.id}`));
-    this.useProgram = import_vitest11.vi.fn((program) => this.calls.push(`useProgram:${program?.id ?? "null"}`));
-    this.getUniformLocation = import_vitest11.vi.fn((program, name) => {
+    this.getProgramInfoLog = import_vitest10.vi.fn(() => this.linkSucceeds ? "" : this.programInfoLog);
+    this.deleteProgram = import_vitest10.vi.fn((program) => this.calls.push(`deleteProgram:${program.id}`));
+    this.useProgram = import_vitest10.vi.fn((program) => this.calls.push(`useProgram:${program?.id ?? "null"}`));
+    this.getUniformLocation = import_vitest10.vi.fn((program, name) => {
       this.calls.push(`getUniformLocation:${program.id}:${name}`);
       return this.uniformLocations.get(name) ?? null;
     });
-    this.getAttribLocation = import_vitest11.vi.fn((program, name) => {
+    this.getAttribLocation = import_vitest10.vi.fn((program, name) => {
       this.calls.push(`getAttribLocation:${program.id}:${name}`);
       return this.attributeLocations.get(name) ?? -1;
     });
-    this.createBuffer = import_vitest11.vi.fn(() => ({ buffer: {} }));
-    this.bindBuffer = import_vitest11.vi.fn((target, buffer) => this.calls.push(`bindBuffer:${target}:${!!buffer}`));
-    this.bufferData = import_vitest11.vi.fn(
+    this.createBuffer = import_vitest10.vi.fn(() => ({ buffer: {} }));
+    this.bindBuffer = import_vitest10.vi.fn((target, buffer) => this.calls.push(`bindBuffer:${target}:${!!buffer}`));
+    this.bufferData = import_vitest10.vi.fn(
       (target, data, usage) => this.calls.push(`bufferData:${target}:${usage}:${typeof data === "number" ? data : "data"}`)
     );
-    this.bufferSubData = import_vitest11.vi.fn(
+    this.bufferSubData = import_vitest10.vi.fn(
       (target, offset, data) => this.calls.push(`bufferSubData:${target}:${offset}:${data.byteLength ?? "len"}`)
     );
-    this.deleteBuffer = import_vitest11.vi.fn((buffer) => this.calls.push(`deleteBuffer:${!!buffer}`));
-    this.createVertexArray = import_vitest11.vi.fn(() => ({ vao: {} }));
-    this.bindVertexArray = import_vitest11.vi.fn((vao) => this.calls.push(`bindVertexArray:${!!vao}`));
-    this.enableVertexAttribArray = import_vitest11.vi.fn((index) => this.calls.push(`enableAttrib:${index}`));
-    this.vertexAttribPointer = import_vitest11.vi.fn(
+    this.deleteBuffer = import_vitest10.vi.fn((buffer) => this.calls.push(`deleteBuffer:${!!buffer}`));
+    this.createVertexArray = import_vitest10.vi.fn(() => ({ vao: {} }));
+    this.bindVertexArray = import_vitest10.vi.fn((vao) => this.calls.push(`bindVertexArray:${!!vao}`));
+    this.enableVertexAttribArray = import_vitest10.vi.fn((index) => this.calls.push(`enableAttrib:${index}`));
+    this.vertexAttribPointer = import_vitest10.vi.fn(
       (index, size, type, normalized, stride, offset) => this.calls.push(`vertexAttribPointer:${index}:${size}:${type}:${normalized}:${stride}:${offset}`)
     );
-    this.vertexAttribDivisor = import_vitest11.vi.fn((index, divisor) => this.calls.push(`divisor:${index}:${divisor}`));
-    this.deleteVertexArray = import_vitest11.vi.fn((vao) => this.calls.push(`deleteVertexArray:${!!vao}`));
-    this.createTexture = import_vitest11.vi.fn(() => ({ texture: {} }));
-    this.activeTexture = import_vitest11.vi.fn((unit) => this.calls.push(`activeTexture:${unit}`));
-    this.bindTexture = import_vitest11.vi.fn((target, texture) => this.calls.push(`bindTexture:${target}:${!!texture}`));
-    this.texParameteri = import_vitest11.vi.fn(
+    this.vertexAttribDivisor = import_vitest10.vi.fn((index, divisor) => this.calls.push(`divisor:${index}:${divisor}`));
+    this.deleteVertexArray = import_vitest10.vi.fn((vao) => this.calls.push(`deleteVertexArray:${!!vao}`));
+    this.createTexture = import_vitest10.vi.fn(() => ({ texture: {} }));
+    this.activeTexture = import_vitest10.vi.fn((unit) => this.calls.push(`activeTexture:${unit}`));
+    this.bindTexture = import_vitest10.vi.fn((target, texture) => this.calls.push(`bindTexture:${target}:${!!texture}`));
+    this.texParameteri = import_vitest10.vi.fn(
       (target, pname, param) => this.calls.push(`texParameteri:${target}:${pname}:${param}`)
     );
-    this.texImage2D = import_vitest11.vi.fn(
+    this.texImage2D = import_vitest10.vi.fn(
       (target, level, internalFormat, width, height, border, format, type, pixels) => this.calls.push(
         `texImage2D:${target}:${level}:${internalFormat}:${width}:${height}:${border}:${format}:${type}:${pixels ? "data" : "null"}`
       )
     );
-    this.texImage3D = import_vitest11.vi.fn();
+    this.texImage3D = import_vitest10.vi.fn();
     // Stub for compatibility
-    this.deleteTexture = import_vitest11.vi.fn((texture) => this.calls.push(`deleteTexture:${!!texture}`));
-    this.createFramebuffer = import_vitest11.vi.fn(() => ({ fb: {} }));
-    this.bindFramebuffer = import_vitest11.vi.fn(
+    this.deleteTexture = import_vitest10.vi.fn((texture) => this.calls.push(`deleteTexture:${!!texture}`));
+    this.createFramebuffer = import_vitest10.vi.fn(() => ({ fb: {} }));
+    this.bindFramebuffer = import_vitest10.vi.fn(
       (target, framebuffer) => this.calls.push(`bindFramebuffer:${target}:${!!framebuffer}`)
     );
-    this.framebufferTexture2D = import_vitest11.vi.fn(
+    this.framebufferTexture2D = import_vitest10.vi.fn(
       (target, attachment, textarget, texture, level) => this.calls.push(`framebufferTexture2D:${target}:${attachment}:${textarget}:${!!texture}:${level}`)
     );
-    this.deleteFramebuffer = import_vitest11.vi.fn((fb) => this.calls.push(`deleteFramebuffer:${!!fb}`));
-    this.checkFramebufferStatus = import_vitest11.vi.fn((target) => this.FRAMEBUFFER_COMPLETE);
-    this.createRenderbuffer = import_vitest11.vi.fn(() => ({ rb: {} }));
-    this.bindRenderbuffer = import_vitest11.vi.fn(
+    this.deleteFramebuffer = import_vitest10.vi.fn((fb) => this.calls.push(`deleteFramebuffer:${!!fb}`));
+    this.checkFramebufferStatus = import_vitest10.vi.fn((target) => this.FRAMEBUFFER_COMPLETE);
+    this.createRenderbuffer = import_vitest10.vi.fn(() => ({ rb: {} }));
+    this.bindRenderbuffer = import_vitest10.vi.fn(
       (target, renderbuffer) => this.calls.push(`bindRenderbuffer:${target}:${!!renderbuffer}`)
     );
-    this.renderbufferStorage = import_vitest11.vi.fn(
+    this.renderbufferStorage = import_vitest10.vi.fn(
       (target, internalformat, width, height) => this.calls.push(`renderbufferStorage:${target}:${internalformat}:${width}:${height}`)
     );
-    this.framebufferRenderbuffer = import_vitest11.vi.fn(
+    this.framebufferRenderbuffer = import_vitest10.vi.fn(
       (target, attachment, renderbuffertarget, renderbuffer) => this.calls.push(`framebufferRenderbuffer:${target}:${attachment}:${renderbuffertarget}:${!!renderbuffer}`)
     );
-    this.deleteRenderbuffer = import_vitest11.vi.fn((rb) => this.calls.push(`deleteRenderbuffer:${!!rb}`));
-    this.drawArrays = import_vitest11.vi.fn(
+    this.deleteRenderbuffer = import_vitest10.vi.fn((rb) => this.calls.push(`deleteRenderbuffer:${!!rb}`));
+    this.drawArrays = import_vitest10.vi.fn(
       (mode, first, count) => this.calls.push(`drawArrays:${mode}:${first}:${count}`)
     );
-    this.drawElements = import_vitest11.vi.fn(
+    this.drawElements = import_vitest10.vi.fn(
       (mode, count, type, offset) => this.calls.push(`drawElements:${mode}:${count}:${type}:${offset}`)
     );
     // Queries
-    this.createQuery = import_vitest11.vi.fn(() => ({}));
-    this.beginQuery = import_vitest11.vi.fn();
-    this.endQuery = import_vitest11.vi.fn();
-    this.deleteQuery = import_vitest11.vi.fn();
-    this.getQueryParameter = import_vitest11.vi.fn();
-    this.getParameter = import_vitest11.vi.fn();
-    this.uniform1f = import_vitest11.vi.fn(
+    this.createQuery = import_vitest10.vi.fn(() => ({}));
+    this.beginQuery = import_vitest10.vi.fn();
+    this.endQuery = import_vitest10.vi.fn();
+    this.deleteQuery = import_vitest10.vi.fn();
+    this.getQueryParameter = import_vitest10.vi.fn();
+    this.getParameter = import_vitest10.vi.fn();
+    this.uniform1f = import_vitest10.vi.fn(
       (location, x) => this.calls.push(`uniform1f:${location ? "set" : "null"}:${x}`)
     );
-    this.uniform1i = import_vitest11.vi.fn(
+    this.uniform1i = import_vitest10.vi.fn(
       (location, x) => this.calls.push(`uniform1i:${location ? "set" : "null"}:${x}`)
     );
-    this.uniform4f = import_vitest11.vi.fn(
+    this.uniform4f = import_vitest10.vi.fn(
       (location, x, y, z, w) => this.calls.push(`uniform4f:${location ? "set" : "null"}:${x}:${y}:${z}:${w}`)
     );
-    this.uniform3fv = import_vitest11.vi.fn(
+    this.uniform3fv = import_vitest10.vi.fn(
       (location, data) => this.calls.push(`uniform3fv:${location ? "set" : "null"}:${Array.from(data).join(",")}`)
     );
-    this.uniform3f = import_vitest11.vi.fn(
+    this.uniform3f = import_vitest10.vi.fn(
       (location, x, y, z) => this.calls.push(`uniform3f:${location ? "set" : "null"}:${x}:${y}:${z}`)
     );
-    this.uniform2f = import_vitest11.vi.fn(
+    this.uniform2f = import_vitest10.vi.fn(
       (location, x, y) => this.calls.push(`uniform2f:${location ? "set" : "null"}:${x}:${y}`)
     );
-    this.uniform4fv = import_vitest11.vi.fn(
+    this.uniform4fv = import_vitest10.vi.fn(
       (location, data) => this.calls.push(`uniform4fv:${location ? "set" : "null"}:${Array.from(data).join(",")}`)
     );
-    this.uniformMatrix4fv = import_vitest11.vi.fn(
+    this.uniformMatrix4fv = import_vitest10.vi.fn(
       (location, transpose, data) => this.calls.push(`uniformMatrix4fv:${location ? "set" : "null"}:${transpose}:${Array.from(data).join(",")}`)
     );
-    this.uniformBlockBinding = import_vitest11.vi.fn();
-    this.isContextLost = import_vitest11.vi.fn(() => false);
+    this.uniformBlockBinding = import_vitest10.vi.fn();
+    this.isContextLost = import_vitest10.vi.fn(() => false);
     if (canvas) {
       this.canvas = canvas;
       this.drawingBufferWidth = canvas.width;
@@ -3031,13 +2996,13 @@ async function createHeadlessTestContext() {
 }
 
 // src/engine/mocks/webgpu.ts
-var import_vitest12 = require("vitest");
+var import_vitest11 = require("vitest");
 var import_webgpu = require("webgpu");
 function setupWebGPUMocks() {
   Object.assign(globalThis, import_webgpu.globals);
   const mockGpu = {
-    requestAdapter: import_vitest12.vi.fn(),
-    getPreferredCanvasFormat: import_vitest12.vi.fn().mockReturnValue("bgra8unorm")
+    requestAdapter: import_vitest11.vi.fn(),
+    getPreferredCanvasFormat: import_vitest11.vi.fn().mockReturnValue("bgra8unorm")
   };
   const mockAdapter = createMockGPUAdapter();
   const mockDevice = createMockGPUDevice();
@@ -3066,8 +3031,8 @@ function createMockGPUAdapter(options = {}) {
     features: /* @__PURE__ */ new Set(),
     limits: {},
     isFallbackAdapter: false,
-    requestDevice: import_vitest12.vi.fn().mockResolvedValue(createMockGPUDevice()),
-    requestAdapterInfo: import_vitest12.vi.fn().mockResolvedValue({}),
+    requestDevice: import_vitest11.vi.fn().mockResolvedValue(createMockGPUDevice()),
+    requestAdapterInfo: import_vitest11.vi.fn().mockResolvedValue({}),
     ...options
   };
 }
@@ -3077,25 +3042,25 @@ function createMockGPUDevice(features = /* @__PURE__ */ new Set()) {
     features,
     limits: {},
     queue,
-    destroy: import_vitest12.vi.fn(),
-    createBuffer: import_vitest12.vi.fn((descriptor) => createMockGPUBuffer(descriptor)),
-    createTexture: import_vitest12.vi.fn((descriptor) => createMockGPUTexture(descriptor)),
-    createSampler: import_vitest12.vi.fn(() => createMockSampler()),
-    createBindGroupLayout: import_vitest12.vi.fn(() => ({ label: "mock-bind-group-layout" })),
-    createPipelineLayout: import_vitest12.vi.fn(() => ({ label: "mock-pipeline-layout" })),
-    createBindGroup: import_vitest12.vi.fn(() => ({ label: "mock-bind-group" })),
-    createShaderModule: import_vitest12.vi.fn((descriptor) => createMockShaderModule(descriptor)),
-    createComputePipeline: import_vitest12.vi.fn(() => createMockComputePipeline()),
-    createRenderPipeline: import_vitest12.vi.fn(() => createMockRenderPipeline()),
-    createComputePipelineAsync: import_vitest12.vi.fn().mockResolvedValue(createMockComputePipeline()),
-    createRenderPipelineAsync: import_vitest12.vi.fn().mockResolvedValue(createMockRenderPipeline()),
-    createCommandEncoder: import_vitest12.vi.fn(() => createMockCommandEncoder()),
-    createQuerySet: import_vitest12.vi.fn(() => ({ label: "mock-query-set" })),
-    pushErrorScope: import_vitest12.vi.fn(),
-    popErrorScope: import_vitest12.vi.fn().mockResolvedValue(null),
-    addEventListener: import_vitest12.vi.fn(),
-    removeEventListener: import_vitest12.vi.fn(),
-    dispatchEvent: import_vitest12.vi.fn(),
+    destroy: import_vitest11.vi.fn(),
+    createBuffer: import_vitest11.vi.fn((descriptor) => createMockGPUBuffer(descriptor)),
+    createTexture: import_vitest11.vi.fn((descriptor) => createMockGPUTexture(descriptor)),
+    createSampler: import_vitest11.vi.fn(() => createMockSampler()),
+    createBindGroupLayout: import_vitest11.vi.fn(() => ({ label: "mock-bind-group-layout" })),
+    createPipelineLayout: import_vitest11.vi.fn(() => ({ label: "mock-pipeline-layout" })),
+    createBindGroup: import_vitest11.vi.fn(() => ({ label: "mock-bind-group" })),
+    createShaderModule: import_vitest11.vi.fn((descriptor) => createMockShaderModule(descriptor)),
+    createComputePipeline: import_vitest11.vi.fn(() => createMockComputePipeline()),
+    createRenderPipeline: import_vitest11.vi.fn(() => createMockRenderPipeline()),
+    createComputePipelineAsync: import_vitest11.vi.fn().mockResolvedValue(createMockComputePipeline()),
+    createRenderPipelineAsync: import_vitest11.vi.fn().mockResolvedValue(createMockRenderPipeline()),
+    createCommandEncoder: import_vitest11.vi.fn(() => createMockCommandEncoder()),
+    createQuerySet: import_vitest11.vi.fn(() => ({ label: "mock-query-set" })),
+    pushErrorScope: import_vitest11.vi.fn(),
+    popErrorScope: import_vitest11.vi.fn().mockResolvedValue(null),
+    addEventListener: import_vitest11.vi.fn(),
+    removeEventListener: import_vitest11.vi.fn(),
+    dispatchEvent: import_vitest11.vi.fn(),
     onuncapturederror: null,
     label: "",
     lost: Promise.resolve({ reason: "destroyed", message: "Device lost" })
@@ -3103,11 +3068,11 @@ function createMockGPUDevice(features = /* @__PURE__ */ new Set()) {
 }
 function createMockQueue() {
   return {
-    submit: import_vitest12.vi.fn(),
-    onSubmittedWorkDone: import_vitest12.vi.fn().mockResolvedValue(void 0),
-    writeBuffer: import_vitest12.vi.fn(),
-    writeTexture: import_vitest12.vi.fn(),
-    copyExternalImageToTexture: import_vitest12.vi.fn(),
+    submit: import_vitest11.vi.fn(),
+    onSubmittedWorkDone: import_vitest11.vi.fn().mockResolvedValue(void 0),
+    writeBuffer: import_vitest11.vi.fn(),
+    writeTexture: import_vitest11.vi.fn(),
+    copyExternalImageToTexture: import_vitest11.vi.fn(),
     label: ""
   };
 }
@@ -3116,10 +3081,10 @@ function createMockGPUBuffer(descriptor) {
     size: descriptor.size,
     usage: descriptor.usage,
     mapState: "unmapped",
-    mapAsync: import_vitest12.vi.fn().mockResolvedValue(void 0),
-    getMappedRange: import_vitest12.vi.fn(() => new ArrayBuffer(descriptor.size)),
-    unmap: import_vitest12.vi.fn(),
-    destroy: import_vitest12.vi.fn(),
+    mapAsync: import_vitest11.vi.fn().mockResolvedValue(void 0),
+    getMappedRange: import_vitest11.vi.fn(() => new ArrayBuffer(descriptor.size)),
+    unmap: import_vitest11.vi.fn(),
+    destroy: import_vitest11.vi.fn(),
     label: descriptor.label || ""
   };
 }
@@ -3148,8 +3113,8 @@ function createMockGPUTexture(descriptor) {
     dimension: descriptor.dimension || "2d",
     format: descriptor.format,
     usage: descriptor.usage,
-    createView: import_vitest12.vi.fn(() => createMockTextureView()),
-    destroy: import_vitest12.vi.fn(),
+    createView: import_vitest11.vi.fn(() => createMockTextureView()),
+    destroy: import_vitest11.vi.fn(),
     label: descriptor.label || ""
   };
 }
@@ -3165,74 +3130,74 @@ function createMockSampler() {
 }
 function createMockShaderModule(descriptor) {
   return {
-    getCompilationInfo: import_vitest12.vi.fn().mockResolvedValue({ messages: [] }),
+    getCompilationInfo: import_vitest11.vi.fn().mockResolvedValue({ messages: [] }),
     label: descriptor.label || ""
   };
 }
 function createMockComputePipeline() {
   return {
-    getBindGroupLayout: import_vitest12.vi.fn(() => ({ label: "mock-bind-group-layout" })),
+    getBindGroupLayout: import_vitest11.vi.fn(() => ({ label: "mock-bind-group-layout" })),
     label: ""
   };
 }
 function createMockRenderPipeline() {
   return {
-    getBindGroupLayout: import_vitest12.vi.fn(() => ({ label: "mock-bind-group-layout" })),
+    getBindGroupLayout: import_vitest11.vi.fn(() => ({ label: "mock-bind-group-layout" })),
     label: ""
   };
 }
 function createMockCommandEncoder() {
   return {
-    beginRenderPass: import_vitest12.vi.fn(() => createMockRenderPassEncoder()),
-    beginComputePass: import_vitest12.vi.fn(() => createMockComputePassEncoder()),
-    copyBufferToBuffer: import_vitest12.vi.fn(),
-    copyBufferToTexture: import_vitest12.vi.fn(),
-    copyTextureToBuffer: import_vitest12.vi.fn(),
-    copyTextureToTexture: import_vitest12.vi.fn(),
-    clearBuffer: import_vitest12.vi.fn(),
-    writeTimestamp: import_vitest12.vi.fn(),
-    resolveQuerySet: import_vitest12.vi.fn(),
-    finish: import_vitest12.vi.fn(() => ({ label: "mock-command-buffer" })),
-    pushDebugGroup: import_vitest12.vi.fn(),
-    popDebugGroup: import_vitest12.vi.fn(),
-    insertDebugMarker: import_vitest12.vi.fn(),
+    beginRenderPass: import_vitest11.vi.fn(() => createMockRenderPassEncoder()),
+    beginComputePass: import_vitest11.vi.fn(() => createMockComputePassEncoder()),
+    copyBufferToBuffer: import_vitest11.vi.fn(),
+    copyBufferToTexture: import_vitest11.vi.fn(),
+    copyTextureToBuffer: import_vitest11.vi.fn(),
+    copyTextureToTexture: import_vitest11.vi.fn(),
+    clearBuffer: import_vitest11.vi.fn(),
+    writeTimestamp: import_vitest11.vi.fn(),
+    resolveQuerySet: import_vitest11.vi.fn(),
+    finish: import_vitest11.vi.fn(() => ({ label: "mock-command-buffer" })),
+    pushDebugGroup: import_vitest11.vi.fn(),
+    popDebugGroup: import_vitest11.vi.fn(),
+    insertDebugMarker: import_vitest11.vi.fn(),
     label: ""
   };
 }
 function createMockRenderPassEncoder() {
   return {
-    setPipeline: import_vitest12.vi.fn(),
-    setIndexBuffer: import_vitest12.vi.fn(),
-    setVertexBuffer: import_vitest12.vi.fn(),
-    setBindGroup: import_vitest12.vi.fn(),
-    setViewport: import_vitest12.vi.fn(),
-    setScissorRect: import_vitest12.vi.fn(),
-    setBlendConstant: import_vitest12.vi.fn(),
-    setStencilReference: import_vitest12.vi.fn(),
-    beginOcclusionQuery: import_vitest12.vi.fn(),
-    endOcclusionQuery: import_vitest12.vi.fn(),
-    executeBundles: import_vitest12.vi.fn(),
-    draw: import_vitest12.vi.fn(),
-    drawIndexed: import_vitest12.vi.fn(),
-    drawIndirect: import_vitest12.vi.fn(),
-    drawIndexedIndirect: import_vitest12.vi.fn(),
-    end: import_vitest12.vi.fn(),
-    pushDebugGroup: import_vitest12.vi.fn(),
-    popDebugGroup: import_vitest12.vi.fn(),
-    insertDebugMarker: import_vitest12.vi.fn(),
+    setPipeline: import_vitest11.vi.fn(),
+    setIndexBuffer: import_vitest11.vi.fn(),
+    setVertexBuffer: import_vitest11.vi.fn(),
+    setBindGroup: import_vitest11.vi.fn(),
+    setViewport: import_vitest11.vi.fn(),
+    setScissorRect: import_vitest11.vi.fn(),
+    setBlendConstant: import_vitest11.vi.fn(),
+    setStencilReference: import_vitest11.vi.fn(),
+    beginOcclusionQuery: import_vitest11.vi.fn(),
+    endOcclusionQuery: import_vitest11.vi.fn(),
+    executeBundles: import_vitest11.vi.fn(),
+    draw: import_vitest11.vi.fn(),
+    drawIndexed: import_vitest11.vi.fn(),
+    drawIndirect: import_vitest11.vi.fn(),
+    drawIndexedIndirect: import_vitest11.vi.fn(),
+    end: import_vitest11.vi.fn(),
+    pushDebugGroup: import_vitest11.vi.fn(),
+    popDebugGroup: import_vitest11.vi.fn(),
+    insertDebugMarker: import_vitest11.vi.fn(),
     label: ""
   };
 }
 function createMockComputePassEncoder() {
   return {
-    setPipeline: import_vitest12.vi.fn(),
-    setBindGroup: import_vitest12.vi.fn(),
-    dispatchWorkgroups: import_vitest12.vi.fn(),
-    dispatchWorkgroupsIndirect: import_vitest12.vi.fn(),
-    end: import_vitest12.vi.fn(),
-    pushDebugGroup: import_vitest12.vi.fn(),
-    popDebugGroup: import_vitest12.vi.fn(),
-    insertDebugMarker: import_vitest12.vi.fn(),
+    setPipeline: import_vitest11.vi.fn(),
+    setBindGroup: import_vitest11.vi.fn(),
+    dispatchWorkgroups: import_vitest11.vi.fn(),
+    dispatchWorkgroupsIndirect: import_vitest11.vi.fn(),
+    end: import_vitest11.vi.fn(),
+    pushDebugGroup: import_vitest11.vi.fn(),
+    popDebugGroup: import_vitest11.vi.fn(),
+    insertDebugMarker: import_vitest11.vi.fn(),
     label: ""
   };
 }
@@ -3459,67 +3424,67 @@ var createMockBufferSource = (buffer) => {
 };
 
 // src/engine/mocks/renderer.ts
-var import_vitest13 = require("vitest");
+var import_vitest12 = require("vitest");
 function createMockRenderer(overrides) {
   return {
     width: 800,
     height: 600,
     collisionVis: {
-      render: import_vitest13.vi.fn(),
-      clear: import_vitest13.vi.fn(),
+      render: import_vitest12.vi.fn(),
+      clear: import_vitest12.vi.fn(),
       shaderSize: 0,
-      dispose: import_vitest13.vi.fn()
+      dispose: import_vitest12.vi.fn()
     },
     debug: {
-      render: import_vitest13.vi.fn(),
-      clear: import_vitest13.vi.fn(),
-      drawLine: import_vitest13.vi.fn(),
-      drawBoundingBox: import_vitest13.vi.fn(),
-      drawAxes: import_vitest13.vi.fn(),
-      getLabels: import_vitest13.vi.fn().mockReturnValue([]),
+      render: import_vitest12.vi.fn(),
+      clear: import_vitest12.vi.fn(),
+      drawLine: import_vitest12.vi.fn(),
+      drawBoundingBox: import_vitest12.vi.fn(),
+      drawAxes: import_vitest12.vi.fn(),
+      getLabels: import_vitest12.vi.fn().mockReturnValue([]),
       shaderSize: 0,
-      dispose: import_vitest13.vi.fn()
+      dispose: import_vitest12.vi.fn()
     },
     particleSystem: {
-      update: import_vitest13.vi.fn(),
-      emit: import_vitest13.vi.fn(),
-      clear: import_vitest13.vi.fn(),
+      update: import_vitest12.vi.fn(),
+      emit: import_vitest12.vi.fn(),
+      clear: import_vitest12.vi.fn(),
       count: 0
     },
-    getPerformanceReport: import_vitest13.vi.fn().mockReturnValue({}),
-    getMemoryUsage: import_vitest13.vi.fn().mockReturnValue({}),
-    renderFrame: import_vitest13.vi.fn(),
-    registerPic: import_vitest13.vi.fn().mockResolvedValue({}),
-    registerTexture: import_vitest13.vi.fn().mockReturnValue({}),
-    begin2D: import_vitest13.vi.fn(),
-    end2D: import_vitest13.vi.fn(),
-    drawPic: import_vitest13.vi.fn(),
-    drawString: import_vitest13.vi.fn(),
-    drawCenterString: import_vitest13.vi.fn(),
-    drawfillRect: import_vitest13.vi.fn(),
-    setEntityHighlight: import_vitest13.vi.fn(),
-    clearEntityHighlight: import_vitest13.vi.fn(),
-    highlightSurface: import_vitest13.vi.fn(),
-    removeSurfaceHighlight: import_vitest13.vi.fn(),
-    setDebugMode: import_vitest13.vi.fn(),
-    setBrightness: import_vitest13.vi.fn(),
-    setGamma: import_vitest13.vi.fn(),
-    setFullbright: import_vitest13.vi.fn(),
-    setAmbient: import_vitest13.vi.fn(),
-    setLightStyle: import_vitest13.vi.fn(),
-    setUnderwaterWarp: import_vitest13.vi.fn(),
-    setBloom: import_vitest13.vi.fn(),
-    setBloomIntensity: import_vitest13.vi.fn(),
-    setLodBias: import_vitest13.vi.fn(),
-    setAreaPortalState: import_vitest13.vi.fn(),
-    renderInstanced: import_vitest13.vi.fn(),
-    dispose: import_vitest13.vi.fn(),
+    getPerformanceReport: import_vitest12.vi.fn().mockReturnValue({}),
+    getMemoryUsage: import_vitest12.vi.fn().mockReturnValue({}),
+    renderFrame: import_vitest12.vi.fn(),
+    registerPic: import_vitest12.vi.fn().mockResolvedValue({}),
+    registerTexture: import_vitest12.vi.fn().mockReturnValue({}),
+    begin2D: import_vitest12.vi.fn(),
+    end2D: import_vitest12.vi.fn(),
+    drawPic: import_vitest12.vi.fn(),
+    drawString: import_vitest12.vi.fn(),
+    drawCenterString: import_vitest12.vi.fn(),
+    drawfillRect: import_vitest12.vi.fn(),
+    setEntityHighlight: import_vitest12.vi.fn(),
+    clearEntityHighlight: import_vitest12.vi.fn(),
+    highlightSurface: import_vitest12.vi.fn(),
+    removeSurfaceHighlight: import_vitest12.vi.fn(),
+    setDebugMode: import_vitest12.vi.fn(),
+    setBrightness: import_vitest12.vi.fn(),
+    setGamma: import_vitest12.vi.fn(),
+    setFullbright: import_vitest12.vi.fn(),
+    setAmbient: import_vitest12.vi.fn(),
+    setLightStyle: import_vitest12.vi.fn(),
+    setUnderwaterWarp: import_vitest12.vi.fn(),
+    setBloom: import_vitest12.vi.fn(),
+    setBloomIntensity: import_vitest12.vi.fn(),
+    setLodBias: import_vitest12.vi.fn(),
+    setAreaPortalState: import_vitest12.vi.fn(),
+    renderInstanced: import_vitest12.vi.fn(),
+    dispose: import_vitest12.vi.fn(),
     ...overrides
   };
 }
 function createMockFrameRenderer(overrides) {
   return {
-    renderFrame: import_vitest13.vi.fn().mockReturnValue({
+    renderFrame: import_vitest12.vi.fn().mockReturnValue({
       batches: 0,
       facesDrawn: 0,
       drawCalls: 0,
@@ -3536,15 +3501,15 @@ function createMockBspPipeline(overrides) {
   return {
     gl,
     program: {
-      use: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
+      use: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
       sourceSize: 0,
-      getUniformLocation: import_vitest13.vi.fn().mockReturnValue(null)
+      getUniformLocation: import_vitest12.vi.fn().mockReturnValue(null)
     },
     shaderSize: 0,
-    bind: import_vitest13.vi.fn().mockReturnValue({}),
-    draw: import_vitest13.vi.fn(),
-    dispose: import_vitest13.vi.fn(),
+    bind: import_vitest12.vi.fn().mockReturnValue({}),
+    draw: import_vitest12.vi.fn(),
+    dispose: import_vitest12.vi.fn(),
     ...overrides
   };
 }
@@ -3553,15 +3518,15 @@ function createMockMd2Pipeline(overrides) {
   return {
     gl,
     program: {
-      use: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
+      use: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
       sourceSize: 0,
-      getUniformLocation: import_vitest13.vi.fn().mockReturnValue(null)
+      getUniformLocation: import_vitest12.vi.fn().mockReturnValue(null)
     },
     shaderSize: 0,
-    bind: import_vitest13.vi.fn(),
-    draw: import_vitest13.vi.fn(),
-    dispose: import_vitest13.vi.fn(),
+    bind: import_vitest12.vi.fn(),
+    draw: import_vitest12.vi.fn(),
+    dispose: import_vitest12.vi.fn(),
     ...overrides
   };
 }
@@ -3570,15 +3535,15 @@ function createMockMd3Pipeline(overrides) {
   return {
     gl,
     program: {
-      use: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
+      use: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
       sourceSize: 0,
-      getUniformLocation: import_vitest13.vi.fn().mockReturnValue(null)
+      getUniformLocation: import_vitest12.vi.fn().mockReturnValue(null)
     },
     shaderSize: 0,
-    bind: import_vitest13.vi.fn(),
-    drawSurface: import_vitest13.vi.fn(),
-    dispose: import_vitest13.vi.fn(),
+    bind: import_vitest12.vi.fn(),
+    drawSurface: import_vitest12.vi.fn(),
+    dispose: import_vitest12.vi.fn(),
     ...overrides
   };
 }
@@ -3587,29 +3552,29 @@ function createMockSpritePipeline(overrides) {
   return {
     gl,
     program: {
-      use: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
+      use: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
       sourceSize: 0,
-      getUniformLocation: import_vitest13.vi.fn().mockReturnValue(null)
+      getUniformLocation: import_vitest12.vi.fn().mockReturnValue(null)
     },
     shaderSize: 0,
     vao: {
-      bind: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
-      configureAttributes: import_vitest13.vi.fn()
+      bind: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
+      configureAttributes: import_vitest12.vi.fn()
     },
     vbo: {
-      bind: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
-      upload: import_vitest13.vi.fn()
+      bind: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
+      upload: import_vitest12.vi.fn()
     },
     whiteTexture: {
-      bind: import_vitest13.vi.fn(),
-      upload: import_vitest13.vi.fn()
+      bind: import_vitest12.vi.fn(),
+      upload: import_vitest12.vi.fn()
     },
-    begin: import_vitest13.vi.fn(),
-    draw: import_vitest13.vi.fn(),
-    drawRect: import_vitest13.vi.fn(),
+    begin: import_vitest12.vi.fn(),
+    draw: import_vitest12.vi.fn(),
+    drawRect: import_vitest12.vi.fn(),
     ...overrides
   };
 }
@@ -3618,69 +3583,69 @@ function createMockSkyboxPipeline(overrides) {
   return {
     gl,
     program: {
-      use: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
+      use: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
       sourceSize: 0,
-      getUniformLocation: import_vitest13.vi.fn().mockReturnValue(null)
+      getUniformLocation: import_vitest12.vi.fn().mockReturnValue(null)
     },
     vao: {
-      bind: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
-      configureAttributes: import_vitest13.vi.fn()
+      bind: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
+      configureAttributes: import_vitest12.vi.fn()
     },
     vbo: {
-      bind: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
-      upload: import_vitest13.vi.fn()
+      bind: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
+      upload: import_vitest12.vi.fn()
     },
     cubemap: {
-      bind: import_vitest13.vi.fn(),
-      dispose: import_vitest13.vi.fn(),
-      setParameters: import_vitest13.vi.fn(),
-      upload: import_vitest13.vi.fn()
+      bind: import_vitest12.vi.fn(),
+      dispose: import_vitest12.vi.fn(),
+      setParameters: import_vitest12.vi.fn(),
+      upload: import_vitest12.vi.fn()
     },
     shaderSize: 0,
-    bind: import_vitest13.vi.fn(),
-    draw: import_vitest13.vi.fn(),
-    dispose: import_vitest13.vi.fn(),
+    bind: import_vitest12.vi.fn(),
+    draw: import_vitest12.vi.fn(),
+    dispose: import_vitest12.vi.fn(),
     ...overrides
   };
 }
 
 // src/engine/mocks/assets.ts
-var import_vitest14 = require("vitest");
+var import_vitest13 = require("vitest");
 function createMockAssetManager(overrides) {
   return {
     textures: {
-      get: import_vitest14.vi.fn(),
-      set: import_vitest14.vi.fn(),
-      has: import_vitest14.vi.fn(),
-      clear: import_vitest14.vi.fn(),
+      get: import_vitest13.vi.fn(),
+      set: import_vitest13.vi.fn(),
+      has: import_vitest13.vi.fn(),
+      clear: import_vitest13.vi.fn(),
       memoryUsage: 0
     },
     audio: {
-      load: import_vitest14.vi.fn(),
-      get: import_vitest14.vi.fn(),
-      clearAll: import_vitest14.vi.fn()
+      load: import_vitest13.vi.fn(),
+      get: import_vitest13.vi.fn(),
+      clearAll: import_vitest13.vi.fn()
     },
-    loadTexture: import_vitest14.vi.fn().mockResolvedValue({}),
-    registerTexture: import_vitest14.vi.fn(),
-    loadSound: import_vitest14.vi.fn().mockResolvedValue({}),
-    loadMd2Model: import_vitest14.vi.fn().mockResolvedValue({}),
-    getMd2Model: import_vitest14.vi.fn(),
-    loadMd3Model: import_vitest14.vi.fn().mockResolvedValue({}),
-    getMd3Model: import_vitest14.vi.fn(),
-    loadSprite: import_vitest14.vi.fn().mockResolvedValue({}),
-    loadMap: import_vitest14.vi.fn().mockResolvedValue({}),
-    getMap: import_vitest14.vi.fn(),
-    loadPalette: import_vitest14.vi.fn().mockResolvedValue(void 0),
-    isAssetLoaded: import_vitest14.vi.fn().mockReturnValue(true),
-    listFiles: import_vitest14.vi.fn().mockReturnValue([]),
-    resetForLevelChange: import_vitest14.vi.fn(),
-    getMemoryUsage: import_vitest14.vi.fn().mockReturnValue({ textures: 0, audio: 0 }),
-    clearCache: import_vitest14.vi.fn(),
-    preloadAssets: import_vitest14.vi.fn().mockResolvedValue(void 0),
-    queueLoad: import_vitest14.vi.fn().mockImplementation((path4) => Promise.resolve({})),
+    loadTexture: import_vitest13.vi.fn().mockResolvedValue({}),
+    registerTexture: import_vitest13.vi.fn(),
+    loadSound: import_vitest13.vi.fn().mockResolvedValue({}),
+    loadMd2Model: import_vitest13.vi.fn().mockResolvedValue({}),
+    getMd2Model: import_vitest13.vi.fn(),
+    loadMd3Model: import_vitest13.vi.fn().mockResolvedValue({}),
+    getMd3Model: import_vitest13.vi.fn(),
+    loadSprite: import_vitest13.vi.fn().mockResolvedValue({}),
+    loadMap: import_vitest13.vi.fn().mockResolvedValue({}),
+    getMap: import_vitest13.vi.fn(),
+    loadPalette: import_vitest13.vi.fn().mockResolvedValue(void 0),
+    isAssetLoaded: import_vitest13.vi.fn().mockReturnValue(true),
+    listFiles: import_vitest13.vi.fn().mockReturnValue([]),
+    resetForLevelChange: import_vitest13.vi.fn(),
+    getMemoryUsage: import_vitest13.vi.fn().mockReturnValue({ textures: 0, audio: 0 }),
+    clearCache: import_vitest13.vi.fn(),
+    preloadAssets: import_vitest13.vi.fn().mockResolvedValue(void 0),
+    queueLoad: import_vitest13.vi.fn().mockImplementation((path4) => Promise.resolve({})),
     ...overrides
   };
 }
@@ -3768,16 +3733,16 @@ function createMockBspMap(overrides) {
 }
 
 // src/engine/mocks/buffers.ts
-var import_vitest15 = require("vitest");
+var import_vitest14 = require("vitest");
 var import_engine4 = require("@quake2ts/engine");
 var import_engine5 = require("@quake2ts/engine");
 function createMockVertexBuffer(data, usage) {
   const gl = createMockWebGL2Context();
   const vb = new import_engine4.VertexBuffer(gl, usage ?? gl.STATIC_DRAW);
-  import_vitest15.vi.spyOn(vb, "bind");
-  import_vitest15.vi.spyOn(vb, "upload");
-  import_vitest15.vi.spyOn(vb, "update");
-  import_vitest15.vi.spyOn(vb, "dispose");
+  import_vitest14.vi.spyOn(vb, "bind");
+  import_vitest14.vi.spyOn(vb, "upload");
+  import_vitest14.vi.spyOn(vb, "update");
+  import_vitest14.vi.spyOn(vb, "dispose");
   if (data) {
     vb.upload(data, usage ?? gl.STATIC_DRAW);
   }
@@ -3786,10 +3751,10 @@ function createMockVertexBuffer(data, usage) {
 function createMockIndexBuffer(data, usage) {
   const gl = createMockWebGL2Context();
   const ib = new import_engine4.IndexBuffer(gl, usage ?? gl.STATIC_DRAW);
-  import_vitest15.vi.spyOn(ib, "bind");
-  import_vitest15.vi.spyOn(ib, "upload");
-  import_vitest15.vi.spyOn(ib, "update");
-  import_vitest15.vi.spyOn(ib, "dispose");
+  import_vitest14.vi.spyOn(ib, "bind");
+  import_vitest14.vi.spyOn(ib, "upload");
+  import_vitest14.vi.spyOn(ib, "update");
+  import_vitest14.vi.spyOn(ib, "dispose");
   if (data) {
     ib.upload(data, usage ?? gl.STATIC_DRAW);
   }
@@ -3802,10 +3767,10 @@ function createMockShaderProgram(overrides) {
     fragment: "#version 300 es\nvoid main() {}"
   };
   const program = import_engine5.ShaderProgram.create(gl, dummySources);
-  import_vitest15.vi.spyOn(program, "use");
-  import_vitest15.vi.spyOn(program, "getUniformLocation");
-  import_vitest15.vi.spyOn(program, "getAttributeLocation");
-  import_vitest15.vi.spyOn(program, "dispose");
+  import_vitest14.vi.spyOn(program, "use");
+  import_vitest14.vi.spyOn(program, "getUniformLocation");
+  import_vitest14.vi.spyOn(program, "getAttributeLocation");
+  import_vitest14.vi.spyOn(program, "dispose");
   if (overrides) {
     Object.assign(program, overrides);
   }
@@ -3821,7 +3786,7 @@ function createMockShader(vertSource, fragSource) {
 }
 
 // src/engine/mocks/lighting.ts
-var import_vitest16 = require("vitest");
+var import_vitest15 = require("vitest");
 var import_engine6 = require("@quake2ts/engine");
 function createMockDLight(position = { x: 0, y: 0, z: 0 }, color = { x: 1, y: 1, z: 1 }, intensity = 300) {
   return {
@@ -3833,10 +3798,10 @@ function createMockDLight(position = { x: 0, y: 0, z: 0 }, color = { x: 1, y: 1,
 }
 function createMockDLightManager(overrides) {
   const mockManager = {
-    addLight: import_vitest16.vi.fn(),
-    clear: import_vitest16.vi.fn(),
-    update: import_vitest16.vi.fn(),
-    getActiveLights: import_vitest16.vi.fn().mockReturnValue([]),
+    addLight: import_vitest15.vi.fn(),
+    clear: import_vitest15.vi.fn(),
+    update: import_vitest15.vi.fn(),
+    getActiveLights: import_vitest15.vi.fn().mockReturnValue([]),
     ...overrides
   };
   return mockManager;
@@ -3851,7 +3816,7 @@ function createMockLightmap(width = 128, height = 128) {
 }
 
 // src/engine/mocks/particles.ts
-var import_vitest17 = require("vitest");
+var import_vitest16 = require("vitest");
 var import_engine7 = require("@quake2ts/engine");
 function createMockParticle(overrides) {
   return {
@@ -3870,8 +3835,8 @@ function createMockParticle(overrides) {
 }
 function createMockParticleEmitter(overrides) {
   return {
-    update: import_vitest17.vi.fn(),
-    emit: import_vitest17.vi.fn(),
+    update: import_vitest16.vi.fn(),
+    emit: import_vitest16.vi.fn(),
     ...overrides
   };
 }
@@ -3879,35 +3844,35 @@ function createMockParticleSystem(overrides) {
   return {
     maxParticles: 1e3,
     rng: {
-      frandom: import_vitest17.vi.fn().mockReturnValue(0.5),
+      frandom: import_vitest16.vi.fn().mockReturnValue(0.5),
       // Deterministic default
-      random: import_vitest17.vi.fn().mockReturnValue(0.5),
-      seed: import_vitest17.vi.fn()
+      random: import_vitest16.vi.fn().mockReturnValue(0.5),
+      seed: import_vitest16.vi.fn()
     },
-    update: import_vitest17.vi.fn(),
-    spawn: import_vitest17.vi.fn(),
-    killAll: import_vitest17.vi.fn(),
-    aliveCount: import_vitest17.vi.fn().mockReturnValue(0),
-    getState: import_vitest17.vi.fn(),
-    buildMesh: import_vitest17.vi.fn(),
+    update: import_vitest16.vi.fn(),
+    spawn: import_vitest16.vi.fn(),
+    killAll: import_vitest16.vi.fn(),
+    aliveCount: import_vitest16.vi.fn().mockReturnValue(0),
+    getState: import_vitest16.vi.fn(),
+    buildMesh: import_vitest16.vi.fn(),
     ...overrides
   };
 }
 
 // src/engine/rendering.ts
-var import_vitest18 = require("vitest");
+var import_vitest17 = require("vitest");
 function createMockRenderingContext() {
   const gl = createMockWebGL2Context();
   const camera = {
-    update: import_vitest18.vi.fn(),
-    getViewMatrix: import_vitest18.vi.fn().mockReturnValue(new Float32Array(16)),
-    getProjectionMatrix: import_vitest18.vi.fn().mockReturnValue(new Float32Array(16)),
-    getViewProjectionMatrix: import_vitest18.vi.fn().mockReturnValue(new Float32Array(16)),
-    getPosition: import_vitest18.vi.fn().mockReturnValue([0, 0, 0]),
-    getForward: import_vitest18.vi.fn().mockReturnValue([0, 0, -1]),
-    getRight: import_vitest18.vi.fn().mockReturnValue([1, 0, 0]),
-    getUp: import_vitest18.vi.fn().mockReturnValue([0, 1, 0]),
-    extractFrustumPlanes: import_vitest18.vi.fn(),
+    update: import_vitest17.vi.fn(),
+    getViewMatrix: import_vitest17.vi.fn().mockReturnValue(new Float32Array(16)),
+    getProjectionMatrix: import_vitest17.vi.fn().mockReturnValue(new Float32Array(16)),
+    getViewProjectionMatrix: import_vitest17.vi.fn().mockReturnValue(new Float32Array(16)),
+    getPosition: import_vitest17.vi.fn().mockReturnValue([0, 0, 0]),
+    getForward: import_vitest17.vi.fn().mockReturnValue([0, 0, -1]),
+    getRight: import_vitest17.vi.fn().mockReturnValue([1, 0, 0]),
+    getUp: import_vitest17.vi.fn().mockReturnValue([0, 1, 0]),
+    extractFrustumPlanes: import_vitest17.vi.fn(),
     transform: {
       origin: [0, 0, 0],
       angles: [0, 0, 0],
@@ -3915,29 +3880,29 @@ function createMockRenderingContext() {
     }
   };
   const md2 = {
-    render: import_vitest18.vi.fn(),
-    init: import_vitest18.vi.fn(),
-    resize: import_vitest18.vi.fn()
+    render: import_vitest17.vi.fn(),
+    init: import_vitest17.vi.fn(),
+    resize: import_vitest17.vi.fn()
   };
   const bsp = {
-    render: import_vitest18.vi.fn(),
-    init: import_vitest18.vi.fn(),
-    resize: import_vitest18.vi.fn()
+    render: import_vitest17.vi.fn(),
+    init: import_vitest17.vi.fn(),
+    resize: import_vitest17.vi.fn()
   };
   const sprite = {
-    render: import_vitest18.vi.fn(),
-    init: import_vitest18.vi.fn(),
-    resize: import_vitest18.vi.fn()
+    render: import_vitest17.vi.fn(),
+    init: import_vitest17.vi.fn(),
+    resize: import_vitest17.vi.fn()
   };
   const poly = {
-    render: import_vitest18.vi.fn(),
-    init: import_vitest18.vi.fn(),
-    resize: import_vitest18.vi.fn()
+    render: import_vitest17.vi.fn(),
+    init: import_vitest17.vi.fn(),
+    resize: import_vitest17.vi.fn()
   };
   const particle = {
-    render: import_vitest18.vi.fn(),
-    init: import_vitest18.vi.fn(),
-    resize: import_vitest18.vi.fn()
+    render: import_vitest17.vi.fn(),
+    init: import_vitest17.vi.fn(),
+    resize: import_vitest17.vi.fn()
   };
   return {
     gl,
@@ -4232,7 +4197,7 @@ async function runComputeAndReadback(setup, computeFn) {
 }
 
 // src/engine/helpers/pipeline-test-template.ts
-var import_vitest19 = require("vitest");
+var import_vitest18 = require("vitest");
 async function testPipelineRendering(name, createPipeline, setupGeometry, expectedOutput) {
   const setup = await createRenderTestSetup(256, 256);
   try {
@@ -4249,9 +4214,9 @@ async function testPipelineRendering(name, createPipeline, setupGeometry, expect
       }
     });
     if (expectedOutput) {
-      (0, import_vitest19.expect)(pixels).toEqual(expectedOutput);
+      (0, import_vitest18.expect)(pixels).toEqual(expectedOutput);
     } else {
-      (0, import_vitest19.expect)(pixels.length).toBe(256 * 256 * 4);
+      (0, import_vitest18.expect)(pixels.length).toBe(256 * 256 * 4);
     }
   } finally {
     await setup.cleanup();
@@ -4290,7 +4255,7 @@ async function testComputeShader(name, createComputePipeline, inputData, expecte
     });
     if (expectedOutput) {
       const floatResult = new Float32Array(resultBuffer);
-      (0, import_vitest19.expect)(floatResult).toEqual(expectedOutput);
+      (0, import_vitest18.expect)(floatResult).toEqual(expectedOutput);
     }
     stagingBuffer.destroy();
   } finally {
@@ -4402,7 +4367,7 @@ function simulateCameraMovement(camera, input, deltaTime) {
 }
 
 // src/client/helpers/hud.ts
-var import_vitest20 = require("vitest");
+var import_vitest19 = require("vitest");
 function createMockHudState(overrides) {
   const defaultPs = {
     damageAlpha: 0,
@@ -4432,11 +4397,11 @@ function createMockHudState(overrides) {
   defaultStats[2] = 25;
   defaultStats[4] = 50;
   const defaultMessages = {
-    drawCenterPrint: import_vitest20.vi.fn(),
-    drawNotifications: import_vitest20.vi.fn(),
-    addCenterPrint: import_vitest20.vi.fn(),
-    addNotification: import_vitest20.vi.fn(),
-    clear: import_vitest20.vi.fn()
+    drawCenterPrint: import_vitest19.vi.fn(),
+    drawNotifications: import_vitest19.vi.fn(),
+    addCenterPrint: import_vitest19.vi.fn(),
+    addNotification: import_vitest19.vi.fn(),
+    clear: import_vitest19.vi.fn()
   };
   return {
     ps: overrides?.ps ?? defaultPs,
@@ -4455,7 +4420,7 @@ function createMockHudState(overrides) {
 function createMockScoreboard(players = []) {
   return {
     players,
-    draw: import_vitest20.vi.fn()
+    draw: import_vitest19.vi.fn()
   };
 }
 function createMockChatMessage(text, sender, timestamp = Date.now()) {
@@ -4554,12 +4519,12 @@ function createMockFogData(overrides = {}) {
 }
 
 // src/client/mocks/download.ts
-var import_vitest21 = require("vitest");
+var import_vitest20 = require("vitest");
 function createMockDownloadManager(overrides) {
   return {
-    download: import_vitest21.vi.fn().mockResolvedValue(new ArrayBuffer(0)),
-    cancel: import_vitest21.vi.fn(),
-    getProgress: import_vitest21.vi.fn().mockReturnValue(0),
+    download: import_vitest20.vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+    cancel: import_vitest20.vi.fn(),
+    getProgress: import_vitest20.vi.fn().mockReturnValue(0),
     ...overrides
   };
 }
@@ -4668,20 +4633,20 @@ var createMockConnectionState = (state = "connected") => ({
 });
 
 // src/client/mocks/console.ts
-var import_vitest22 = require("vitest");
+var import_vitest21 = require("vitest");
 function createMockConsole(overrides) {
   const history = [];
   const errors = [];
   const commands = {};
   const cvars = {};
   return {
-    print: import_vitest22.vi.fn((text) => {
+    print: import_vitest21.vi.fn((text) => {
       history.push(text);
     }),
-    error: import_vitest22.vi.fn((text) => {
+    error: import_vitest21.vi.fn((text) => {
       errors.push(text);
     }),
-    execute: import_vitest22.vi.fn((text) => {
+    execute: import_vitest21.vi.fn((text) => {
       const parts = text.trim().split(/\s+/);
       const cmd = parts[0];
       const args = parts.slice(1);
@@ -4691,11 +4656,11 @@ function createMockConsole(overrides) {
         history.push(`Unknown command "${cmd}"`);
       }
     }),
-    addCommand: import_vitest22.vi.fn((name, handler) => {
+    addCommand: import_vitest21.vi.fn((name, handler) => {
       commands[name] = handler;
     }),
-    getCvar: import_vitest22.vi.fn((name) => cvars[name]),
-    setCvar: import_vitest22.vi.fn((name, value) => {
+    getCvar: import_vitest21.vi.fn((name) => cvars[name]),
+    setCvar: import_vitest21.vi.fn((name, value) => {
       cvars[name] = value;
     }),
     getHistory: () => history,
@@ -5074,10 +5039,15 @@ function throttleBandwidth(bytesPerSecond) {
 }
 
 // src/e2e/visual.ts
-var import_canvas3 = require("@napi-rs/canvas");
+var import_pngjs2 = require("pngjs");
+var import_pixelmatch2 = __toESM(require("pixelmatch"), 1);
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_path2 = __toESM(require("path"), 1);
 async function captureGameScreenshot(page, name) {
+  const canvasElement = page.locator("canvas");
+  if (await canvasElement.count() > 0) {
+    return await canvasElement.screenshot({ path: `${name}.png` });
+  }
   return await page.screenshot({ path: `${name}.png` });
 }
 async function takeScreenshot(canvas, filepath) {
@@ -5094,82 +5064,43 @@ async function takeScreenshot(canvas, filepath) {
   await import_promises2.default.mkdir(import_path2.default.dirname(filepath), { recursive: true });
   await import_promises2.default.writeFile(filepath, buffer);
 }
-async function compareScreenshot(canvas, baselinePath) {
-  try {
-    await import_promises2.default.access(baselinePath);
-  } catch {
-    console.warn(`Baseline not found at ${baselinePath}, saving current as baseline.`);
-    await takeScreenshot(canvas, baselinePath);
-    return true;
-  }
-  const baselineBuffer = await import_promises2.default.readFile(baselinePath);
-  const baselineImage = new import_canvas3.Image();
-  baselineImage.src = baselineBuffer;
-  const width = baselineImage.width;
-  const height = baselineImage.height;
-  let currentBuffer;
-  if ("toBuffer" in canvas && typeof canvas.toBuffer === "function") {
-    currentBuffer = canvas.toBuffer("image/png");
-  } else if ("toDataURL" in canvas) {
-    const dataUrl = canvas.toDataURL("image/png");
-    currentBuffer = Buffer.from(dataUrl.replace(/^data:image\/png;base64,/, ""), "base64");
-  } else {
-    throw new Error("Unsupported canvas type");
-  }
-  if (baselineBuffer.equals(currentBuffer)) {
-    return true;
-  }
-  const baselineCanvas = new import_canvas3.Canvas(width, height);
-  const ctx = baselineCanvas.getContext("2d");
-  ctx.drawImage(baselineImage, 0, 0);
-  const baselineData = ctx.getImageData(0, 0, width, height).data;
-  const currentImage = new import_canvas3.Image();
-  currentImage.src = currentBuffer;
-  if (currentImage.width !== width || currentImage.height !== height) {
-    console.error(`Dimension mismatch: Baseline ${width}x${height} vs Current ${currentImage.width}x${currentImage.height}`);
-    return false;
-  }
-  const currentCanvas = new import_canvas3.Canvas(width, height);
-  const ctx2 = currentCanvas.getContext("2d");
-  ctx2.drawImage(currentImage, 0, 0);
-  const currentData = ctx2.getImageData(0, 0, width, height).data;
-  let diffPixels = 0;
-  const totalPixels = width * height;
-  for (let i = 0; i < baselineData.length; i += 4) {
-    if (baselineData[i] !== currentData[i] || // R
-    baselineData[i + 1] !== currentData[i + 1] || // G
-    baselineData[i + 2] !== currentData[i + 2] || // B
-    baselineData[i + 3] !== currentData[i + 3]) {
-      diffPixels++;
-    }
-  }
-  if (diffPixels > 0) {
-    console.error(`Visual regression: ${diffPixels} pixels differ (${(diffPixels / totalPixels * 100).toFixed(2)}%)`);
-    return false;
-  }
-  return true;
-}
 function compareScreenshots(baseline, current, threshold = 0.01) {
-  if (baseline.length !== current.length) {
-    return { diffPercentage: 1 };
-  }
-  let diffPixels = 0;
-  const totalPixels = baseline.length;
-  for (let i = 0; i < baseline.length; i++) {
-    if (baseline[i] !== current[i]) {
-      diffPixels++;
+  try {
+    const img1 = import_pngjs2.PNG.sync.read(baseline);
+    const img2 = import_pngjs2.PNG.sync.read(current);
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(`Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`);
     }
+    const { width, height } = img1;
+    const diff = new import_pngjs2.PNG({ width, height });
+    const diffPixels = (0, import_pixelmatch2.default)(
+      img1.data,
+      img2.data,
+      diff.data,
+      width,
+      height,
+      { threshold }
+    );
+    const diffPercentage = diffPixels / (width * height);
+    const isMatch = diffPixels === 0;
+    return {
+      diffPixels,
+      diffPercentage,
+      isMatch,
+      diffImage: import_pngjs2.PNG.sync.write(diff)
+    };
+  } catch (error) {
+    console.error("Error comparing screenshots:", error);
+    return {
+      diffPixels: -1,
+      diffPercentage: 1,
+      isMatch: false
+    };
   }
-  const diffPercentage = diffPixels / totalPixels;
-  return {
-    diffPercentage
-  };
 }
 function createVisualTestScenario(sceneName) {
   return {
-    sceneName,
-    setup: async () => {
-    }
+    sceneName
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -5206,7 +5137,6 @@ function createVisualTestScenario(sceneName) {
   captureGameState,
   captureTexture,
   compareSaveGames,
-  compareScreenshot,
   compareScreenshots,
   compareSnapshots,
   createBandwidthTestScenario,