quake2ts 0.0.621 → 0.0.629

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

@@ -2317,99 +2317,280 @@ function createMockImage(width = 100, height = 100, src = "") {
   return img;
 }
 
-// src/engine/mocks/webgpu.ts
-import { vi as vi12 } from "vitest";
-function createMockGPUAdapter() {
-  return {
-    features: /* @__PURE__ */ new Set(),
-    limits: {
-      maxTextureDimension2D: 8192,
-      maxBindGroups: 4,
-      maxUniformBufferBindingSize: 65536,
-      maxStorageBufferBindingSize: 134217728
-    },
-    requestDevice: vi12.fn().mockResolvedValue(createMockGPUDevice())
-  };
-}
-function createMockGPUDevice() {
+// ../../node_modules/.pnpm/webgpu@0.3.8/node_modules/webgpu/index.js
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var isMac = process.platform === "darwin";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var arch = isMac ? "universal" : process.arch;
+var dawnNodePath = 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: vi12.fn(),
-    createBindGroupLayout: vi12.fn(),
-    createPipelineLayout: vi12.fn(),
-    createRenderPipeline: vi12.fn(),
-    createCommandEncoder: vi12.fn().mockReturnValue({
-      copyTextureToBuffer: vi12.fn(),
-      finish: vi12.fn()
-    }),
-    createBuffer: vi12.fn(),
-    createTexture: vi12.fn().mockReturnValue({
-      createView: vi12.fn()
-    }),
-    queue: {
-      submit: vi12.fn(),
-      writeBuffer: vi12.fn(),
-      writeTexture: vi12.fn()
+    adapter,
+    device,
+    cleanup: async () => {
+      device.destroy();
     }
   };
 }
