@quake2ts/server 0.0.1

package/tests/dedicated.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DedicatedServer } from '../src/dedicated.js';
+import { createGame, GameExports } from '@quake2ts/game';
+import { ClientState } from '../src/client.js';
+import { UPDATE_BACKUP } from '@quake2ts/shared';
+import {
+    createMockTransport,
+    MockTransport,
+    createMockServerClient,
+    createMockGameExports,
+    createGameStateSnapshotFactory,
+    createServerSnapshot
+} from '@quake2ts/test-utils';
+
+// Mock dependencies
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: vi.fn().mockResolvedValue(Buffer.from([0])),
+  },
+}));
+vi.mock('@quake2ts/engine', () => ({
+  parseBsp: vi.fn().mockReturnValue({
+        planes: [],
+        nodes: [],
+        leafs: [],
+        brushes: [],
+        models: [],
+        leafLists: { leafBrushes: [] },
+        texInfo: [],
+        brushSides: [],
+        visibility: { numClusters: 0, clusters: [] }
+  }),
+}));
+vi.mock('@quake2ts/game', () => ({
+  createGame: vi.fn(),
+  createPlayerInventory: vi.fn(),
+  createPlayerWeaponStates: vi.fn(),
+}));
+
+const FRAME_TIME_MS = 100; // 10Hz
+
+describe('DedicatedServer', () => {
+  let server: DedicatedServer;
+  let mockGame: GameExports;
+  let consoleLogSpy: any;
+  let consoleWarnSpy: any;
+  let transport: MockTransport;
+
+  beforeEach(async () => {
+    // Only fake specific timers to avoid blocking internal promises/fs mocks
+    vi.useFakeTimers({
+        toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date']
+    });
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    mockGame = createMockGameExports({
+      clientBegin: vi.fn(() => ({ id: 1, classname: 'player' } as any)),
+      frame: vi.fn().mockReturnValue({
+        state: createGameStateSnapshotFactory({
+           gravity: { x: 0, y: 0, z: -800 },
+           stats: new Array(32).fill(0),
+        })
+      }),
+      clientConnect: vi.fn().mockReturnValue(true),
+    });
+
+    (createGame as vi.Mock).mockReturnValue(mockGame);
+
+    transport = createMockTransport();
+    server = new DedicatedServer({ transport });
+    await server.startServer('test.bsp');
+  });
+
+  afterEach(() => {
+    server.stopServer();
+    vi.useRealTimers();
+    vi.clearAllMocks();
+    consoleLogSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('should initialize the game and start the frame loop', () => {
+    expect(createGame).toHaveBeenCalled();
+    expect(mockGame.init).toHaveBeenCalled();
+    expect(mockGame.spawnWorld).toHaveBeenCalled();
+
+    vi.advanceTimersByTime(FRAME_TIME_MS);
+    expect(mockGame.frame).toHaveBeenCalledTimes(2);
+  });
+
+  it('should run the main game loop and process client commands', () => {
+    // Use helper to create default frames if needed, or rely on createMockServerClient defaults if updated
+    // For now, we still need frames for the dedicated server logic to work properly
+    const frames = [];
+    for (let i = 0; i < UPDATE_BACKUP; i++) {
+        frames.push({
+            areaBytes: 0,
+            areaBits: new Uint8Array(0),
+            playerState: {},
+            numEntities: 0,
+            firstEntity: 0,
+            sentTime: 0,
+            entities: []
+        });
+    }
+
+    const fakeClient = createMockServerClient(0, {
+        frames: frames as any[],
+        lastCmd: { msec: 100, angles: {x: 0, y: 90, z: 0}, buttons: 1, forwardmove: 200, sidemove: 0, upmove: 0, sequence: 1, lightlevel: 0, impulse: 0, serverFrame: 0 },
+        state: ClientState.Active,
+        edict: { id: 1, classname: 'player' } as any
+    });
+
+    // @ts-ignore
+    server.svs.clients[0] = fakeClient;
+
+    (mockGame.frame as any).mockClear();
+    (mockGame.clientThink as any).mockClear();
+
+    vi.advanceTimersByTime(FRAME_TIME_MS);
+
+    expect(mockGame.clientThink).toHaveBeenCalledWith(fakeClient.edict, fakeClient.lastCmd);
+    expect(mockGame.frame).toHaveBeenCalledTimes(1);
+    expect(mockGame.frame).toHaveBeenCalledWith(expect.objectContaining({ frame: 2 }));
+
+    vi.advanceTimersByTime(FRAME_TIME_MS);
+    expect(mockGame.frame).toHaveBeenCalledTimes(2);
+    expect(mockGame.frame).toHaveBeenCalledWith(expect.objectContaining({ frame: 3 }));
+
+    // Test server snapshot creation using helper
+    // This serves as a sanity check that the helpers are compatible with the server state
+    const snapshot = createServerSnapshot(server.sv, 0);
+    expect(snapshot).toBeDefined();
+    expect(snapshot.serverTime).toBe(server.sv.time);
+  });
+
+
+  it('should not process commands for clients that are not active', () => {
+    const frames = [];
+    for (let i = 0; i < UPDATE_BACKUP; i++) {
+        frames.push({
+            areaBytes: 0,
+            areaBits: new Uint8Array(0),
+            playerState: {},
+            numEntities: 0,
+            firstEntity: 0,
+            sentTime: 0,
+            entities: []
+        });
+    }
+
+    const fakeClient = createMockServerClient(0, {
+        frames: frames as any[],
+        state: ClientState.Connected, // Not Active
+        edict: { id: 1, classname: 'player' } as any
+    });
+
+    // @ts-ignore
+    server.svs.clients[0] = fakeClient;
+
+    (mockGame.frame as any).mockClear();
+    (mockGame.clientThink as any).mockClear();
+
+    vi.advanceTimersByTime(FRAME_TIME_MS);
+
+    expect(mockGame.clientThink).not.toHaveBeenCalled();
+    expect(mockGame.frame).toHaveBeenCalledTimes(1);
+  });
+
+  it('should compensate for slow frames (drift compensation)', async () => {
+    vi.clearAllTimers();
+    (mockGame.frame as any).mockClear();
+    server.stopServer();
+
+    transport = createMockTransport();
+    server = new DedicatedServer({ transport });
+    await server.startServer('test.bsp');
+
+    expect(mockGame.frame).toHaveBeenCalledTimes(1);
+
+    const frameMock2 = vi.fn().mockImplementation(() => {
+        const now = Date.now();
+        vi.setSystemTime(now + 40);
+        return { state: { packetEntities: [], stats: [] } };
+    });
+    mockGame.frame = frameMock2;
+
+    vi.advanceTimersByTime(100);
+    expect(frameMock2).toHaveBeenCalledTimes(1);
+
+    const frameMock3 = vi.fn().mockImplementation(() => {
+        const now = Date.now();
+        vi.setSystemTime(now + 120);
+        return { state: { packetEntities: [], stats: [] } };
+    });
+    mockGame.frame = frameMock3;
+
+    vi.advanceTimersByTime(59);
+    expect(frameMock3).toHaveBeenCalledTimes(0);
+
+    vi.advanceTimersByTime(1);
+    expect(frameMock3).toHaveBeenCalledTimes(1);
+
+    const frameMock4 = vi.fn().mockReturnValue({ state: { packetEntities: [], stats: [] } });
+    mockGame.frame = frameMock4;
+
+    vi.advanceTimersByTime(1);
+    expect(frameMock4).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/dedicated_trace.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { DedicatedServer } from '../src/dedicated.js';
+import * as gameModule from '@quake2ts/game';
+import { CollisionEntityIndex, traceBox } from '@quake2ts/shared';
+import { createMockCollisionEntityIndex } from '@quake2ts/test-utils';
+
+// Mock dependencies
+vi.mock('@quake2ts/shared', async () => {
+    const actual = await vi.importActual('@quake2ts/shared');
+    return {
+        ...actual,
+        traceBox: vi.fn(),
+        CollisionEntityIndex: vi.fn().mockImplementation(() => createMockCollisionEntityIndex())
+    };
+});
+
+describe('DedicatedServer Trace Integration', () => {
+    let server: DedicatedServer;
+
+    afterEach(() => {
+        if (server) {
+            // Restore mocked game object to have shutdown so stop() doesn't crash
+            if ((server as any).game && !(server as any).game.shutdown) {
+                (server as any).game.shutdown = vi.fn();
+            }
+            server.stop();
+        }
+    });
+
+    it('should invoke CollisionEntityIndex.trace and resolve entity', async () => {
+        const createGameSpy = vi.spyOn(gameModule, 'createGame');
+        server = new DedicatedServer(27998); // Use different port
+
+        // Setup mock for entity tracing
+        const mockEntityIndex = (server as any).entityIndex;
+        mockEntityIndex.trace.mockReturnValue({
+            fraction: 0.5,
+            allsolid: false,
+            startsolid: false,
+            endpos: { x: 50, y: 0, z: 0 },
+            entityId: 10,
+            contents: 1,
+            surfaceFlags: 0,
+            plane: { normal: { x: -1, y: 0, z: 0 }, dist: 50 }
+        });
+
+        // Start server
+        await server.start('test.bsp');
+
+        expect(createGameSpy).toHaveBeenCalled();
+        const imports = createGameSpy.mock.calls[0][0] as any;
+
+        // Mock game instance for entity lookup, INCLUDING shutdown for cleanup
+        const mockEntity = { index: 10, classname: 'test_entity' };
+        (server as any).game = {
+            entities: {
+                getByIndex: vi.fn().mockReturnValue(mockEntity)
+            },
+            shutdown: vi.fn()
+        };
+
+        // Call trace
+        const traceResult = imports.trace(
+            { x: 0, y: 0, z: 0 },
+            { x: -16, y: -16, z: -24 },
+            { x: 16, y: 16, z: 32 },
+            { x: 100, y: 0, z: 0 },
+            null,
+            0xFFFFFFFF
+        );
+
+        // Verify entity index was called
+        expect(mockEntityIndex.trace).toHaveBeenCalled();
+
+        // Verify result contains the entity
+        expect(traceResult.fraction).toBe(0.5);
+        expect(traceResult.ent).toBe(mockEntity);
+    });
+
+    it('should fallback to world trace (via entityIndex) if entity trace is further', async () => {
+        const createGameSpy = vi.spyOn(gameModule, 'createGame');
+        server = new DedicatedServer(27999);
+
+        // Setup mock for entity tracing to return a miss (entityId: null)
+        const mockEntityIndex = (server as any).entityIndex;
+        mockEntityIndex.trace.mockReturnValue({
+            fraction: 0.3,
+            allsolid: false,
+            startsolid: false,
+            endpos: { x: 30, y: 0, z: 0 },
+            entityId: null
+        });
+
+        await server.start('test.bsp');
+        const imports = createGameSpy.mock.calls[0][0] as any;
+
+        // Mock game instance
+        (server as any).game = {
+            entities: {
+                getByIndex: vi.fn().mockReturnValue({})
+            },
+            shutdown: vi.fn()
+        };
+
+        const traceResult = imports.trace(
+            { x: 0, y: 0, z: 0 },
+            null, null,
+            { x: 100, y: 0, z: 0 },
+            null,
+            0xFFFFFFFF
+        );
+
+        // If entityIndex.trace returned entityId: null, then ent should be null.
+        expect(traceResult.ent).toBeNull();
+        expect(traceResult.fraction).toBe(0.3);
+    });
+});

package/tests/integration/configstring_sync.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DedicatedServer } from '../../src/dedicated.js';
+import { createClient, Client, ClientState } from '../../src/client.js';
+import { ServerCommand, ConfigStringIndex, PlayerStat, MAX_CONFIGSTRINGS, BinaryStream, BinaryWriter, NetDriver } from '@quake2ts/shared';
+import { Entity, createGame } from '@quake2ts/game';
+import { createMockTransport, MockTransport, createMockNetDriver, createMockGameExports, createGameStateSnapshotFactory } from '@quake2ts/test-utils';
+
+// Mock dependencies
+// ws mock removed
+vi.mock('../../src/net/nodeWsDriver.js');
+vi.mock('@quake2ts/game', async (importOriginal) => {
+    const actual = await importOriginal() as any;
+    return {
+        ...actual,
+        createGame: vi.fn(),
+        createPlayerInventory: vi.fn(() => ({
+             ammo: { counts: [] },
+             items: new Set(),
+             ownedWeapons: new Set(),
+             powerups: new Map()
+        })),
+        createPlayerWeaponStates: vi.fn(() => ({}))
+    };
+});
+vi.mock('node:fs/promises', async (importOriginal) => {
+    const actual = await importOriginal() as any;
+    return {
+        ...actual,
+        default: {
+            ...actual.default,
+            readFile: vi.fn().mockResolvedValue(Buffer.from(''))
+        },
+        readFile: vi.fn().mockResolvedValue(Buffer.from(''))
+    };
+});
+vi.mock('@quake2ts/engine', () => ({
+    parseBsp: vi.fn().mockReturnValue({
+        planes: [],
+        nodes: [],
+        leafs: [],
+        brushes: [],
+        models: [],
+        leafLists: { leafBrushes: [] },
+        texInfo: [],
+        brushSides: [],
+        visibility: { numClusters: 0, clusters: [] }
+    })
+}));
+
+
+describe('Integration: Config String & Stats Sync', () => {
+    let server: DedicatedServer;
+    let mockClient: Client;
+    let mockDriver: NetDriver;
+    let consoleLogSpy: any;
+    let consoleWarnSpy: any;
+    let transport: MockTransport;
+
+    beforeEach(async () => {
+        vi.useFakeTimers({
+            toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date']
+        });
+        // Suppress logs for cleaner output
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+        (createGame as vi.Mock).mockReturnValue(createMockGameExports({
+            clientBegin: vi.fn().mockReturnValue({ index: 1, origin: { x: 0, y: 0, z: 0 } } as any),
+            frame: vi.fn().mockReturnValue({
+                state: createGameStateSnapshotFactory({
+                    stats: new Array(32).fill(0),
+                    packetEntities: []
+                })
+            }),
+            clientConnect: vi.fn().mockReturnValue(true),
+        }));
+
+        transport = createMockTransport();
+        server = new DedicatedServer({ port: 27910, transport });
+
+        // Start server
+        await server.startServer('maps/test.bsp');
+
+        // Setup mock driver instance
+        mockDriver = createMockNetDriver({
+            send: vi.fn()
+        });
+
+        // Simulate connection via Transport
+        transport.simulateConnection(mockDriver, {});
+
+        const clients = (server as any).svs.clients;
+        // Find client with our mock driver
+        mockClient = clients.find((c: Client | null) => c && c.net === mockDriver);
+
+        if (!mockClient) {
+             mockClient = clients.find((c: Client | null) => c !== null);
+        }
+    });
+
+    afterEach(() => {
+        server.stopServer();
+        vi.useRealTimers();
+        consoleLogSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        vi.clearAllMocks();
+    });
+
+    it('should broadcast config strings to connected clients', () => {
+        // 1. Client connects and enters game
+        mockClient.state = ClientState.Connected;
+
+        // 2. Server sets a config string (e.g., map name or model)
+        const testIndex = ConfigStringIndex.Models + 1;
+        const testValue = "models/weapons/g_shotg/tris.md2";
+
+        // Call configstring via GameEngine interface (exposed on server)
+        server.configstring(testIndex, testValue);
+
+        // 3. Verify driver.send was called with correct data
+        expect(mockDriver.send).toHaveBeenCalled();
+
+        // Inspect the last call to see if it contains the config string command
+        const calls = (mockDriver.send as any).mock.calls;
+        const lastCallData = calls[calls.length - 1][0];
+
+        // Scan for the command byte (ServerCommand.configstring)
+        // With NetChan, it's wrapped.
+        const view = new Uint8Array(lastCallData.buffer);
+        let found = false;
+
+        // Command byte (13) + index (2 bytes) + value
+        // We look for [13, index_low, index_high]
+        // testIndex is ConfigStringIndex.Models + 1 (probably small number)
+        const idxLow = testIndex & 0xff;
+        const idxHigh = (testIndex >> 8) & 0xff;
+
+        for(let i=0; i<view.length-3; i++) {
+            if (view[i] === ServerCommand.configstring && view[i+1] === idxLow && view[i+2] === idxHigh) {
+                found = true;
+                break;
+            }
+        }
+        expect(found).toBe(true);
+    });
+
+    it('should send full config string list on client connect', () => {
+        // 1. Pre-populate some config strings
+        (server as any).sv.configStrings[ConfigStringIndex.Models] = "model1";
+        (server as any).sv.configStrings[ConfigStringIndex.Sounds] = "sound1";
+
+        // 2. Simulate client connection flow
+        (server as any).handleConnect(mockClient, "userinfo");
+
+        // 3. Check sent packets
+        const calls = (mockDriver.send as any).mock.calls;
+        let foundServerData = false;
+        let foundModel1 = false;
+        let foundSound1 = false;
+
+        for (const call of calls) {
+            const data = call[0] instanceof Uint8Array ? call[0] : new Uint8Array(call[0].buffer);
+
+            // Search for strings in the packet data
+            const textDecoder = new TextDecoder();
+            // We can't decode the whole binary as text easily, but we can search for substring bytes
+            // Or just decode and search (binary garbage might be invalid utf8 but strings usually survive)
+            const text = textDecoder.decode(data);
+
+            if (text.includes("baseq2") && text.includes("maps/test.bsp")) {
+                foundServerData = true;
+            }
+            if (text.includes("model1")) foundModel1 = true;
+            if (text.includes("sound1")) foundSound1 = true;
+        }
+
+        expect(foundServerData).toBe(true);
+        expect(foundModel1).toBe(true);
+        expect(foundSound1).toBe(true);
+    });
+
+    it('should sync player stats in frame updates', () => {
+        // 1. Activate client
+        mockClient.state = ClientState.Active;
+
+        // 2. Mock game frame returning stats
+        const mockStats = new Array(32).fill(0);
+        mockStats[PlayerStat.STAT_HEALTH] = 100;
+        mockStats[PlayerStat.STAT_ARMOR] = 50;
+
+        // We need to update the mock implementation of 'frame' for this specific test
+        // Accessing the game instance created by createGame
+        const game = (server as any).game;
+        game.frame.mockReturnValue({
+            state: {
+                stats: mockStats,
+                packetEntities: [],
+                origin: { x:0, y:0, z:0 },
+                velocity: { x:0, y:0, z:0 },
+                gravity: { x:0, y:0, z:0 },
+                deltaAngles: { x:0, y:0, z:0 },
+                viewangles: { x:0, y:0, z:0 },
+                kick_angles: { x:0, y:0, z:0 },
+                gunoffset: { x:0, y:0, z:0 },
+                gunangles: { x:0, y:0, z:0 },
+                blend: [0,0,0,0]
+            }
+        });
+
+        // 3. Run server frame
+        (server as any).runFrame();
+
+        // 4. Check for frame packet
+        const calls = (mockDriver.send as any).mock.calls;
+        const lastCallData = calls[calls.length - 1][0];
+
+        // Scan buffer for stats values (100 and 50)
+        // Since NetChan header is 10 bytes, start from there.
+
+        const view = new Uint8Array(lastCallData.buffer);
+        let foundHealth = false;
+        let foundArmor = false;
+
+        // Simple scan for values (heuristic)
+        // Note: Stats are shorts (2 bytes)
+        for (let i = 10; i < view.length - 1; i++) {
+            const val = view[i] | (view[i+1] << 8);
+            if (val === 100) foundHealth = true;
+            if (val === 50) foundArmor = true;
+        }
+
+        expect(foundHealth).toBe(true);
+        expect(foundArmor).toBe(true);
+    });
+});

package/tests/lag.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DedicatedServer } from '../src/dedicated.js';
+import { Entity, Solid, createGame, GameExports } from '@quake2ts/game';
+import { createMockGameExports, createMockCollisionEntityIndex } from '@quake2ts/test-utils';
+
+vi.mock('@quake2ts/game', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual as any,
+        createGame: vi.fn(),
+    };
+});
+
+describe('Lag Compensation', () => {
+    let server: DedicatedServer;
+    let target: Entity;
+    let attacker: Entity;
+    let entities: Entity[];
+    let mockGame: GameExports;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+
+        // Setup mock entities
+        target = new Entity(1);
+        target.solid = Solid.Bsp; // Needs to be solid to be tracked
+        target.takedamage = true;
+        target.origin = { x: 100, y: 0, z: 0 };
+        target.mins = { x: -16, y: -16, z: -24 };
+        target.maxs = { x: 16, y: 16, z: 32 };
+        target.angles = { x: 0, y: 0, z: 0 };
+
+        attacker = new Entity(2);
+        attacker.origin = { x: 0, y: 0, z: 0 };
+
+        entities = [target, attacker];
+
+        const defaultGame = createMockGameExports();
+        mockGame = createMockGameExports({
+             entities: {
+                 ...defaultGame.entities,
+                 forEachEntity: vi.fn((cb: any) => entities.forEach(cb)),
+                 getByIndex: vi.fn((id: number) => entities.find(e => e.index === id)) as any,
+                 trace: vi.fn(),
+             } as any
+        });
+
+        (createGame as vi.Mock).mockReturnValue(mockGame);
+
+        server = new DedicatedServer(0);
+
+        // Initialize server (starts game)
+        // start() is async and does file io.
+        // We manually inject the game instance to bypass start()
+        (server as any).game = mockGame;
+        (server as any).entityIndex = createMockCollisionEntityIndex();
+    });
+
+    it('should record entity history', () => {
+        // Record at time 1000
+        vi.setSystemTime(1000);
+        (server as any).recordHistory();
+
+        // Check history
+        const history = (server as any).history.get(target.index);
+        expect(history).toBeDefined();
+        expect(history).toHaveLength(1);
+        expect(history![0].time).toBe(1000);
+        expect(history![0].origin).toEqual({ x: 100, y: 0, z: 0 });
+
+        // Move entity
+        target.origin = { x: 200, y: 0, z: 0 };
+
+        // Record at time 1100
+        vi.setSystemTime(1100);
+        (server as any).recordHistory();
+
+        expect(history).toHaveLength(2);
+        expect(history![1].time).toBe(1100);
+        expect(history![1].origin).toEqual({ x: 200, y: 0, z: 0 });
+    });
+
+    it('should interpolate entity position based on lag', () => {
+        // Setup history
+        // Time 1000: x=100
+        // Time 1100: x=200
+        target.origin = { x: 100, y: 0, z: 0 };
+        vi.setSystemTime(1000);
+        (server as any).recordHistory();
+
+        target.origin = { x: 200, y: 0, z: 0 };
+        vi.setSystemTime(1100);
+        (server as any).recordHistory();
+
+        // Current time is 1100. Target is at 200.
+        // Attacker has 50ms lag. Target should be rewound to time 1050.
+        // 1050 is halfway between 1000 and 1100.
+        // Origin should be 150.
+
+        server.setLagCompensation(true, attacker, 50);
+
+        expect(target.origin.x).toBeCloseTo(150);
+
+        // Restore
+        server.setLagCompensation(false);
+        expect(target.origin.x).toBe(200);
+    });
+
+    it('should handle lag larger than history', () => {
+        target.origin = { x: 100, y: 0, z: 0 };
+        vi.setSystemTime(1000);
+        (server as any).recordHistory();
+
+        target.origin = { x: 200, y: 0, z: 0 };
+        vi.setSystemTime(1100);
+        (server as any).recordHistory();
+
+        // Lag 200ms -> Time 900.
+        // Oldest sample is 1000. Should clamp to 1000 (x=100).
+        server.setLagCompensation(true, attacker, 200);
+
+        expect(target.origin.x).toBe(100);
+
+        server.setLagCompensation(false);
+    });
+
+    it('should handle negative lag (extrapolation not supported, clamps to newest)', () => {
+        target.origin = { x: 100, y: 0, z: 0 };
+        vi.setSystemTime(1000);
+        (server as any).recordHistory();
+
+        target.origin = { x: 200, y: 0, z: 0 };
+        vi.setSystemTime(1100);
+        (server as any).recordHistory();
+
+        // Lag -100ms (impossible ping) -> Time 1200.
+        // Newest is 1100. Should clamp to 1100 (x=200).
+        server.setLagCompensation(true, attacker, -100);
+
+        expect(target.origin.x).toBe(200);
+
+        server.setLagCompensation(false);
+    });
+});