quake2ts 0.0.621 → 0.0.629

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

@@ -42,6 +42,7 @@ __export(index_exports, {
   HandshakeStage: () => HandshakeStage,
   InputInjector: () => InputInjector,
   MockAudioBufferSourceNode: () => FakeBufferSource,
+  MockClientConfigStrings: () => MockClientConfigStrings,
   MockNetDriver: () => MockNetDriver,
   MockNetworkTransport: () => MockNetworkTransport,
   MockPointerLock: () => MockPointerLock,
@@ -58,6 +59,7 @@ __export(index_exports, {
   createBinaryWriterMock: () => createBinaryWriterMock,
   createBounds: () => createBounds,
   createCombatTestContext: () => createCombatTestContext,
+  createComputeTestSetup: () => createComputeTestSetup,
   createConfigStringArrayMock: () => createConfigStringArrayMock,
   createConfigStringMock: () => createConfigStringMock,
   createControlledTimer: () => createControlledTimer,
@@ -68,33 +70,49 @@ __export(index_exports, {
   createEntityFactory: () => createEntityFactory,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
+  createHeadlessTestContext: () => createHeadlessTestContext,
   createInputInjector: () => createInputInjector,
+  createInterpolationTestData: () => createInterpolationTestData,
   createItemEntityFactory: () => createItemEntityFactory,
   createMessageReaderMock: () => createMessageReaderMock,
   createMessageWriterMock: () => createMessageWriterMock,
   createMockAI: () => createMockAI,
   createMockAmmoItem: () => createMockAmmoItem,
   createMockArmorItem: () => createMockArmorItem,
+  createMockAssetManager: () => createMockAssetManager,
   createMockAudioBuffer: () => createMockAudioBuffer,
   createMockAudioContext: () => createMockAudioContext,
+  createMockBspMap: () => createMockBspMap,
   createMockBspPipeline: () => createMockBspPipeline,
   createMockBufferSource: () => createMockBufferSource,
   createMockCamera: () => createMockCamera,
   createMockCanvas: () => createMockCanvas,
   createMockCanvasContext2D: () => createMockCanvasContext2D,
   createMockChatMessage: () => createMockChatMessage,
+  createMockClientInfo: () => createMockClientInfo,
+  createMockClientState: () => createMockClientState,
   createMockCollisionEntityIndex: () => createMockCollisionEntityIndex,
+  createMockCommand: () => createMockCommand,
+  createMockCommandEncoder: () => createMockCommandEncoder,
+  createMockComputePassEncoder: () => createMockComputePassEncoder,
+  createMockComputePipeline: () => createMockComputePipeline,
   createMockConnection: () => createMockConnection,
+  createMockConnectionState: () => createMockConnectionState,
+  createMockConsole: () => createMockConsole,
+  createMockCvarRegistry: () => createMockCvarRegistry,
   createMockDamageIndicator: () => createMockDamageIndicator,
   createMockDamageInfo: () => createMockDamageInfo,
   createMockDeltaFrame: () => createMockDeltaFrame,
+  createMockDownloadManager: () => createMockDownloadManager,
   createMockEngine: () => createMockEngine,
   createMockEntityState: () => createMockEntityState,
   createMockFogData: () => createMockFogData,
+  createMockFrame: () => createMockFrame,
   createMockFrameRenderer: () => createMockFrameRenderer,
   createMockGPUAdapter: () => createMockGPUAdapter,
-  createMockGPUCanvasContext: () => createMockGPUCanvasContext,
+  createMockGPUBuffer: () => createMockGPUBuffer,
   createMockGPUDevice: () => createMockGPUDevice,
+  createMockGPUTexture: () => createMockGPUTexture,
   createMockGame: () => createMockGame,
   createMockGameExports: () => createMockGameExports,
   createMockGameState: () => createMockGameState,
@@ -109,7 +127,9 @@ __export(index_exports, {
   createMockKeyboardEvent: () => createMockKeyboardEvent,
   createMockLocalStorage: () => createMockLocalStorage,
   createMockMasterServer: () => createMockMasterServer,
+  createMockMd2Model: () => createMockMd2Model,
   createMockMd2Pipeline: () => createMockMd2Pipeline,
+  createMockMd3Model: () => createMockMd3Model,
   createMockMd3Pipeline: () => createMockMd3Pipeline,
   createMockMonsterAI: () => createMockMonsterAI,
   createMockMonsterMove: () => createMockMonsterMove,
@@ -121,12 +141,17 @@ __export(index_exports, {
   createMockPerformance: () => createMockPerformance,
   createMockPointerLock: () => createMockPointerLock,
   createMockPowerupItem: () => createMockPowerupItem,
+  createMockPrecacheList: () => createMockPrecacheList,
+  createMockQueue: () => createMockQueue,
   createMockRAF: () => createMockRAF,
   createMockRConClient: () => createMockRConClient,
   createMockRateLimiter: () => createMockRateLimiter,
   createMockRefDef: () => createMockRefDef,
+  createMockRenderPassEncoder: () => createMockRenderPassEncoder,
+  createMockRenderPipeline: () => createMockRenderPipeline,
   createMockRenderer: () => createMockRenderer,
   createMockRenderingContext: () => createMockRenderingContext,
+  createMockSampler: () => createMockSampler,
   createMockScoreboard: () => createMockScoreboard,
   createMockServer: () => createMockServer,
   createMockServerClient: () => createMockServerClient,
@@ -136,9 +161,12 @@ __export(index_exports, {
   createMockServerState: () => createMockServerState,
   createMockServerStatic: () => createMockServerStatic,
   createMockSessionStorage: () => createMockSessionStorage,
+  createMockShaderModule: () => createMockShaderModule,
   createMockSkyboxPipeline: () => createMockSkyboxPipeline,
   createMockSnapshot: () => createMockSnapshot,
   createMockSpritePipeline: () => createMockSpritePipeline,
+  createMockTexture: () => createMockTexture,
+  createMockTextureView: () => createMockTextureView,
   createMockTransport: () => createMockTransport,
   createMockUDPSocket: () => createMockUDPSocket,
   createMockUserInfo: () => createMockUserInfo,
@@ -146,6 +174,7 @@ __export(index_exports, {
   createMockWeapon: () => createMockWeapon,
   createMockWeaponItem: () => createMockWeaponItem,
   createMockWebGL2Context: () => createMockWebGL2Context,
+  createMockWebGPUContext: () => createMockWebGPUContext,
   createMockWheelEvent: () => createMockWheelEvent,
   createMonsterEntityFactory: () => createMonsterEntityFactory,
   createMultiplayerTestScenario: () => createMultiplayerTestScenario,
@@ -156,7 +185,9 @@ __export(index_exports, {
   createPlayerEntityFactory: () => createPlayerEntityFactory,
   createPlayerStateFactory: () => createPlayerStateFactory,
   createPlaywrightTestClient: () => createPlaywrightTestClient,
+  createPredictionTestScenario: () => createPredictionTestScenario,
   createProjectileEntityFactory: () => createProjectileEntityFactory,
+  createRenderTestSetup: () => createRenderTestSetup,
   createServerSnapshot: () => createServerSnapshot,
   createSpawnTestContext: () => createSpawnTestContext,
   createStorageTestScenario: () => createStorageTestScenario,
@@ -168,6 +199,7 @@ __export(index_exports, {
   createVector3: () => createVector3,
   createViewTestScenario: () => createViewTestScenario,
   createVisualTestScenario: () => createVisualTestScenario,
+  initHeadlessWebGPU: () => initHeadlessWebGPU,
   intersects: () => import_shared2.intersects,
   ladderTrace: () => import_shared2.ladderTrace,
   makeAxisBrush: () => makeAxisBrush,
@@ -180,6 +212,8 @@ __export(index_exports, {
   measureSnapshotSize: () => measureSnapshotSize,
   mockMonsterAttacks: () => mockMonsterAttacks,
   randomVector3: () => randomVector3,
+  renderAndCapture: () => renderAndCapture,
+  runComputeAndReadback: () => runComputeAndReadback,
   serializeUserInfo: () => serializeUserInfo,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
   setupMockAudioContext: () => setupMockAudioContext,
@@ -187,6 +221,8 @@ __export(index_exports, {
   setupWebGPUMocks: () => setupWebGPUMocks,
   simulateBandwidthLimit: () => simulateBandwidthLimit,
   simulateCameraMovement: () => simulateCameraMovement,
+  simulateClientPrediction: () => simulateClientPrediction,
+  simulateDownload: () => simulateDownload,
   simulateFrames: () => simulateFrames,
   simulateGravity: () => simulateGravity,
   simulateHandshake: () => simulateHandshake,
@@ -207,7 +243,10 @@ __export(index_exports, {
   teardownBrowserEnvironment: () => teardownBrowserEnvironment,
   teardownMockAudioContext: () => teardownMockAudioContext,
   teardownNodeEnvironment: () => teardownNodeEnvironment,
+  testComputeShader: () => testComputeShader,
+  testPipelineRendering: () => testPipelineRendering,
   throttleBandwidth: () => throttleBandwidth,
+  verifySmoothing: () => verifySmoothing,
   verifySnapshotConsistency: () => verifySnapshotConsistency,
   waitForGameReady: () => waitForGameReady
 });
@@ -2506,99 +2545,281 @@ function createMockImage(width = 100, height = 100, src = "") {
   return img;
 }
 
-// src/engine/mocks/webgpu.ts
-var import_vitest12 = require("vitest");
-function createMockGPUAdapter() {
-  return {
-    features: /* @__PURE__ */ new Set(),
-    limits: {
-      maxTextureDimension2D: 8192,
-      maxBindGroups: 4,
-      maxUniformBufferBindingSize: 65536,
-      maxStorageBufferBindingSize: 134217728
-    },
-    requestDevice: import_vitest12.vi.fn().mockResolvedValue(createMockGPUDevice())
-  };
-}
-function createMockGPUDevice() {
+// ../../node_modules/.pnpm/webgpu@0.3.8/node_modules/webgpu/index.js
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_module = require("module");
+var import_meta = {};
+var require2 = (0, import_module.createRequire)(import_meta.url);
+var isMac = process.platform === "darwin";
+var __dirname = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+var arch = isMac ? "universal" : process.arch;
+var dawnNodePath = (0, import_node_path.join)(__dirname, "dist", `${process.platform}-${arch}.dawn.node`);
+var { create, globals } = require2(dawnNodePath);
+
+// src/setup/webgpu.ts
+async function initHeadlessWebGPU(options) {
+  if (typeof process === "undefined" || process.release?.name !== "node") {
+    throw new Error("initHeadlessWebGPU should only be called in a Node.js environment");
+  }
+  if (!globalThis.navigator) {
+    globalThis.navigator = {};
+  }
+  if (!globalThis.navigator.gpu) {
+    const gpu = create([]);
+    try {
+      Object.defineProperty(globalThis.navigator, "gpu", {
+        value: gpu,
+        writable: true,
+        configurable: true
+      });
+    } catch (e) {
+      console.warn("Could not define navigator.gpu, trying direct assignment");
+      globalThis.navigator.gpu = gpu;
+    }
+    Object.assign(globalThis, globals);
+  }
+  const adapter = await navigator.gpu.requestAdapter({
+    powerPreference: options?.powerPreference || "high-performance"
+  });
+  if (!adapter) {
+    throw new Error("Failed to create WebGPU adapter");
+  }
+  const device = await adapter.requestDevice({
+    requiredFeatures: options?.requiredFeatures || []
+  });
+  if (!device) {
+    throw new Error("Failed to create WebGPU device");
+  }
   return {
-    features: /* @__PURE__ */ new Set(),
-    limits: {
-      maxTextureDimension2D: 8192
-    },
-    lost: new Promise(() => {
-    }),
-    // Pending promise
-    createShaderModule: import_vitest12.vi.fn(),
-    createBindGroupLayout: import_vitest12.vi.fn(),
-    createPipelineLayout: import_vitest12.vi.fn(),
-    createRenderPipeline: import_vitest12.vi.fn(),
-    createCommandEncoder: import_vitest12.vi.fn().mockReturnValue({
-      copyTextureToBuffer: import_vitest12.vi.fn(),
-      finish: import_vitest12.vi.fn()
-    }),
-    createBuffer: import_vitest12.vi.fn(),
-    createTexture: import_vitest12.vi.fn().mockReturnValue({
-      createView: import_vitest12.vi.fn()
-    }),
-    queue: {
-      submit: import_vitest12.vi.fn(),
-      writeBuffer: import_vitest12.vi.fn(),
-      writeTexture: import_vitest12.vi.fn()
+    adapter,
+    device,
+    cleanup: async () => {
+      device.destroy();
     }
   };
 }
-function createMockGPUCanvasContext() {
+async function createHeadlessTestContext() {
+  const { adapter, device } = await initHeadlessWebGPU();
   return {
-    configure: import_vitest12.vi.fn(),
-    getCurrentTexture: import_vitest12.vi.fn()
+    adapter,
+    device,
+    queue: device.queue
   };
 }
+
+// src/engine/mocks/webgpu.ts
+var import_vitest12 = require("vitest");
 function setupWebGPUMocks() {
-  const mockAdapter = createMockGPUAdapter();
+  Object.assign(globalThis, globals);
   const mockGpu = {
-    requestAdapter: import_vitest12.vi.fn().mockResolvedValue(mockAdapter),
+    requestAdapter: import_vitest12.vi.fn(),
     getPreferredCanvasFormat: import_vitest12.vi.fn().mockReturnValue("bgra8unorm")
   };
-  Object.defineProperty(global, "navigator", {
-    value: {
-      ...global.navigator,
-      gpu: mockGpu
-    },
-    writable: true
-  });
-  if (typeof GPUTextureUsage === "undefined") {
-    global.GPUTextureUsage = {
-      COPY_SRC: 1,
-      COPY_DST: 2,
-      TEXTURE_BINDING: 4,
-      STORAGE_BINDING: 8,
-      RENDER_ATTACHMENT: 16
-    };
-  }
-  if (typeof GPUBufferUsage === "undefined") {
-    global.GPUBufferUsage = {
-      MAP_READ: 1,
-      MAP_WRITE: 2,
-      COPY_SRC: 4,
-      COPY_DST: 8,
-      INDEX: 16,
-      VERTEX: 32,
-      UNIFORM: 64,
-      STORAGE: 128,
-      INDIRECT: 256,
-      QUERY_RESOLVE: 512
-    };
+  const mockAdapter = createMockGPUAdapter();
+  const mockDevice = createMockGPUDevice();
+  mockGpu.requestAdapter.mockResolvedValue(mockAdapter);
+  mockAdapter.requestDevice.mockResolvedValue(mockDevice);
+  if (!globalThis.navigator) {
+    globalThis.navigator = {};
   }
-  if (typeof GPUMapMode === "undefined") {
-    global.GPUMapMode = {
-      READ: 1,
-      WRITE: 2
-    };
+  try {
+    Object.defineProperty(globalThis.navigator, "gpu", {
+      value: mockGpu,
+      writable: true,
+      configurable: true
+    });
+  } catch (e) {
+    globalThis.navigator.gpu = mockGpu;
   }
   return {
     mockGpu,
-    mockAdapter
+    mockAdapter,
+    mockDevice
+  };
+}
+function createMockGPUAdapter(options = {}) {
+  return {
+    features: /* @__PURE__ */ new Set(),
+    limits: {},
+    isFallbackAdapter: false,
+    requestDevice: import_vitest12.vi.fn().mockResolvedValue(createMockGPUDevice()),
+    requestAdapterInfo: import_vitest12.vi.fn().mockResolvedValue({}),
+    ...options
+  };
+}
+function createMockGPUDevice(features = /* @__PURE__ */ new Set()) {
+  const queue = createMockQueue();
+  return {
+    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(),
+    onuncapturederror: null,
+    label: "",
+    lost: Promise.resolve({ reason: "destroyed", message: "Device lost" })
+  };
+}
+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(),
+    label: ""
+  };
+}
+function createMockGPUBuffer(descriptor) {
+  return {
+    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(),
+    label: descriptor.label || ""
+  };
+}
+function createMockGPUTexture(descriptor) {
+  const size = descriptor.size;
+  let width = 0;
+  let height = 0;
+  let depthOrArrayLayers = 1;
+  if (Array.isArray(size) || size instanceof Float32Array || size instanceof Uint32Array) {
+    const arr = Array.from(size);
+    width = arr[0] || 0;
+    height = arr[1] || 1;
+    depthOrArrayLayers = arr[2] || 1;
+  } else if (typeof size === "object") {
+    const dict = size;
+    width = dict.width;
+    height = dict.height || 1;
+    depthOrArrayLayers = dict.depthOrArrayLayers || 1;
+  }
+  return {
+    width,
+    height,
+    depthOrArrayLayers,
+    mipLevelCount: descriptor.mipLevelCount || 1,
+    sampleCount: descriptor.sampleCount || 1,
+    dimension: descriptor.dimension || "2d",
+    format: descriptor.format,
+    usage: descriptor.usage,
+    createView: import_vitest12.vi.fn(() => createMockTextureView()),
+    destroy: import_vitest12.vi.fn(),
+    label: descriptor.label || ""
+  };
+}
+function createMockTextureView() {
+  return {
+    label: ""
+  };
+}
+function createMockSampler() {
+  return {
+    label: ""
+  };
+}
+function createMockShaderModule(descriptor) {
+  return {
+    getCompilationInfo: import_vitest12.vi.fn().mockResolvedValue({ messages: [] }),
+    label: descriptor.label || ""
+  };
+}
+function createMockComputePipeline() {
+  return {
+    getBindGroupLayout: import_vitest12.vi.fn(() => ({ label: "mock-bind-group-layout" })),
+    label: ""
+  };
+}
+function createMockRenderPipeline() {
+  return {
+    getBindGroupLayout: import_vitest12.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(),
+    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(),
+    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(),
+    label: ""
+  };
+}
+function createMockWebGPUContext() {
+  const adapter = createMockGPUAdapter();
+  const device = createMockGPUDevice();
+  return {
+    adapter,
+    device,
+    queue: device.queue
   };
 }
 
@@ -3002,20 +3223,140 @@ function createMockSkyboxPipeline(overrides) {
   };
 }
 
-// src/engine/rendering.ts
+// src/engine/mocks/assets.ts
 var import_vitest14 = 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(),
+      memoryUsage: 0
+    },
+    audio: {
+      load: import_vitest14.vi.fn(),
+      get: import_vitest14.vi.fn(),
+      clearAll: import_vitest14.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((path2) => Promise.resolve({})),
+    ...overrides
+  };
+}
+function createMockTexture(width = 1, height = 1, data) {
+  return {
+    width,
+    height,
+    data: data || new Uint8Array(width * height * 4).fill(255),
+    format: 0,
+    // RGBA
+    name: "mock_texture",
+    uploaded: false
+  };
+}
+function createMockMd2Model(overrides) {
+  return {
+    header: {
+      skinWidth: 0,
+      skinHeight: 0,
+      frameSize: 0,
+      numSkins: 0,
+      numVertices: 0,
+      numSt: 0,
+      numTriangles: 0,
+      numGlCmds: 0,
+      numFrames: 0,
+      offsetSkins: 0,
+      offsetSt: 0,
+      offsetTriangles: 0,
+      offsetFrames: 0,
+      offsetGlCmds: 0,
+      offsetEnd: 0
+    },
+    skins: [],
+    texCoords: [],
+    triangles: [],
+    frames: [],
+    glCommands: new Int32Array(0),
+    ...overrides
+  };
+}
+function createMockMd3Model(overrides) {
+  return {
+    header: {
+      ident: 0,
+      version: 0,
+      name: "",
+      flags: 0,
+      numFrames: 0,
+      numTags: 0,
+      numSurfaces: 0,
+      numSkins: 0,
+      offsetFrames: 0,
+      offsetTags: 0,
+      offsetSurfaces: 0,
+      offsetEnd: 0
+    },
+    frames: [],
+    tags: [],
+    surfaces: [],
+    ...overrides
+  };
+}
+function createMockBspMap(overrides) {
+  return {
+    version: 38,
+    entities: [],
+    planes: [],
+    vertices: [],
+    visibility: new Uint8Array(0),
+    nodes: [],
+    texInfo: [],
+    faces: [],
+    lightmaps: [],
+    leafs: [],
+    leafFaces: [],
+    leafBrushes: [],
+    edges: [],
+    faceEdges: [],
+    models: [],
+    brushes: [],
+    brushSides: [],
+    ...overrides
+  };
+}
+
+// src/engine/rendering.ts
+var import_vitest15 = require("vitest");
 function createMockRenderingContext() {
   const gl = createMockWebGL2Context();
   const camera = {
-    update: import_vitest14.vi.fn(),
-    getViewMatrix: import_vitest14.vi.fn().mockReturnValue(new Float32Array(16)),
-    getProjectionMatrix: import_vitest14.vi.fn().mockReturnValue(new Float32Array(16)),
-    getViewProjectionMatrix: import_vitest14.vi.fn().mockReturnValue(new Float32Array(16)),
-    getPosition: import_vitest14.vi.fn().mockReturnValue([0, 0, 0]),
-    getForward: import_vitest14.vi.fn().mockReturnValue([0, 0, -1]),
-    getRight: import_vitest14.vi.fn().mockReturnValue([1, 0, 0]),
-    getUp: import_vitest14.vi.fn().mockReturnValue([0, 1, 0]),
-    extractFrustumPlanes: import_vitest14.vi.fn(),
+    update: import_vitest15.vi.fn(),
+    getViewMatrix: import_vitest15.vi.fn().mockReturnValue(new Float32Array(16)),
+    getProjectionMatrix: import_vitest15.vi.fn().mockReturnValue(new Float32Array(16)),
+    getViewProjectionMatrix: import_vitest15.vi.fn().mockReturnValue(new Float32Array(16)),
+    getPosition: import_vitest15.vi.fn().mockReturnValue([0, 0, 0]),
+    getForward: import_vitest15.vi.fn().mockReturnValue([0, 0, -1]),
+    getRight: import_vitest15.vi.fn().mockReturnValue([1, 0, 0]),
+    getUp: import_vitest15.vi.fn().mockReturnValue([0, 1, 0]),
+    extractFrustumPlanes: import_vitest15.vi.fn(),
     transform: {
       origin: [0, 0, 0],
       angles: [0, 0, 0],
@@ -3023,29 +3364,29 @@ function createMockRenderingContext() {
     }
   };
   const md2 = {
-    render: import_vitest14.vi.fn(),
-    init: import_vitest14.vi.fn(),
-    resize: import_vitest14.vi.fn()
+    render: import_vitest15.vi.fn(),
+    init: import_vitest15.vi.fn(),
+    resize: import_vitest15.vi.fn()
   };
   const bsp = {
-    render: import_vitest14.vi.fn(),
-    init: import_vitest14.vi.fn(),
-    resize: import_vitest14.vi.fn()
+    render: import_vitest15.vi.fn(),
+    init: import_vitest15.vi.fn(),
+    resize: import_vitest15.vi.fn()
   };
   const sprite = {
-    render: import_vitest14.vi.fn(),
-    init: import_vitest14.vi.fn(),
-    resize: import_vitest14.vi.fn()
+    render: import_vitest15.vi.fn(),
+    init: import_vitest15.vi.fn(),
+    resize: import_vitest15.vi.fn()
   };
   const poly = {
-    render: import_vitest14.vi.fn(),
-    init: import_vitest14.vi.fn(),
-    resize: import_vitest14.vi.fn()
+    render: import_vitest15.vi.fn(),
+    init: import_vitest15.vi.fn(),
+    resize: import_vitest15.vi.fn()
   };
   const particle = {
-    render: import_vitest14.vi.fn(),
-    init: import_vitest14.vi.fn(),
-    resize: import_vitest14.vi.fn()
+    render: import_vitest15.vi.fn(),
+    init: import_vitest15.vi.fn(),
+    resize: import_vitest15.vi.fn()
   };
   return {
     gl,
@@ -3198,6 +3539,207 @@ function captureAudioEvents(context) {
   return [];
 }
 
+// src/engine/helpers/webgpu-rendering.ts
+async function createRenderTestSetup(width = 256, height = 256) {
+  const setup = await initHeadlessWebGPU();
+  const { device } = setup;
+  const renderTarget = device.createTexture({
+    size: { width, height, depthOrArrayLayers: 1 },
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
+  });
+  const renderTargetView = renderTarget.createView();
+  const commandEncoder = device.createCommandEncoder();
+  const context = {
+    adapter: setup.adapter,
+    device: setup.device,
+    queue: setup.device.queue
+  };
+  return {
+    context,
+    renderTarget,
+    renderTargetView,
+    commandEncoder,
+    width,
+    height,
+    cleanup: async () => {
+      renderTarget.destroy();
+      await setup.cleanup();
+    }
+  };
+}
+async function renderAndCapture(setup, renderFn) {
+  const { device, queue } = setup.context;
+  const { renderTargetView, commandEncoder, width, height } = setup;
+  const passEncoder = commandEncoder.beginRenderPass({
+    colorAttachments: [
+      {
+        view: renderTargetView,
+        clearValue: { r: 0, g: 0, b: 0, a: 0 },
+        loadOp: "clear",
+        storeOp: "store"
+      }
+    ]
+  });
+  renderFn(passEncoder);
+  passEncoder.end();
+  const bytesPerPixel = 4;
+  const unpaddedBytesPerRow = width * bytesPerPixel;
+  const align = 256;
+  const paddedBytesPerRow = Math.max(
+    bytesPerPixel * width,
+    Math.ceil(bytesPerPixel * width / align) * align
+  );
+  const bufferSize = paddedBytesPerRow * height;
+  const readbackBuffer = device.createBuffer({
+    size: bufferSize,
+    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+  });
+  commandEncoder.copyTextureToBuffer(
+    {
+      texture: setup.renderTarget
+    },
+    {
+      buffer: readbackBuffer,
+      bytesPerRow: paddedBytesPerRow
+    },
+    {
+      width,
+      height,
+      depthOrArrayLayers: 1
+    }
+  );
+  queue.submit([commandEncoder.finish()]);
+  await readbackBuffer.mapAsync(GPUMapMode.READ);
+  const arrayBuffer = readbackBuffer.getMappedRange();
+  const output = new Uint8ClampedArray(width * height * 4);
+  const srcBytes = new Uint8Array(arrayBuffer);
+  for (let y = 0; y < height; y++) {
+    const srcOffset = y * paddedBytesPerRow;
+    const dstOffset = y * unpaddedBytesPerRow;
+    output.set(srcBytes.subarray(srcOffset, srcOffset + unpaddedBytesPerRow), dstOffset);
+  }
+  readbackBuffer.unmap();
+  readbackBuffer.destroy();
+  return output;
+}
+async function createComputeTestSetup(outputSize) {
+  const setup = await initHeadlessWebGPU();
+  const { device } = setup;
+  const outputBuffer = device.createBuffer({
+    size: outputSize,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+  });
+  const commandEncoder = device.createCommandEncoder();
+  const context = {
+    adapter: setup.adapter,
+    device: setup.device,
+    queue: setup.device.queue
+  };
+  return {
+    context,
+    outputBuffer,
+    commandEncoder,
+    outputSize,
+    cleanup: async () => {
+      outputBuffer.destroy();
+      await setup.cleanup();
+    }
+  };
+}
+async function runComputeAndReadback(setup, computeFn) {
+  const { device, queue } = setup.context;
+  const { outputBuffer, commandEncoder, outputSize } = setup;
+  const passEncoder = commandEncoder.beginComputePass();
+  computeFn(passEncoder);
+  passEncoder.end();
+  const stagingBuffer = device.createBuffer({
+    size: outputSize,
+    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+  });
+  commandEncoder.copyBufferToBuffer(
+    outputBuffer,
+    0,
+    stagingBuffer,
+    0,
+    outputSize
+  );
+  queue.submit([commandEncoder.finish()]);
+  await stagingBuffer.mapAsync(GPUMapMode.READ);
+  const mappedRange = stagingBuffer.getMappedRange();
+  const result = mappedRange.slice(0);
+  stagingBuffer.unmap();
+  stagingBuffer.destroy();
+  return result;
+}
+
+// src/engine/helpers/pipeline-test-template.ts
+var import_vitest16 = require("vitest");
+async function testPipelineRendering(name, createPipeline, setupGeometry, expectedOutput) {
+  const setup = await createRenderTestSetup(256, 256);
+  try {
+    const pipeline = createPipeline(setup.context.device);
+    const geometry = setupGeometry(setup.context.device);
+    const pixels = await renderAndCapture(setup, (pass) => {
+      pass.setPipeline(pipeline);
+      pass.setVertexBuffer(0, geometry.vertexBuffer);
+      if (geometry.indexBuffer) {
+        pass.setIndexBuffer(geometry.indexBuffer, "uint16");
+        pass.drawIndexed(geometry.indexCount || 0);
+      } else {
+        pass.draw(geometry.vertexCount);
+      }
+    });
+    if (expectedOutput) {
+      (0, import_vitest16.expect)(pixels).toEqual(expectedOutput);
+    } else {
+      (0, import_vitest16.expect)(pixels.length).toBe(256 * 256 * 4);
+    }
+  } finally {
+    await setup.cleanup();
+  }
+}
+async function testComputeShader(name, createComputePipeline, inputData, expectedOutput) {
+  const setup = await createComputeTestSetup(inputData.byteLength);
+  const { device } = setup.context;
+  try {
+    const pipeline = createComputePipeline(device);
+    const stagingBuffer = device.createBuffer({
+      size: inputData.byteLength,
+      usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
+      mappedAtCreation: true
+    });
+    new Float32Array(stagingBuffer.getMappedRange()).set(inputData);
+    stagingBuffer.unmap();
+    const encoder = device.createCommandEncoder();
+    encoder.copyBufferToBuffer(stagingBuffer, 0, setup.outputBuffer, 0, inputData.byteLength);
+    device.queue.submit([encoder.finish()]);
+    const bindGroup = device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        {
+          binding: 0,
+          resource: {
+            buffer: setup.outputBuffer
+          }
+        }
+      ]
+    });
+    const resultBuffer = await runComputeAndReadback(setup, (pass) => {
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bindGroup);
+      pass.dispatchWorkgroups(Math.ceil(inputData.length / 64));
+    });
+    if (expectedOutput) {
+      const floatResult = new Float32Array(resultBuffer);
+      (0, import_vitest16.expect)(floatResult).toEqual(expectedOutput);
+    }
+    stagingBuffer.destroy();
+  } finally {
+    await setup.cleanup();
+  }
+}
+
 // ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/common.js
 var EPSILON = 1e-6;
 var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
@@ -3218,7 +3760,7 @@ __export(vec3_exports, {
   ceil: () => ceil,
   clone: () => clone,
   copy: () => copy,
-  create: () => create,
+  create: () => create2,
   cross: () => cross,
   dist: () => dist,
   distance: () => distance,
@@ -3262,7 +3804,7 @@ __export(vec3_exports, {
   transformQuat: () => transformQuat,
   zero: () => zero
 });
-function create() {
+function create2() {
   var out = new ARRAY_TYPE(3);
   if (ARRAY_TYPE != Float32Array) {
     out[0] = 0;
@@ -3574,7 +4116,7 @@ var sqrDist = squaredDistance;
 var len = length;
 var sqrLen = squaredLength;
 var forEach = (function() {
-  var vec = create();
+  var vec = create2();
   return function(a, stride, offset, count, fn, arg) {
     var i, l;
     if (!stride) {
@@ -3697,7 +4239,7 @@ function simulateCameraMovement(camera, input, deltaTime) {
 }
 
 // src/client/helpers/hud.ts
-var import_vitest15 = require("vitest");
+var import_vitest17 = require("vitest");
 function createMockHudState(overrides) {
   const defaultPs = {
     damageAlpha: 0,
@@ -3732,11 +4274,11 @@ function createMockHudState(overrides) {
     batches: 10
   };
   const defaultMessages = {
-    drawCenterPrint: import_vitest15.vi.fn(),
-    drawNotifications: import_vitest15.vi.fn(),
-    addCenterPrint: import_vitest15.vi.fn(),
-    addNotification: import_vitest15.vi.fn(),
-    clear: import_vitest15.vi.fn()
+    drawCenterPrint: import_vitest17.vi.fn(),
+    drawNotifications: import_vitest17.vi.fn(),
+    addCenterPrint: import_vitest17.vi.fn(),
+    addNotification: import_vitest17.vi.fn(),
+    clear: import_vitest17.vi.fn()
   };
   return {
     ps: overrides?.ps ?? defaultPs,
@@ -3752,7 +4294,7 @@ function createMockHudState(overrides) {
 function createMockScoreboard(players = []) {
   return {
     players,
-    draw: import_vitest15.vi.fn()
+    draw: import_vitest17.vi.fn()
   };
 }
 function createMockChatMessage(text, sender, timestamp = Date.now()) {
@@ -3850,6 +4392,254 @@ function createMockFogData(overrides = {}) {
   };
 }
 
+// src/client/mocks/download.ts
+var import_vitest18 = require("vitest");
+function createMockDownloadManager(overrides) {
+  return {
+    download: import_vitest18.vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+    cancel: import_vitest18.vi.fn(),
+    getProgress: import_vitest18.vi.fn().mockReturnValue(0),
+    ...overrides
+  };
+}
+function createMockPrecacheList(models = [], sounds = [], images = []) {
+  return {
+    models,
+    sounds,
+    images
+  };
+}
+async function simulateDownload(url, progressCallback) {
+  const steps = 10;
+  for (let i = 0; i <= steps; i++) {
+    if (progressCallback) {
+      progressCallback(i / steps);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  return new ArrayBuffer(1024);
+}
+
+// src/client/mocks/state.ts
+var MAX_MODELS = 256;
+var MAX_SOUNDS = 256;
+var MAX_IMAGES = 256;
+var MockClientConfigStrings = class {
+  constructor() {
+    this.strings = /* @__PURE__ */ new Map();
+    this.models = [];
+    this.sounds = [];
+    this.images = [];
+  }
+  set(index, value) {
+    this.strings.set(index, value);
+    if (index >= 32 /* Models */ && index < 32 /* Models */ + MAX_MODELS) {
+      this.models[index - 32 /* Models */] = value;
+    } else if (index >= 288 /* Sounds */ && index < 288 /* Sounds */ + MAX_SOUNDS) {
+      this.sounds[index - 288 /* Sounds */] = value;
+    } else if (index >= 544 /* Images */ && index < 544 /* Images */ + MAX_IMAGES) {
+      this.images[index - 544 /* Images */] = value;
+    }
+  }
+  get(index) {
+    return this.strings.get(index);
+  }
+  getModelName(index) {
+    return this.models[index];
+  }
+  getSoundName(index) {
+    return this.sounds[index];
+  }
+  getImageName(index) {
+    return this.images[index];
+  }
+  getPlayerName(playernum) {
+    const info = this.strings.get(800 /* Players */ + playernum);
+    if (!info) return void 0;
+    const parts = info.split("\\");
+    for (let i = 1; i < parts.length; i += 2) {
+      if (parts[i] === "name") {
+        return parts[i + 1];
+      }
+    }
+    return void 0;
+  }
+  clear() {
+    this.strings.clear();
+    this.models.length = 0;
+    this.sounds.length = 0;
+    this.images.length = 0;
+  }
+};
+var createMockClientState = (overrides) => {
+  const configStrings = new MockClientConfigStrings();
+  return {
+    tickRate: 10,
+    frameTimeMs: 100,
+    serverFrame: 0,
+    serverProtocol: 34,
+    configStrings,
+    playerNum: 0,
+    serverTime: 0,
+    parseEntities: 0,
+    inAutoDemo: false,
+    getClientName: (num) => `Player${num}`,
+    getKeyBinding: (key) => "",
+    ...overrides
+  };
+};
+var createMockFrame = (overrides) => ({
+  serverFrame: 0,
+  deltaFrame: -1,
+  valid: true,
+  entities: [],
+  ...overrides
+});
+var createMockClientInfo = (overrides) => ({
+  name: "Player",
+  skin: "male/grunt",
+  model: "male",
+  icon: "pics/icon.pcx",
+  ...overrides
+});
+var createMockConnectionState = (state = "connected") => ({
+  state
+});
+
+// src/client/mocks/console.ts
+var import_vitest19 = require("vitest");
+function createMockConsole(overrides) {
+  const history = [];
+  const errors = [];
+  const commands = {};
+  const cvars = {};
+  return {
+    print: import_vitest19.vi.fn((text) => {
+      history.push(text);
+    }),
+    error: import_vitest19.vi.fn((text) => {
+      errors.push(text);
+    }),
+    execute: import_vitest19.vi.fn((text) => {
+      const parts = text.trim().split(/\s+/);
+      const cmd = parts[0];
+      const args = parts.slice(1);
+      if (commands[cmd]) {
+        commands[cmd](args);
+      } else {
+        history.push(`Unknown command "${cmd}"`);
+      }
+    }),
+    addCommand: import_vitest19.vi.fn((name, handler) => {
+      commands[name] = handler;
+    }),
+    getCvar: import_vitest19.vi.fn((name) => cvars[name]),
+    setCvar: import_vitest19.vi.fn((name, value) => {
+      cvars[name] = value;
+    }),
+    getHistory: () => history,
+    clearHistory: () => {
+      history.length = 0;
+      errors.length = 0;
+    },
+    getErrors: () => errors,
+    ...overrides
+  };
+}
+function createMockCommand(name, handler) {
+  return { name, handler };
+}
+function createMockCvarRegistry(initialCvars) {
+  return { ...initialCvars };
+}
+
+// src/client/helpers/prediction.ts
+var createPredictionTestScenario = (lagMs = 100) => {
+  const clientState = createMockClientState({
+    playerNum: 0,
+    serverTime: 1e3,
+    getClientName: (num) => "TestPlayer"
+  });
+  const snapshots = [];
+  for (let i = 0; i < 5; i++) {
+    const frameEntities = [
+      {
+        number: 1,
+        origin: { x: i * 10, y: 0, z: 0 },
+        angles: { x: 0, y: 0, z: 0 },
+        oldOrigin: { x: (i - 1) * 10, 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
+      }
+    ];
+    snapshots.push(frameEntities);
+  }
+  return {
+    clientState,
+    snapshots,
+    lagMs
+  };
+};
+var simulateClientPrediction = (state, input, deltaTime) => {
+  return {
+    ...state,
+    serverTime: state.serverTime + deltaTime * 1e3
+  };
+};
+var createInterpolationTestData = (startState, endState, steps = 10) => {
+  const result = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const lerp2 = (a, b) => a + (b - a) * t;
+    result.push({
+      ...startState,
+      origin: {
+        x: lerp2(startState.origin.x, endState.origin.x),
+        y: lerp2(startState.origin.y, endState.origin.y),
+        z: lerp2(startState.origin.z, endState.origin.z)
+      },
+      angles: {
+        x: lerp2(startState.angles.x, endState.angles.x),
+        y: lerp2(startState.angles.y, endState.angles.y),
+        z: lerp2(startState.angles.z, endState.angles.z)
+      }
+    });
+  }
+  return result;
+};
+var verifySmoothing = (states) => {
+  let maxError = 0;
+  let totalError = 0;
+  const jumps = [];
+  for (let i = 1; i < states.length; i++) {
+    const prev = states[i - 1].origin;
+    const curr = states[i].origin;
+    const dx = curr.x - prev.x;
+    const dy = curr.y - prev.y;
+    const dz = curr.z - prev.z;
+    const dist2 = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (dist2 > 50) {
+      jumps.push(i);
+    }
+    totalError += dist2;
+  }
+  return {
+    smooth: jumps.length === 0,
+    maxError,
+    averageError: totalError / (states.length - 1 || 1),
+    jumps
+  };
+};
+
 // src/e2e/playwright.ts
 async function createPlaywrightTestClient(options = {}) {
   let playwright;
@@ -4043,6 +4833,7 @@ function createVisualTestScenario(sceneName) {
   HandshakeStage,
   InputInjector,
   MockAudioBufferSourceNode,
+  MockClientConfigStrings,
   MockNetDriver,
   MockNetworkTransport,
   MockPointerLock,
@@ -4059,6 +4850,7 @@ function createVisualTestScenario(sceneName) {
   createBinaryWriterMock,
   createBounds,
   createCombatTestContext,
+  createComputeTestSetup,
   createConfigStringArrayMock,
   createConfigStringMock,
   createControlledTimer,
@@ -4069,33 +4861,49 @@ function createVisualTestScenario(sceneName) {
   createEntityFactory,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
+  createHeadlessTestContext,
   createInputInjector,
+  createInterpolationTestData,
   createItemEntityFactory,
   createMessageReaderMock,
   createMessageWriterMock,
   createMockAI,
   createMockAmmoItem,
   createMockArmorItem,
+  createMockAssetManager,
   createMockAudioBuffer,
   createMockAudioContext,
+  createMockBspMap,
   createMockBspPipeline,
   createMockBufferSource,
   createMockCamera,
   createMockCanvas,
   createMockCanvasContext2D,
   createMockChatMessage,
+  createMockClientInfo,
+  createMockClientState,
   createMockCollisionEntityIndex,
+  createMockCommand,
+  createMockCommandEncoder,
+  createMockComputePassEncoder,
+  createMockComputePipeline,
   createMockConnection,
+  createMockConnectionState,
+  createMockConsole,
+  createMockCvarRegistry,
   createMockDamageIndicator,
   createMockDamageInfo,
   createMockDeltaFrame,
+  createMockDownloadManager,
   createMockEngine,
   createMockEntityState,
   createMockFogData,
+  createMockFrame,
   createMockFrameRenderer,
   createMockGPUAdapter,
-  createMockGPUCanvasContext,
+  createMockGPUBuffer,
   createMockGPUDevice,
+  createMockGPUTexture,
   createMockGame,
   createMockGameExports,
   createMockGameState,
@@ -4110,7 +4918,9 @@ function createVisualTestScenario(sceneName) {
   createMockKeyboardEvent,
   createMockLocalStorage,
   createMockMasterServer,
+  createMockMd2Model,
   createMockMd2Pipeline,
+  createMockMd3Model,
   createMockMd3Pipeline,
   createMockMonsterAI,
   createMockMonsterMove,
@@ -4122,12 +4932,17 @@ function createVisualTestScenario(sceneName) {
   createMockPerformance,
   createMockPointerLock,
   createMockPowerupItem,
+  createMockPrecacheList,
+  createMockQueue,
   createMockRAF,
   createMockRConClient,
   createMockRateLimiter,
   createMockRefDef,
+  createMockRenderPassEncoder,
+  createMockRenderPipeline,
   createMockRenderer,
   createMockRenderingContext,
+  createMockSampler,
   createMockScoreboard,
   createMockServer,
   createMockServerClient,
@@ -4137,9 +4952,12 @@ function createVisualTestScenario(sceneName) {
   createMockServerState,
   createMockServerStatic,
   createMockSessionStorage,
+  createMockShaderModule,
   createMockSkyboxPipeline,
   createMockSnapshot,
   createMockSpritePipeline,
+  createMockTexture,
+  createMockTextureView,
   createMockTransport,
   createMockUDPSocket,
   createMockUserInfo,
@@ -4147,6 +4965,7 @@ function createVisualTestScenario(sceneName) {
   createMockWeapon,
   createMockWeaponItem,
   createMockWebGL2Context,
+  createMockWebGPUContext,
   createMockWheelEvent,
   createMonsterEntityFactory,
   createMultiplayerTestScenario,
@@ -4157,7 +4976,9 @@ function createVisualTestScenario(sceneName) {
   createPlayerEntityFactory,
   createPlayerStateFactory,
   createPlaywrightTestClient,
+  createPredictionTestScenario,
   createProjectileEntityFactory,
+  createRenderTestSetup,
   createServerSnapshot,
   createSpawnTestContext,
   createStorageTestScenario,
@@ -4169,6 +4990,7 @@ function createVisualTestScenario(sceneName) {
   createVector3,
   createViewTestScenario,
   createVisualTestScenario,
+  initHeadlessWebGPU,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -4181,6 +5003,8 @@ function createVisualTestScenario(sceneName) {
   measureSnapshotSize,
   mockMonsterAttacks,
   randomVector3,
+  renderAndCapture,
+  runComputeAndReadback,
   serializeUserInfo,
   setupBrowserEnvironment,
   setupMockAudioContext,
@@ -4188,6 +5012,8 @@ function createVisualTestScenario(sceneName) {
   setupWebGPUMocks,
   simulateBandwidthLimit,
   simulateCameraMovement,
+  simulateClientPrediction,
+  simulateDownload,
   simulateFrames,
   simulateGravity,
   simulateHandshake,
@@ -4208,7 +5034,10 @@ function createVisualTestScenario(sceneName) {
   teardownBrowserEnvironment,
   teardownMockAudioContext,
   teardownNodeEnvironment,
+  testComputeShader,
+  testPipelineRendering,
   throttleBandwidth,
+  verifySmoothing,
   verifySnapshotConsistency,
   waitForGameReady
 });