-function createMockGPUCanvasContext() {
+async function createHeadlessTestContext() {
+  const { adapter, device } = await initHeadlessWebGPU();
   return {
-    configure: vi12.fn(),
-    getCurrentTexture: vi12.fn()
+    adapter,
+    device,
+    queue: device.queue
   };
 }
+
+// src/engine/mocks/webgpu.ts
+import { vi as vi12 } from "vitest";
 function setupWebGPUMocks() {
-  const mockAdapter = createMockGPUAdapter();
+  Object.assign(globalThis, globals);
   const mockGpu = {
-    requestAdapter: vi12.fn().mockResolvedValue(mockAdapter),
+    requestAdapter: vi12.fn(),
     getPreferredCanvasFormat: vi12.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: vi12.fn().mockResolvedValue(createMockGPUDevice()),
+    requestAdapterInfo: vi12.fn().mockResolvedValue({}),
+    ...options
+  };
+}
+function createMockGPUDevice(features = /* @__PURE__ */ new Set()) {
+  const queue = createMockQueue();
+  return {
+    features,
+    limits: {},
+    queue,
+    destroy: vi12.fn(),
+    createBuffer: vi12.fn((descriptor) => createMockGPUBuffer(descriptor)),
+    createTexture: vi12.fn((descriptor) => createMockGPUTexture(descriptor)),
+    createSampler: vi12.fn(() => createMockSampler()),
+    createBindGroupLayout: vi12.fn(() => ({ label: "mock-bind-group-layout" })),
+    createPipelineLayout: vi12.fn(() => ({ label: "mock-pipeline-layout" })),
+    createBindGroup: vi12.fn(() => ({ label: "mock-bind-group" })),
+    createShaderModule: vi12.fn((descriptor) => createMockShaderModule(descriptor)),
+    createComputePipeline: vi12.fn(() => createMockComputePipeline()),
+    createRenderPipeline: vi12.fn(() => createMockRenderPipeline()),
+    createComputePipelineAsync: vi12.fn().mockResolvedValue(createMockComputePipeline()),
+    createRenderPipelineAsync: vi12.fn().mockResolvedValue(createMockRenderPipeline()),
+    createCommandEncoder: vi12.fn(() => createMockCommandEncoder()),
+    createQuerySet: vi12.fn(() => ({ label: "mock-query-set" })),
+    pushErrorScope: vi12.fn(),
+    popErrorScope: vi12.fn().mockResolvedValue(null),
+    addEventListener: vi12.fn(),
+    removeEventListener: vi12.fn(),
+    dispatchEvent: vi12.fn(),
+    onuncapturederror: null,
+    label: "",
+    lost: Promise.resolve({ reason: "destroyed", message: "Device lost" })
+  };
+}
+function createMockQueue() {
+  return {
+    submit: vi12.fn(),
+    onSubmittedWorkDone: vi12.fn().mockResolvedValue(void 0),
+    writeBuffer: vi12.fn(),
+    writeTexture: vi12.fn(),
+    copyExternalImageToTexture: vi12.fn(),
+    label: ""
+  };
+}
+function createMockGPUBuffer(descriptor) {
+  return {
+    size: descriptor.size,
+    usage: descriptor.usage,
+    mapState: "unmapped",
+    mapAsync: vi12.fn().mockResolvedValue(void 0),
+    getMappedRange: vi12.fn(() => new ArrayBuffer(descriptor.size)),
+    unmap: vi12.fn(),
+    destroy: vi12.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: vi12.fn(() => createMockTextureView()),
+    destroy: vi12.fn(),
+    label: descriptor.label || ""
+  };
+}
+function createMockTextureView() {
+  return {
+    label: ""
+  };
+}
+function createMockSampler() {
+  return {
+    label: ""
+  };
+}
+function createMockShaderModule(descriptor) {
+  return {
+    getCompilationInfo: vi12.fn().mockResolvedValue({ messages: [] }),
+    label: descriptor.label || ""
+  };
+}
+function createMockComputePipeline() {
+  return {
+    getBindGroupLayout: vi12.fn(() => ({ label: "mock-bind-group-layout" })),
+    label: ""
+  };
+}
+function createMockRenderPipeline() {
+  return {
+    getBindGroupLayout: vi12.fn(() => ({ label: "mock-bind-group-layout" })),
+    label: ""
+  };
+}
+function createMockCommandEncoder() {
+  return {
+    beginRenderPass: vi12.fn(() => createMockRenderPassEncoder()),
+    beginComputePass: vi12.fn(() => createMockComputePassEncoder()),
+    copyBufferToBuffer: vi12.fn(),
+    copyBufferToTexture: vi12.fn(),
+    copyTextureToBuffer: vi12.fn(),
+    copyTextureToTexture: vi12.fn(),
+    clearBuffer: vi12.fn(),
+    writeTimestamp: vi12.fn(),
+    resolveQuerySet: vi12.fn(),
+    finish: vi12.fn(() => ({ label: "mock-command-buffer" })),
+    pushDebugGroup: vi12.fn(),
+    popDebugGroup: vi12.fn(),
+    insertDebugMarker: vi12.fn(),
+    label: ""
+  };
+}
+function createMockRenderPassEncoder() {
+  return {
+    setPipeline: vi12.fn(),
+    setIndexBuffer: vi12.fn(),
+    setVertexBuffer: vi12.fn(),
+    setBindGroup: vi12.fn(),
+    setViewport: vi12.fn(),
+    setScissorRect: vi12.fn(),
+    setBlendConstant: vi12.fn(),
+    setStencilReference: vi12.fn(),
+    beginOcclusionQuery: vi12.fn(),
+    endOcclusionQuery: vi12.fn(),
+    executeBundles: vi12.fn(),
+    draw: vi12.fn(),
+    drawIndexed: vi12.fn(),
+    drawIndirect: vi12.fn(),
+    drawIndexedIndirect: vi12.fn(),
+    end: vi12.fn(),
+    pushDebugGroup: vi12.fn(),
+    popDebugGroup: vi12.fn(),
+    insertDebugMarker: vi12.fn(),
+    label: ""
+  };
+}
+function createMockComputePassEncoder() {
+  return {
+    setPipeline: vi12.fn(),
+    setBindGroup: vi12.fn(),
+    dispatchWorkgroups: vi12.fn(),
+    dispatchWorkgroupsIndirect: vi12.fn(),
+    end: vi12.fn(),
+    pushDebugGroup: vi12.fn(),
+    popDebugGroup: vi12.fn(),
+    insertDebugMarker: vi12.fn(),
+    label: ""
+  };
+}
+function createMockWebGPUContext() {
+  const adapter = createMockGPUAdapter();
+  const device = createMockGPUDevice();
+  return {
+    adapter,
+    device,
+    queue: device.queue
   };
 }
 
@@ -2813,20 +2994,140 @@ function createMockSkyboxPipeline(overrides) {
   };
 }
 
-// src/engine/rendering.ts
+// src/engine/mocks/assets.ts
 import { vi as vi14 } from "vitest";
+function createMockAssetManager(overrides) {
+  return {
+    textures: {
+      get: vi14.fn(),
+      set: vi14.fn(),
+      has: vi14.fn(),
+      clear: vi14.fn(),
+      memoryUsage: 0
+    },
+    audio: {
+      load: vi14.fn(),
+      get: vi14.fn(),
+      clearAll: vi14.fn()
+    },
+    loadTexture: vi14.fn().mockResolvedValue({}),
+    registerTexture: vi14.fn(),
+    loadSound: vi14.fn().mockResolvedValue({}),
+    loadMd2Model: vi14.fn().mockResolvedValue({}),
+    getMd2Model: vi14.fn(),
+    loadMd3Model: vi14.fn().mockResolvedValue({}),
+    getMd3Model: vi14.fn(),
+    loadSprite: vi14.fn().mockResolvedValue({}),
+    loadMap: vi14.fn().mockResolvedValue({}),
+    getMap: vi14.fn(),
+    loadPalette: vi14.fn().mockResolvedValue(void 0),
+    isAssetLoaded: vi14.fn().mockReturnValue(true),
+    listFiles: vi14.fn().mockReturnValue([]),
+    resetForLevelChange: vi14.fn(),
+    getMemoryUsage: vi14.fn().mockReturnValue({ textures: 0, audio: 0 }),
+    clearCache: vi14.fn(),
+    preloadAssets: vi14.fn().mockResolvedValue(void 0),
+    queueLoad: vi14.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
+import { vi as vi15 } from "vitest";
 function createMockRenderingContext() {
   const gl = createMockWebGL2Context();
   const camera = {
-    update: vi14.fn(),
-    getViewMatrix: vi14.fn().mockReturnValue(new Float32Array(16)),
-    getProjectionMatrix: vi14.fn().mockReturnValue(new Float32Array(16)),
-    getViewProjectionMatrix: vi14.fn().mockReturnValue(new Float32Array(16)),
-    getPosition: vi14.fn().mockReturnValue([0, 0, 0]),
-    getForward: vi14.fn().mockReturnValue([0, 0, -1]),
-    getRight: vi14.fn().mockReturnValue([1, 0, 0]),
-    getUp: vi14.fn().mockReturnValue([0, 1, 0]),
-    extractFrustumPlanes: vi14.fn(),
+    update: vi15.fn(),
+    getViewMatrix: vi15.fn().mockReturnValue(new Float32Array(16)),
+    getProjectionMatrix: vi15.fn().mockReturnValue(new Float32Array(16)),
+    getViewProjectionMatrix: vi15.fn().mockReturnValue(new Float32Array(16)),
+    getPosition: vi15.fn().mockReturnValue([0, 0, 0]),
+    getForward: vi15.fn().mockReturnValue([0, 0, -1]),
+    getRight: vi15.fn().mockReturnValue([1, 0, 0]),
+    getUp: vi15.fn().mockReturnValue([0, 1, 0]),
+    extractFrustumPlanes: vi15.fn(),
     transform: {
       origin: [0, 0, 0],
       angles: [0, 0, 0],
@@ -2834,29 +3135,29 @@ function createMockRenderingContext() {
     }
   };
   const md2 = {
-    render: vi14.fn(),
-    init: vi14.fn(),
-    resize: vi14.fn()
+    render: vi15.fn(),
+    init: vi15.fn(),
+    resize: vi15.fn()
   };
   const bsp = {
-    render: vi14.fn(),
-    init: vi14.fn(),
-    resize: vi14.fn()
+    render: vi15.fn(),
+    init: vi15.fn(),
+    resize: vi15.fn()
   };
   const sprite = {
-    render: vi14.fn(),
-    init: vi14.fn(),
-    resize: vi14.fn()
+    render: vi15.fn(),
+    init: vi15.fn(),
+    resize: vi15.fn()
   };
   const poly = {
-    render: vi14.fn(),
-    init: vi14.fn(),
-    resize: vi14.fn()
+    render: vi15.fn(),
+    init: vi15.fn(),
+    resize: vi15.fn()
   };
   const particle = {
-    render: vi14.fn(),
-    init: vi14.fn(),
-    resize: vi14.fn()
+    render: vi15.fn(),
+    init: vi15.fn(),
+    resize: vi15.fn()
   };
   return {
     gl,
@@ -3009,6 +3310,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
+import { expect } from "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) {
+      expect(pixels).toEqual(expectedOutput);
+    } else {
+      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);
+      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;
@@ -3029,7 +3531,7 @@ __export(vec3_exports, {
   ceil: () => ceil,
   clone: () => clone,
   copy: () => copy,
-  create: () => create,
+  create: () => create2,
   cross: () => cross,
   dist: () => dist,
   distance: () => distance,
@@ -3073,7 +3575,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;
@@ -3385,7 +3887,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) {
@@ -3508,7 +4010,7 @@ function simulateCameraMovement(camera, input, deltaTime) {
 }
 
 // src/client/helpers/hud.ts
-import { vi as vi15 } from "vitest";
+import { vi as vi16 } from "vitest";
 function createMockHudState(overrides) {
   const defaultPs = {
     damageAlpha: 0,
@@ -3543,11 +4045,11 @@ function createMockHudState(overrides) {
     batches: 10
   };
   const defaultMessages = {
-    drawCenterPrint: vi15.fn(),
-    drawNotifications: vi15.fn(),
-    addCenterPrint: vi15.fn(),
-    addNotification: vi15.fn(),
-    clear: vi15.fn()
+    drawCenterPrint: vi16.fn(),
+    drawNotifications: vi16.fn(),
+    addCenterPrint: vi16.fn(),
+    addNotification: vi16.fn(),
+    clear: vi16.fn()
   };
   return {
     ps: overrides?.ps ?? defaultPs,
@@ -3563,7 +4065,7 @@ function createMockHudState(overrides) {
 function createMockScoreboard(players = []) {
   return {
     players,
-    draw: vi15.fn()
+    draw: vi16.fn()
   };
 }
 function createMockChatMessage(text, sender, timestamp = Date.now()) {
@@ -3664,6 +4166,254 @@ function createMockFogData(overrides = {}) {
   };
 }
 
+// src/client/mocks/download.ts
+import { vi as vi17 } from "vitest";
+function createMockDownloadManager(overrides) {
+  return {
+    download: vi17.fn().mockResolvedValue(new ArrayBuffer(0)),
+    cancel: vi17.fn(),
+    getProgress: vi17.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
+import { vi as vi18 } from "vitest";
+function createMockConsole(overrides) {
+  const history = [];
+  const errors = [];
+  const commands = {};
+  const cvars = {};
+  return {
+    print: vi18.fn((text) => {
+      history.push(text);
+    }),
+    error: vi18.fn((text) => {
+      errors.push(text);
+    }),
+    execute: vi18.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: vi18.fn((name, handler) => {
+      commands[name] = handler;
+    }),
+    getCvar: vi18.fn((name) => cvars[name]),
+    setCvar: vi18.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;
@@ -3856,6 +4606,7 @@ export {
   HandshakeStage,
   InputInjector,
   FakeBufferSource as MockAudioBufferSourceNode,
+  MockClientConfigStrings,
   MockNetDriver,
   MockNetworkTransport,
   MockPointerLock,
@@ -3872,6 +4623,7 @@ export {
   createBinaryWriterMock,
   createBounds,
   createCombatTestContext,
+  createComputeTestSetup,
   createConfigStringArrayMock,
   createConfigStringMock,
   createControlledTimer,
@@ -3882,33 +4634,49 @@ export {
   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,
@@ -3923,7 +4691,9 @@ export {
   createMockKeyboardEvent,
   createMockLocalStorage,
   createMockMasterServer,
+  createMockMd2Model,
   createMockMd2Pipeline,
+  createMockMd3Model,
   createMockMd3Pipeline,
   createMockMonsterAI,
   createMockMonsterMove,
@@ -3935,12 +4705,17 @@ export {
   createMockPerformance,
   createMockPointerLock,
   createMockPowerupItem,
+  createMockPrecacheList,
+  createMockQueue,
   createMockRAF,
   createMockRConClient,
   createMockRateLimiter,
   createMockRefDef,
+  createMockRenderPassEncoder,
+  createMockRenderPipeline,
   createMockRenderer,
   createMockRenderingContext,
+  createMockSampler,
   createMockScoreboard,
   createMockServer,
   createMockServerClient,
@@ -3950,9 +4725,12 @@ export {
   createMockServerState,
   createMockServerStatic,
   createMockSessionStorage,
+  createMockShaderModule,
   createMockSkyboxPipeline,
   createMockSnapshot,
   createMockSpritePipeline,
+  createMockTexture,
+  createMockTextureView,
   createMockTransport,
   createMockUDPSocket,
   createMockUserInfo,
@@ -3960,6 +4738,7 @@ export {
   createMockWeapon,
   createMockWeaponItem,
   createMockWebGL2Context,
+  createMockWebGPUContext,
   createMockWheelEvent,
   createMonsterEntityFactory,
   createMultiplayerTestScenario,
@@ -3970,7 +4749,9 @@ export {
   createPlayerEntityFactory,
   createPlayerStateFactory,
   createPlaywrightTestClient,
+  createPredictionTestScenario,
   createProjectileEntityFactory,
+  createRenderTestSetup,
   createServerSnapshot,
   createSpawnTestContext,
   createStorageTestScenario,
@@ -3982,6 +4763,7 @@ export {
   createVector3,
   createViewTestScenario,
   createVisualTestScenario,
+  initHeadlessWebGPU,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -3994,6 +4776,8 @@ export {
   measureSnapshotSize,
   mockMonsterAttacks,
   randomVector3,
+  renderAndCapture,
+  runComputeAndReadback,
   serializeUserInfo,
   setupBrowserEnvironment,
   setupMockAudioContext,
@@ -4001,6 +4785,8 @@ export {
   setupWebGPUMocks,
   simulateBandwidthLimit,
   simulateCameraMovement,
+  simulateClientPrediction,
+  simulateDownload,
   simulateFrames,
   simulateGravity,
   simulateHandshake,
@@ -4021,7 +4807,10 @@ export {
   teardownBrowserEnvironment,
   teardownMockAudioContext,
   teardownNodeEnvironment,
+  testComputeShader,
+  testPipelineRendering,
   throttleBandwidth,
+  verifySmoothing,
   verifySnapshotConsistency,
   waitForGameReady
 };