@quake2ts/test-utils 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,2150 @@
+import * as vitest from 'vitest';
+import { Mock, vi } from 'vitest';
+import { Vec3, CollisionPlane, CollisionBrush, CollisionNode, CollisionLeaf, CollisionModel, PlayerState, EntityState, createRandomGenerator, TraceResult as TraceResult$1, NetDriver, NetChan, UserCommand, ProtocolPlayerState } from '@quake2ts/shared';
+export { intersects, ladderTrace, stairTrace } from '@quake2ts/shared';
+import { Vec3 as Vec3$1, Bounds3 } from '@quake2ts/shared/math/vec3';
+import { TraceResult, CollisionPlane as CollisionPlane$1 } from '@quake2ts/shared/bsp/collision';
+import { ConfigStringEntry, Cvar, BspModel, AudioNodeLike, AudioBufferSourceNodeLike, AudioBufferLike, AudioParamLike, GainNodeLike, DynamicsCompressorNodeLike, PannerNodeLike, BiquadFilterNodeLike, AudioDestinationNodeLike, AudioContextLike, Renderer, FrameRenderer, BspSurfacePipeline, Md2Pipeline, Md3Pipeline, SpriteRenderer, SkyboxPipeline, AssetManager, PreparedTexture, Md2Model, Md3Model, BspMap, BufferUsage, VertexBuffer, IndexBuffer, ShaderProgram, DLight, DynamicLightManager, ParticleSystem, Camera, FrameRenderStats, EntityState as EntityState$1, ProtocolPlayerState as ProtocolPlayerState$1, FrameData, DamageIndicator, FogData } from '@quake2ts/engine';
+export { ConfigStringEntry, Cvar, DLight, DynamicLightManager, IndexBuffer, ParticleSystem, ShaderProgram, VertexBuffer } from '@quake2ts/engine';
+import { GameStateSnapshot, Entity, ScriptHookRegistry, SpawnContext, EntitySystem, SpawnRegistry, GameSaveFile, LevelState, MonsterMove, DamageMod, PlayerInventory, BaseItem, WeaponId, WeaponItem, HealthItem, ArmorItem, AmmoItemId, PowerupItem, GameExports, PlayerClient } from '@quake2ts/game';
+import { NetworkTransport, Server, ServerStatic, Client, ClientState as ClientState$1, ClientFrame } from '@quake2ts/server';
+import { ImageData, Canvas } from '@napi-rs/canvas';
+import { vec3 } from 'gl-matrix';
+
+/**
+ * Interface for the BinaryWriter mock.
+ */
+interface BinaryWriterMock {
+    writeByte: Mock<[number], void>;
+    writeShort: Mock<[number], void>;
+    writeLong: Mock<[number], void>;
+    writeString: Mock<[string], void>;
+    writeBytes: Mock<[Uint8Array], void>;
+    getBuffer: Mock<[], Uint8Array>;
+    reset: Mock<[], void>;
+    writeInt8: Mock<[number], void>;
+    writeUint8: Mock<[number], void>;
+    writeInt16: Mock<[number], void>;
+    writeUint16: Mock<[number], void>;
+    writeInt32: Mock<[number], void>;
+    writeUint32: Mock<[number], void>;
+    writeFloat: Mock<[number], void>;
+    getData: Mock<[], Uint8Array>;
+    writePos: Mock<[any], void>;
+    writeDir: Mock<[any], void>;
+}
+/**
+ * Creates a mock BinaryWriter for testing binary data writing.
+ *
+ * @returns A BinaryWriterMock object with all methods mocked using vi.fn().
+ */
+declare const createBinaryWriterMock: () => BinaryWriterMock;
+/**
+ * Creates a mock NetChan (Network Channel) for testing network communication.
+ * Includes mocks for sequencing, reliable messaging, and fragmentation.
+ *
+ * @returns A mocked NetChan object.
+ */
+declare const createNetChanMock: () => {
+    qport: number;
+    incomingSequence: number;
+    outgoingSequence: number;
+    incomingAcknowledged: number;
+    incomingReliableAcknowledged: boolean;
+    incomingReliableSequence: number;
+    outgoingReliableSequence: number;
+    reliableMessage: BinaryWriterMock;
+    reliableLength: number;
+    fragmentSendOffset: number;
+    fragmentBuffer: null;
+    fragmentLength: number;
+    fragmentReceived: number;
+    lastReceived: number;
+    lastSent: number;
+    remoteAddress: {
+        type: string;
+        port: number;
+    };
+    setup: Mock<any, any>;
+    reset: Mock<any, any>;
+    transmit: Mock<any, any>;
+    process: Mock<any, any>;
+    canSendReliable: Mock<[], boolean>;
+    writeReliableByte: Mock<any, any>;
+    writeReliableShort: Mock<any, any>;
+    writeReliableLong: Mock<any, any>;
+    writeReliableString: Mock<any, any>;
+    getReliableData: Mock<[], Uint8Array<ArrayBufferLike>>;
+    needsKeepalive: Mock<[], boolean>;
+    isTimedOut: Mock<[], boolean>;
+};
+/**
+ * Interface for the BinaryStream mock.
+ */
+interface BinaryStreamMock {
+    getPosition: Mock<[], number>;
+    getReadPosition: Mock<[], number>;
+    getLength: Mock<[], number>;
+    getRemaining: Mock<[], number>;
+    seek: Mock<[number], void>;
+    setReadPosition: Mock<[number], void>;
+    hasMore: Mock<[], boolean>;
+    hasBytes: Mock<[number], boolean>;
+    readChar: Mock<[], number>;
+    readByte: Mock<[], number>;
+    readShort: Mock<[], number>;
+    readUShort: Mock<[], number>;
+    readLong: Mock<[], number>;
+    readULong: Mock<[], number>;
+    readFloat: Mock<[], number>;
+    readString: Mock<[], string>;
+    readStringLine: Mock<[], string>;
+    readCoord: Mock<[], number>;
+    readAngle: Mock<[], number>;
+    readAngle16: Mock<[], number>;
+    readData: Mock<[number], Uint8Array>;
+    readPos: Mock<[], any>;
+    readDir: Mock<[], any>;
+}
+/**
+ * Creates a mock BinaryStream for testing binary data reading.
+ *
+ * @returns A BinaryStreamMock object with all methods mocked.
+ */
+declare const createBinaryStreamMock: () => BinaryStreamMock;
+/**
+ * Interface for MessageWriter mock, extending BinaryWriterMock with additional message-specific methods.
+ */
+interface MessageWriterMock extends BinaryWriterMock {
+    writeInt: Mock<[number], void>;
+    writeVector: Mock<[any], void>;
+}
+/**
+ * Creates a mock MessageWriter, aliasing writeInt to writeInt32 and writeVector to writePos.
+ *
+ * @param overrides - Optional overrides for the mock.
+ * @returns A MessageWriterMock object.
+ */
+declare const createMessageWriterMock: (overrides?: Partial<MessageWriterMock>) => MessageWriterMock;
+/**
+ * Interface for MessageReader mock, extending BinaryStreamMock with additional message-specific methods.
+ */
+interface MessageReaderMock extends BinaryStreamMock {
+    readInt: Mock<[], number>;
+    readVector: Mock<[], any>;
+}
+/**
+ * Creates a mock MessageReader, aliasing readInt to readLong and readVector to readPos.
+ *
+ * @param data - Optional initial data for the reader.
+ * @returns A MessageReaderMock object.
+ */
+declare const createMessageReaderMock: (data?: Uint8Array) => MessageReaderMock;
+/**
+ * Interface for a generic network packet mock.
+ */
+interface PacketMock {
+    type: 'connection' | 'data' | 'ack' | 'disconnect';
+    sequence: number;
+    ack: number;
+    qport: number;
+    data: Uint8Array;
+}
+/**
+ * Creates a mock network packet.
+ *
+ * @param overrides - Optional overrides for packet properties.
+ * @returns A PacketMock object.
+ */
+declare const createPacketMock: (overrides?: Partial<PacketMock>) => PacketMock;
+
+/**
+ * Creates a collision plane with the specified normal and distance.
+ * Automatically calculates the plane type and signbits.
+ *
+ * @param normal - The normal vector of the plane.
+ * @param dist - The distance from the origin.
+ * @returns A CollisionPlane object.
+ */
+declare function makePlane(normal: Vec3, dist: number): CollisionPlane;
+/**
+ * Creates a simple axis-aligned cubic brush for testing.
+ *
+ * @param size - The size of the cube (width, height, depth).
+ * @param contents - The content flags for the brush (default: CONTENTS_SOLID).
+ * @returns A CollisionBrush object.
+ */
+declare function makeAxisBrush(size: number, contents?: number): CollisionBrush;
+/**
+ * Creates a BSP node.
+ *
+ * @param plane - The splitting plane for this node.
+ * @param children - Indices of the children (positive for nodes, negative for leaves).
+ * @returns A CollisionNode object.
+ */
+declare function makeNode(plane: CollisionPlane, children: [number, number]): CollisionNode;
+/**
+ * Constructs a full CollisionModel from components.
+ *
+ * @param planes - Array of planes.
+ * @param nodes - Array of nodes.
+ * @param leaves - Array of leaves.
+ * @param brushes - Array of brushes.
+ * @param leafBrushes - Array of leaf brush indices.
+ * @returns A CollisionModel object.
+ */
+declare function makeBspModel(planes: CollisionPlane[], nodes: CollisionNode[], leaves: CollisionLeaf[], brushes: CollisionBrush[], leafBrushes: number[]): CollisionModel;
+/**
+ * Creates a BSP leaf.
+ *
+ * @param contents - The content flags for this leaf.
+ * @param firstLeafBrush - Index into the leafBrushes array.
+ * @param numLeafBrushes - Number of brushes in this leaf.
+ * @returns A CollisionLeaf object.
+ */
+declare function makeLeaf(contents: number, firstLeafBrush: number, numLeafBrushes: number): CollisionLeaf;
+/**
+ * Creates a simplified CollisionModel consisting of a single leaf containing the provided brushes.
+ * Useful for testing collision against a set of brushes without full BSP tree traversal.
+ *
+ * @param brushes - Array of CollisionBrushes to include.
+ * @returns A CollisionModel object.
+ */
+declare function makeLeafModel(brushes: CollisionBrush[]): CollisionModel;
+/**
+ * Creates a brush defined by min and max bounds.
+ *
+ * @param mins - Minimum coordinates (x, y, z).
+ * @param maxs - Maximum coordinates (x, y, z).
+ * @param contents - Content flags (default: CONTENTS_SOLID).
+ * @returns A CollisionBrush object.
+ */
+declare function makeBrushFromMinsMaxs(mins: Vec3, maxs: Vec3, contents?: number): CollisionBrush;
+
+declare function findPakFile(): string | null;
+declare function loadMapFromPak(mapName: string): ArrayBuffer | null;
+
+/**
+ * Creates a Vector3 object.
+ *
+ * @param x - The X coordinate (default: 0).
+ * @param y - The Y coordinate (default: 0).
+ * @param z - The Z coordinate (default: 0).
+ * @returns A Vec3 object.
+ */
+declare const createVector3: (x?: number, y?: number, z?: number) => Vec3$1;
+/**
+ * Creates a bounds object (min/max vectors).
+ *
+ * @param mins - The minimum bounds vector (default: 0,0,0).
+ * @param maxs - The maximum bounds vector (default: 1,1,1).
+ * @returns A Bounds3 object.
+ */
+declare const createBounds: (mins?: Vec3$1, maxs?: Vec3$1) => Bounds3;
+/**
+ * Interface representing a transformation (position, rotation, scale).
+ */
+interface Transform {
+    position: Vec3$1;
+    rotation: Vec3$1;
+    scale: Vec3$1;
+}
+/**
+ * Creates a Transform object.
+ *
+ * @param overrides - Optional overrides for transform properties.
+ * @returns A Transform object.
+ */
+declare const createTransform: (overrides?: Partial<Transform>) => Transform;
+/**
+ * Generates a random Vector3 within the specified range.
+ *
+ * @param min - Minimum value for each component (default: -100).
+ * @param max - Maximum value for each component (default: 100).
+ * @returns A random Vec3 object.
+ */
+declare const randomVector3: (min?: number, max?: number) => Vec3$1;
+
+/**
+ * Interface for a TraceResult mock, including all standard properties.
+ */
+interface TraceMock extends Partial<TraceResult> {
+    fraction: number;
+    endpos: Vec3$1;
+    plane: CollisionPlane$1;
+    surface: {
+        flags: number;
+        name?: string;
+        value?: number;
+    };
+    contents: number;
+    ent: any;
+    allsolid: boolean;
+    startsolid: boolean;
+}
+/**
+ * Creates a mock TraceResult.
+ *
+ * @param overrides - Optional overrides for trace properties.
+ * @returns A TraceMock object.
+ */
+declare const createTraceMock: (overrides?: Partial<TraceMock>) => TraceMock;
+/**
+ * Interface for a Surface mock.
+ */
+interface SurfaceMock {
+    flags: number;
+    name: string;
+    value: number;
+}
+/**
+ * Creates a mock Surface.
+ *
+ * @param overrides - Optional overrides for surface properties.
+ * @returns A SurfaceMock object.
+ */
+declare const createSurfaceMock: (overrides?: Partial<SurfaceMock>) => SurfaceMock;
+
+/**
+ * Creates a mock ConfigStringEntry.
+ *
+ * @param index - The config string index.
+ * @param value - The config string value.
+ * @returns A ConfigStringEntry object.
+ */
+declare function createConfigStringMock(index: number, value: string): ConfigStringEntry;
+/**
+ * Creates an array of ConfigStringEntry objects from a record.
+ *
+ * @param entries - A record of index-value pairs (optional).
+ * @returns An array of ConfigStringEntry objects.
+ */
+declare function createConfigStringArrayMock(entries?: Record<number, string>): ConfigStringEntry[];
+/**
+ * Creates a mock Cvar.
+ *
+ * @param name - The name of the cvar.
+ * @param value - The initial value of the cvar.
+ * @param flags - Cvar flags (default: CvarFlags.None).
+ * @returns A Cvar instance.
+ */
+declare function createCvarMock(name: string, value: string, flags?: number): Cvar;
+/**
+ * Creates a mock PlayerState with sensible defaults.
+ * Corresponds to player_state_t in q_shared.h.
+ *
+ * @param overrides - Partial PlayerState to override defaults.
+ * @returns A complete PlayerState object.
+ */
+declare function createMockPlayerState(overrides?: Partial<PlayerState>): PlayerState;
+
+declare const createPlayerStateFactory: (overrides?: Partial<PlayerState>) => PlayerState;
+declare const createEntityStateFactory: (overrides?: Partial<EntityState>) => EntityState;
+declare const createGameStateSnapshotFactory: (overrides?: Partial<GameStateSnapshot>) => GameStateSnapshot;
+declare function createEntityFactory(overrides?: Partial<Entity>): Partial<Entity>;
+declare function createPlayerEntityFactory(overrides?: Partial<Entity>): Partial<Entity>;
+declare function createMonsterEntityFactory(classname: string, overrides?: Partial<Entity>): Partial<Entity>;
+declare function createItemEntityFactory(classname: string, overrides?: Partial<Entity>): Partial<Entity>;
+declare function createProjectileEntityFactory(classname: string, overrides?: Partial<Entity>): Partial<Entity>;
+declare function createTriggerEntityFactory(classname: string, overrides?: Partial<Entity>): Partial<Entity>;
+
+interface MockEngine {
+    sound: Mock<[Entity, number, string, number, number, number], void>;
+    soundIndex: Mock<[string], number>;
+    modelIndex: Mock<[string], number>;
+    centerprintf: Mock<[Entity, string], void>;
+}
+interface MockGame {
+    random: ReturnType<typeof createRandomGenerator>;
+    registerEntitySpawn: Mock<[string, (entity: Entity) => void], void>;
+    unregisterEntitySpawn: Mock<[string], void>;
+    getCustomEntities: Mock<[], string[]>;
+    hooks: ScriptHookRegistry;
+    registerHooks: Mock<[any], any>;
+    spawnWorld: Mock<[], void>;
+    clientBegin: Mock<[any], void>;
+    damage: Mock<[number], void>;
+}
+interface TestContext extends SpawnContext {
+    entities: EntitySystem;
+    game: MockGame;
+    engine: MockEngine;
+}
+declare const createMockEngine: () => MockEngine;
+declare const createMockGame: (seed?: number) => {
+    game: MockGame;
+    spawnRegistry: SpawnRegistry;
+};
+declare function createTestContext(options?: {
+    seed?: number;
+    initialEntities?: Entity[];
+}): TestContext;
+declare function createSpawnTestContext(mapName?: string): TestContext;
+declare function createCombatTestContext(): TestContext;
+declare function createPhysicsTestContext(bspModel?: BspModel): TestContext;
+declare function createEntity(): Entity;
+/**
+ * Creates mock imports and engine for use with createGame() from @quake2ts/game.
+ * This is a convenience helper that provides all the commonly mocked functions
+ * needed to instantiate a real Game instance in tests.
+ *
+ * @param overrides Optional overrides for specific mock functions
+ * @returns An object containing both imports and engine mocks
+ *
+ * @example
+ * ```typescript
+ * import { createGame } from '@quake2ts/game';
+ * import { createGameImportsAndEngine } from '@quake2ts/test-utils';
+ *
+ * const { imports, engine } = createGameImportsAndEngine();
+ * const game = createGame(imports, engine, { gravity: { x: 0, y: 0, z: -800 } });
+ * ```
+ */
+declare function createGameImportsAndEngine(overrides?: {
+    imports?: Partial<{
+        trace: Mock;
+        pointcontents: Mock;
+        linkentity: Mock;
+        multicast: Mock;
+        unicast: Mock;
+    }>;
+    engine?: Partial<{
+        trace: Mock;
+        sound: Mock;
+        centerprintf: Mock;
+        modelIndex: Mock;
+        soundIndex: Mock;
+    }>;
+}): {
+    imports: {
+        trace: Mock;
+        pointcontents: Mock;
+        linkentity: Mock;
+        multicast: Mock;
+        unicast: Mock;
+    };
+    engine: {
+        trace: Mock;
+        sound: Mock;
+        centerprintf: Mock;
+        modelIndex: Mock;
+        soundIndex: Mock;
+    };
+};
+
+/**
+ * Creates a physics test scenario with pre-configured geometry.
+ * NOTE: Since real BSP loading is complex, this often uses block entities
+ * or mocked trace functions unless a real BSP is loaded in the context.
+ */
+interface PhysicsScenario {
+    ground: Entity;
+    walls: Entity[];
+    setup: (context: TestContext) => void;
+}
+declare function createPhysicsTestScenario(scenarioType: 'stairs' | 'ladder' | 'platform' | 'slope' | 'room', context: TestContext): PhysicsScenario;
+/**
+ * Simulates a single physics step for an entity.
+ * Uses the game's runPmove logic or manually invokes similar steps.
+ * This is useful for testing specific movement mechanics in isolation.
+ */
+declare function simulateMovement(entity: Entity, destination: Vec3, context: TestContext): TraceResult$1;
+/**
+ * Simulates gravity application on an entity.
+ */
+declare function simulateGravity(entity: Entity, deltaTime: number, context: TestContext): void;
+/**
+ * Simulates a jump action.
+ */
+declare function simulateJump(entity: Entity, context: TestContext): void;
+
+interface LevelFrameState {
+    readonly frameNumber: number;
+    readonly timeSeconds: number;
+    readonly previousTimeSeconds: number;
+    readonly deltaSeconds: number;
+}
+/**
+ * Interface for a mock save game object.
+ */
+interface MockSaveGame {
+    game: GameSaveFile;
+    entities: any[];
+    client: any;
+    level: LevelState;
+    timestamp: number;
+}
+/**
+ * Creates a mock SaveGame object.
+ *
+ * @param overrides - Optional overrides for save game properties.
+ * @returns A MockSaveGame object.
+ */
+declare function createMockSaveGame(overrides?: Partial<MockSaveGame>): MockSaveGame;
+/**
+ * Captures the current test context state as a save game snapshot.
+ * Note: This is a simplified snapshot for testing, not a full serialization.
+ *
+ * @param context - The test context to snapshot.
+ * @returns A MockSaveGame representing the current state.
+ */
+declare function createSaveGameSnapshot(context: TestContext): MockSaveGame;
+/**
+ * Restores a test context from a save game snapshot.
+ *
+ * @param saveGame - The save game to restore.
+ * @param context - The test context to update.
+ */
+declare function restoreSaveGameSnapshot(saveGame: MockSaveGame, context: TestContext): void;
+/**
+ * Result of comparing two save games.
+ */
+interface SaveGameDiff {
+    entityCountDiff: number;
+    differentEntities: {
+        index: number;
+        field: string;
+        expected: any;
+        actual: any;
+    }[];
+    gameStateDiffs: string[];
+}
+/**
+ * Compares two save games and returns the differences.
+ * Useful for testing save/load determinism.
+ *
+ * @param a - First save game.
+ * @param b - Second save game.
+ * @returns A SaveGameDiff object.
+ */
+declare function compareSaveGames(a: MockSaveGame, b: MockSaveGame): SaveGameDiff;
+
+interface MockAI {
+    checkAttack: Mock;
+    findTarget: Mock;
+    visible: Mock;
+    infront: Mock;
+}
+interface MockMonsterAI {
+    stand: Mock;
+    walk: Mock;
+    run: Mock;
+    dodge: Mock;
+    attack: Mock;
+    melee: Mock;
+    sight: Mock;
+    idle: Mock;
+}
+declare function createMockAI(overrides?: Partial<MockAI>): MockAI;
+declare function createMockMonsterAI(overrides?: Partial<MockMonsterAI>): MockMonsterAI;
+declare function createMockMonsterMove(first: number, last: number, think: (self: Entity, context: EntitySystem) => void, action: (self: Entity, dist: number, context: EntitySystem) => void): MonsterMove;
+
+interface MockDamageInfo {
+    damage: number;
+    mod: DamageMod;
+    knockback: number;
+    attacker: Entity | null;
+    inflictor: Entity | null;
+    dir: {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    point: {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+}
+declare function createMockDamageInfo(overrides?: Partial<MockDamageInfo>): MockDamageInfo;
+declare function createMockWeapon(name?: string): {
+    name: string;
+    ammoType: string;
+    ammoUse: number;
+    selection: Mock<any, any>;
+    think: Mock<any, any>;
+    command: Mock<any, any>;
+};
+declare const mockMonsterAttacks: {
+    fireBlaster: Mock<any, any>;
+    fireRocket: Mock<any, any>;
+    fireGrenade: Mock<any, any>;
+    fireHeat: Mock<any, any>;
+    fireBullet: Mock<any, any>;
+    fireShotgun: Mock<any, any>;
+    fireRailgun: Mock<any, any>;
+    fireBFG: Mock<any, any>;
+};
+
+/**
+ * Creates a mock player inventory with default values suitable for testing.
+ * Can be customized with overrides.
+ */
+declare function createMockInventory(overrides?: Partial<PlayerInventory>): PlayerInventory;
+/**
+ * Generic factory for any item type.
+ * Attempts to find a predefined item by ID first, then applies overrides.
+ */
+declare function createMockItem(id: string, overrides?: Partial<BaseItem>): BaseItem;
+/**
+ * Creates a mock WeaponItem
+ */
+declare function createMockWeaponItem(weaponId: WeaponId, overrides?: Partial<WeaponItem>): WeaponItem;
+/**
+ * Creates a mock HealthItem
+ */
+declare function createMockHealthItem(amount: number, overrides?: Partial<HealthItem>): HealthItem;
+/**
+ * Creates a mock ArmorItem
+ */
+declare function createMockArmorItem(amount: number, overrides?: Partial<ArmorItem>): ArmorItem;
+/**
+ * Creates a mock AmmoItem
+ */
+declare function createMockAmmoItem(ammoItemId: AmmoItemId, overrides?: Partial<BaseItem>): BaseItem;
+/**
+ * Creates a mock PowerupItem
+ */
+declare function createMockPowerupItem(id: string, duration: number, overrides?: Partial<PowerupItem>): PowerupItem;
+
+/**
+ * Interface for mock GameState.
+ */
+interface GameState {
+    levelName: string;
+    time: number;
+    entities: Entity[];
+    clients: any[];
+}
+/**
+ * Creates a mock game state object.
+ * @param overrides Optional overrides for the game state.
+ */
+declare function createMockGameState(overrides?: Partial<GameState>): GameState;
+/**
+ * Creates a mock GameExports object.
+ */
+declare function createMockGameExports(overrides?: Partial<GameExports>): GameExports;
+
+/**
+ * Mock implementation of the NetworkTransport interface for server testing.
+ * Allows simulating connections and errors.
+ */
+declare class MockTransport implements NetworkTransport {
+    onConnectionCallback?: (driver: NetDriver, info?: any) => void;
+    onErrorCallback?: (error: Error) => void;
+    address: string;
+    port: number;
+    sentMessages: Uint8Array[];
+    receivedMessages: Uint8Array[];
+    listening: boolean;
+    listenSpy: vitest.Mock<any, any>;
+    closeSpy: vitest.Mock<any, any>;
+    /**
+     * Start listening on the specified port.
+     */
+    listen(port: number): Promise<void>;
+    /**
+     * Close the transport.
+     */
+    close(): void;
+    /**
+     * Register a callback for new connections.
+     */
+    onConnection(callback: (driver: NetDriver, info?: any) => void): void;
+    /**
+     * Register a callback for errors.
+     */
+    onError(callback: (error: Error) => void): void;
+    /**
+     * Check if the transport is currently listening.
+     */
+    isListening(): boolean;
+    /**
+     * Helper to simulate a new connection.
+     * @param driver The network driver for the connection.
+     * @param info Optional connection info.
+     */
+    simulateConnection(driver: NetDriver, info?: any): void;
+    /**
+     * Helper to simulate an error.
+     * @param error The error to simulate.
+     */
+    simulateError(error: Error): void;
+}
+/**
+ * Interface for mock UDP socket.
+ * This is a partial mock of Node.js dgram.Socket or similar.
+ */
+interface MockUDPSocket {
+    send: (msg: Uint8Array, offset: number, length: number, port: number, address: string, callback?: (error: Error | null, bytes: number) => void) => void;
+    on: (event: string, callback: (...args: any[]) => void) => void;
+    close: () => void;
+    bind: (port: number, address?: string) => void;
+    address: () => {
+        address: string;
+        family: string;
+        port: number;
+    };
+}
+/**
+ * Creates a mock UDP socket.
+ * @param overrides Optional overrides for the socket methods.
+ */
+declare function createMockUDPSocket(overrides?: Partial<MockUDPSocket>): MockUDPSocket;
+/**
+ * Interface for network address.
+ */
+interface NetworkAddress {
+    ip: string;
+    port: number;
+}
+/**
+ * Creates a mock network address.
+ * @param ip IP address (default: '127.0.0.1')
+ * @param port Port number (default: 27910)
+ */
+declare function createMockNetworkAddress(ip?: string, port?: number): NetworkAddress;
+/**
+ * Creates a configured MockTransport instance.
+ * @param address Address to bind to (default: '127.0.0.1')
+ * @param port Port to listen on (default: 27910)
+ * @param overrides Optional overrides for the transport properties.
+ */
+declare function createMockTransport(address?: string, port?: number, overrides?: Partial<MockTransport>): MockTransport;
+/**
+ * Creates a mock NetDriver instance.
+ * @param overrides Optional overrides for the NetDriver methods.
+ */
+declare function createMockNetDriver(overrides?: Partial<NetDriver>): NetDriver;
+
+interface RecordedPacket {
+    type: 'sent' | 'received';
+    timestamp: number;
+    data: Uint8Array;
+}
+declare class MockNetworkTransport {
+    netchan: NetChan;
+    recordedPackets: RecordedPacket[];
+    sentPackets: Uint8Array[];
+    constructor();
+    reset(): void;
+    receive(data: Uint8Array): Uint8Array<ArrayBufferLike> | null;
+    transmit(unreliableData?: Uint8Array): Uint8Array<ArrayBufferLike>;
+    get lastSentPacket(): Uint8Array<ArrayBufferLike> | undefined;
+}
+
+interface MockNetDriverState {
+    connected: boolean;
+    messagesSent: Uint8Array[];
+    messageHandlers: ((data: Uint8Array) => void)[];
+    closeHandlers: (() => void)[];
+    errorHandlers: ((err: Error) => void)[];
+}
+/**
+ * A mock implementation of NetDriver that provides testing hooks.
+ * Unlike the simple createMockNetDriver factory, this class maintains state
+ * and allows for stimulating events (receiving messages, triggering errors).
+ */
+declare class MockNetDriver implements NetDriver {
+    state: MockNetDriverState;
+    connectSpy: vitest.Mock<any, any>;
+    disconnectSpy: vitest.Mock<any, any>;
+    sendSpy: vitest.Mock<any, any>;
+    connect(url: string): Promise<void>;
+    disconnect(): void;
+    send(data: Uint8Array): void;
+    onMessage(cb: (data: Uint8Array) => void): void;
+    onClose(cb: () => void): void;
+    onError(cb: (err: Error) => void): void;
+    isConnected(): boolean;
+    /**
+     * Simulate receiving a message from the network.
+     */
+    receiveMessage(data: Uint8Array): void;
+    /**
+     * Simulate a connection close event from the remote side.
+     */
+    simulateClose(): void;
+    /**
+     * Simulate a connection error.
+     */
+    simulateError(err: Error): void;
+    /**
+     * Get the last sent message.
+     */
+    getLastSentMessage(): Uint8Array | undefined;
+    /**
+     * Clear recorded sent messages.
+     */
+    clearSentMessages(): void;
+}
+
+/**
+ * Creates a mock server state object.
+ * @param overrides Optional overrides for the server state.
+ */
+declare function createMockServerState(overrides?: Partial<Server>): Server;
+/**
+ * Creates a mock server static object.
+ * @param maxClients Maximum number of clients.
+ * @param overrides Optional overrides for the server static state.
+ */
+declare function createMockServerStatic(maxClients?: number, overrides?: Partial<ServerStatic>): ServerStatic;
+/**
+ * Creates a mock server client.
+ * @param clientNum The client index.
+ * @param overrides Optional overrides for the client.
+ */
+declare function createMockServerClient(clientNum: number, overrides?: Partial<Client>): Client;
+/**
+ * Mock interface for the Server class (DedicatedServer).
+ * This allows mocking the server instance itself.
+ */
+interface MockServer {
+    start(mapName: string): Promise<void>;
+    stop(): void;
+    multicast(origin: any, type: any, event: any, ...args: any[]): void;
+    unicast(ent: Entity, reliable: boolean, event: any, ...args: any[]): void;
+    configstring(index: number, value: string): void;
+    kickPlayer(clientId: number): void;
+    changeMap(mapName: string): Promise<void>;
+    getClient(clientNum: number): Client | null;
+    broadcast(message: string): void;
+    tick(): void;
+}
+/**
+ * Creates a mock server instance.
+ * @param overrides Optional overrides for server methods.
+ */
+declare function createMockServer(overrides?: Partial<MockServer>): MockServer;
+
+/**
+ * Interface representing connection state for testing.
+ */
+interface Connection {
+    state: ClientState$1;
+    address: string;
+    challenge: number;
+    userInfo: UserInfo;
+}
+/**
+ * Stages of the client connection handshake.
+ */
+declare enum HandshakeStage {
+    None = 0,
+    Challenge = 1,
+    Connect = 2,
+    Info = 3,
+    Active = 4
+}
+/**
+ * Interface representing a handshake state.
+ */
+interface Handshake {
+    stage: HandshakeStage;
+    clientNum: number;
+    challenge: number;
+    qport: number;
+}
+/**
+ * Interface for UserInfo structure.
+ */
+interface UserInfo {
+    name: string;
+    skin: string;
+    model: string;
+    fov: number;
+    hand: number;
+    rate: number;
+    msg: number;
+    spectator?: number;
+    [key: string]: string | number | undefined;
+}
+/**
+ * Helper to serialize UserInfo to Quake 2 info string format.
+ * Format: \key\value\key2\value2
+ */
+declare function serializeUserInfo(info: UserInfo): string;
+/**
+ * Creates a mock UserInfo object.
+ * @param overrides Optional overrides for the user info.
+ */
+declare function createMockUserInfo(overrides?: Partial<UserInfo>): UserInfo;
+/**
+ * Creates a mock connection object (Client) with specific state.
+ * @param state The client state (default: Connected).
+ * @param overrides Optional overrides for the client.
+ */
+declare function createMockConnection(state?: ClientState$1, overrides?: Partial<Client>): Client;
+/**
+ * Creates a mock handshake object.
+ * @param stage The stage of the handshake (default: None).
+ */
+declare function createMockHandshake(stage?: HandshakeStage): Handshake;
+/**
+ * Simulates a handshake between a mock client and server.
+ * Note: This is a high-level simulation helper.
+ * @param client The mock client connection.
+ * @param server The mock server instance.
+ * @returns Promise that resolves to true if handshake succeeded.
+ */
+declare function simulateHandshake(client: Client, server: any): Promise<boolean>;
+
+/**
+ * Interface for a mocked server console that can execute commands.
+ * Reference: quake2/server/sv_main.c (SV_ExecuteUserCommand)
+ */
+interface MockServerConsole {
+    exec(cmd: string): string;
+    print(text: string): void;
+    broadcast(text: string): void;
+    commandBuffer: string[];
+    outputBuffer: string[];
+}
+/**
+ * Creates a mock server console.
+ * @param overrides Optional overrides for the mock console.
+ */
+declare function createMockServerConsole(overrides?: Partial<MockServerConsole>): MockServerConsole;
+/**
+ * Interface for a mocked RCON client.
+ * Reference: quake2/server/sv_user.c (SV_ExecuteUserCommand for RCON handling)
+ */
+interface MockRConClient {
+    connect(address: string, port: number, password?: string): Promise<boolean>;
+    sendCommand(cmd: string): Promise<string>;
+    disconnect(): void;
+    connected: boolean;
+    lastCommand: string;
+    lastResponse: string;
+}
+/**
+ * Creates a mock RCON client.
+ * @param password Optional password for the client to use.
+ */
+declare function createMockRConClient(password?: string): MockRConClient;
+/**
+ * Simulates a command execution on the server.
+ * @param server The mock server instance (assumed to have some command handling capability).
+ * @param command The command string to execute.
+ * @returns The output of the command.
+ */
+declare function simulateServerCommand(server: any, command: string): string;
+
+interface MasterServer {
+    registerServer(info: ServerInfo): Promise<boolean>;
+    heartbeat(serverAddress: string): Promise<boolean>;
+    getServerList(filter?: ServerListFilter): Promise<ServerInfo[]>;
+}
+interface ServerInfo {
+    address: string;
+    name: string;
+    map: string;
+    players: number;
+    maxPlayers: number;
+    gametype: string;
+    version: string;
+    password?: boolean;
+}
+interface ServerListFilter {
+    gametype?: string;
+    map?: string;
+    notEmpty?: boolean;
+    notFull?: boolean;
+}
+/**
+ * Creates a mock master server for testing server registration and browsing
+ * @param overrides - Optional overrides for the master server behavior
+ */
+declare function createMockMasterServer(overrides?: Partial<MasterServer>): MasterServer;
+/**
+ * Creates a mock server info object
+ * @param overrides - Optional overrides
+ */
+declare function createMockServerInfo(overrides?: Partial<ServerInfo>): ServerInfo;
+/**
+ * Simulates the process of a game server registering with the master server
+ * @param server - The mock game server instance (typed as any to accept mock)
+ * @param master - The mock master server
+ */
+declare function simulateServerRegistration(server: any, master: MasterServer): Promise<boolean>;
+
+/**
+ * Mock interface for CollisionEntityIndex.
+ */
+interface MockCollisionEntityIndex {
+    trace: (start: any, mins: any, maxs: any, end: any, passEntity: any, contentMask: number) => TraceResult$1;
+    link: (entity: any) => void;
+    unlink: (entity: any) => void;
+    gatherTriggerTouches: (entity: any) => any[];
+}
+/**
+ * Creates a mock CollisionEntityIndex.
+ * @param overrides Optional overrides for the mock methods.
+ */
+declare function createMockCollisionEntityIndex(overrides?: Partial<MockCollisionEntityIndex>): MockCollisionEntityIndex;
+
+type MockServerContext = Server & {
+    clients: (Client | null)[];
+    entities?: Entity[];
+};
+interface MultiplayerScenario {
+    server: MockServerContext;
+    clients: Client[];
+    entities: Entity[];
+}
+/**
+ * Creates a multiplayer test scenario with a mock server and a number of clients.
+ * @param numPlayers Number of players to simulate.
+ */
+declare function createMultiplayerTestScenario(numPlayers?: number): MultiplayerScenario;
+/**
+ * Simulates a player joining the server.
+ * @param server The mock server instance.
+ * @param userInfo Optional user info overrides.
+ */
+declare function simulatePlayerJoin(server: MockServerContext, userInfo?: Partial<UserInfo>): Promise<Client>;
+/**
+ * Simulates a player leaving the server.
+ * @param server The mock server instance.
+ * @param clientNum The client number to disconnect.
+ */
+declare function simulatePlayerLeave(server: MockServerContext, clientNum: number): void;
+/**
+ * Simulates a single server frame update.
+ * @param server The mock server instance.
+ * @param deltaTime Time step in seconds (default: 0.1).
+ */
+declare function simulateServerTick(server: MockServerContext, deltaTime?: number): void;
+/**
+ * Simulates player input for a specific client.
+ * @param client The server client.
+ * @param input The input command.
+ */
+declare function simulatePlayerInput(client: Client, input: Partial<UserCommand>): void;
+
+interface Snapshot {
+    serverTime: number;
+    playerState: any;
+    entities: EntityState[];
+}
+interface DeltaSnapshot {
+    snapshot: Snapshot;
+    deltaEntities: EntityState[];
+    removedEntities: number[];
+}
+interface ConsistencyReport {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Creates a client-specific snapshot from the server state.
+ * @param serverState The current server state.
+ * @param clientNum The client number to generate snapshot for.
+ */
+declare function createServerSnapshot(serverState: Server, clientNum: number): Snapshot;
+/**
+ * Calculates the delta between two snapshots.
+ * @param oldSnapshot The baseline snapshot.
+ * @param newSnapshot The current snapshot.
+ */
+declare function createDeltaSnapshot(oldSnapshot: Snapshot, newSnapshot: Snapshot): DeltaSnapshot;
+/**
+ * Verifies the consistency of a sequence of snapshots.
+ * @param snapshots Array of snapshots ordered by time.
+ */
+declare function verifySnapshotConsistency(snapshots: Snapshot[]): ConsistencyReport;
+/**
+ * Simulates network delivery of a snapshot with potential packet loss.
+ * @param snapshot The snapshot to deliver.
+ * @param reliability Probability of successful delivery (0.0 to 1.0).
+ */
+declare function simulateSnapshotDelivery(snapshot: Snapshot, reliability?: number): Promise<Snapshot | null>;
+/**
+ * Parses a ProtocolPlayerState from a binary buffer.
+ * Useful for testing player state serialization.
+ * logic adapted from packages/engine/src/demo/parser.ts
+ * @param data The binary data to parse.
+ */
+declare function parseProtocolPlayerState(data: Uint8Array): ProtocolPlayerState;
+
+interface RateLimiter {
+    bytesPerSecond: number;
+    allow(bytes: number): boolean;
+    update(deltaSeconds: number): void;
+    reset(): void;
+    getUsage(): number;
+}
+interface Message {
+    data: Uint8Array;
+    size: number;
+    timestamp: number;
+}
+interface BandwidthScenario {
+    bandwidth: number;
+    clients: Client[];
+    duration: number;
+    totalBytesSent: number;
+    totalBytesReceived: number;
+    droppedPackets: number;
+}
+/**
+ * Creates a mock rate limiter for bandwidth testing
+ * @param bytesPerSecond - Maximum bytes per second allowed
+ */
+declare function createMockRateLimiter(bytesPerSecond: number): RateLimiter;
+/**
+ * Simulates bandwidth limiting on a stream of messages
+ * @param messages - Array of messages to process
+ * @param bandwidth - Bandwidth limit in bytes per second
+ * @returns Filtered array of messages that passed the bandwidth check
+ */
+declare function simulateBandwidthLimit(messages: Message[], bandwidth: number): Message[];
+/**
+ * Calculates the size of a client snapshot in bytes
+ * @param snapshot - The client frame snapshot
+ */
+declare function measureSnapshotSize(snapshot: ClientFrame): number;
+/**
+ * Creates a scenario for testing bandwidth limits with multiple clients
+ * @param bandwidth - Bandwidth limit per client or total
+ * @param numClients - Number of clients to simulate
+ */
+declare function createBandwidthTestScenario(bandwidth: number, numClients: number): BandwidthScenario;
+
+interface BrowserSetupOptions {
+    url?: string;
+    pretendToBeVisual?: boolean;
+    resources?: "usable";
+    enableWebGL2?: boolean;
+    enablePointerLock?: boolean;
+}
+/**
+ * Sets up a browser environment for testing using JSDOM and napi-rs/canvas.
+ * This should be called in your vitest.setup.ts file.
+ */
+declare function setupBrowserEnvironment(options?: BrowserSetupOptions): void;
+/**
+ * Cleans up the browser environment.
+ */
+declare function teardownBrowserEnvironment(): void;
+
+/**
+ * Creates a mock HTMLCanvasElement backed by napi-rs/canvas,
+ * with support for both 2D and WebGL2 contexts.
+ */
+declare function createMockCanvas(width?: number, height?: number): HTMLCanvasElement;
+/**
+ * Creates a mock CanvasRenderingContext2D.
+ */
+declare function createMockCanvasContext2D(canvas?: HTMLCanvasElement): CanvasRenderingContext2D;
+/**
+ * Information about a captured draw call.
+ */
+interface DrawCall {
+    method: string;
+    args: any[];
+}
+/**
+ * Wraps a CanvasRenderingContext2D to capture all method calls.
+ */
+declare function captureCanvasDrawCalls(context: CanvasRenderingContext2D): DrawCall[];
+/**
+ * Creates a mock ImageData object.
+ */
+declare function createMockImageData(width: number, height: number, fillColor?: [number, number, number, number]): ImageData;
+/**
+ * Creates a mock HTMLImageElement.
+ */
+declare function createMockImage(width?: number, height?: number, src?: string): HTMLImageElement;
+
+interface HeadlessWebGPUSetup {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    cleanup: () => Promise<void>;
+}
+interface WebGPUContextState {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    queue: GPUQueue;
+    format: GPUTextureFormat;
+}
+/**
+ * Initialize WebGPU in a headless Node.js environment using @webgpu/dawn (via webgpu package)
+ */
+declare function initHeadlessWebGPU(options?: {
+    powerPreference?: 'low-power' | 'high-performance';
+    requiredFeatures?: GPUFeatureName[];
+}): Promise<HeadlessWebGPUSetup>;
+/**
+ * Creates a complete context state for testing
+ */
+declare function createHeadlessTestContext(): Promise<WebGPUContextState>;
+
+interface MockWebGPUContext {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    queue: GPUQueue;
+}
+/**
+ * Patches globalThis with WebGPU globals (GPUBufferUsage, etc.)
+ * and optionally patches navigator.gpu.
+ */
+declare function setupWebGPUMocks(): {
+    mockGpu: {
+        requestAdapter: vitest.Mock<any, any>;
+        getPreferredCanvasFormat: vitest.Mock<any, any>;
+    };
+    mockAdapter: GPUAdapter;
+    mockDevice: GPUDevice;
+};
+declare function createMockGPUAdapter(options?: Partial<GPUAdapter>): GPUAdapter;
+declare function createMockGPUDevice(features?: Set<GPUFeatureName>): GPUDevice;
+declare function createMockQueue(): GPUQueue;
+declare function createMockGPUBuffer(descriptor: GPUBufferDescriptor): GPUBuffer;
+declare function createMockGPUTexture(descriptor: GPUTextureDescriptor): GPUTexture;
+declare function createMockTextureView(): GPUTextureView;
+declare function createMockSampler(): GPUSampler;
+declare function createMockShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
+declare function createMockComputePipeline(): GPUComputePipeline;
+declare function createMockRenderPipeline(): GPURenderPipeline;
+declare function createMockCommandEncoder(): GPUCommandEncoder;
+declare function createMockRenderPassEncoder(): GPURenderPassEncoder;
+declare function createMockComputePassEncoder(): GPUComputePassEncoder;
+declare function createMockWebGPUContext(): MockWebGPUContext;
+
+/**
+ * Interface for the mock RequestAnimationFrame implementation.
+ */
+interface MockRAF {
+    /**
+     * Advances time by one tick (simulating one frame).
+     * @param time Timestamp to pass to callbacks (default: calls Date.now())
+     */
+    tick(time?: number): void;
+    /**
+     * Advances time by a specific amount, triggering multiple frames if necessary.
+     * Not fully implemented in simple version, acts as alias to tick() with specific time.
+     */
+    advance(ms: number): void;
+    /**
+     * Returns current pending callbacks.
+     */
+    getCallbacks(): Array<{
+        id: number;
+        callback: FrameRequestCallback;
+    }>;
+}
+/**
+ * Creates a mock RequestAnimationFrame implementation.
+ * Replaces global.requestAnimationFrame and cancelAnimationFrame.
+ */
+declare function createMockRAF(): MockRAF;
+/**
+ * Creates a mock Performance object.
+ */
+declare function createMockPerformance(startTime?: number): Performance;
+interface ControlledTimer {
+    /**
+     * Advances virtual time by ms.
+     */
+    advanceBy(ms: number): void;
+    /**
+     * Runs all pending timers.
+     */
+    runAll(): void;
+    /**
+     * Restores original timer functions.
+     */
+    clear(): void;
+}
+/**
+ * Creates controlled timers (setTimeout/setInterval).
+ * Note: Use verify's useFakeTimers() for better integration with test runner.
+ * This is a lightweight alternative or specific helper.
+ */
+declare function createControlledTimer(): ControlledTimer;
+/**
+ * Simulates multiple RAF frames.
+ */
+declare function simulateFrames(count: number, frameTime?: number, callback?: (frameIndex: number) => void): void;
+
+/**
+ * Setup helpers for Node.js environments.
+ */
+interface NodeSetupOptions {
+}
+/**
+ * Sets up a Node.js environment for testing.
+ * Currently a placeholder for future Node-specific setup.
+ */
+declare function setupNodeEnvironment(options?: NodeSetupOptions): void;
+/**
+ * Teardown for Node.js environment.
+ */
+declare function teardownNodeEnvironment(): void;
+
+interface ShaderRecord {
+    readonly id: number;
+    readonly type: GLenum;
+}
+interface ProgramRecord {
+    readonly id: number;
+}
+declare class MockWebGL2RenderingContext {
+    readonly ARRAY_BUFFER = 34962;
+    readonly ELEMENT_ARRAY_BUFFER = 34963;
+    readonly STATIC_DRAW = 35044;
+    readonly DYNAMIC_DRAW = 35048;
+    readonly FLOAT = 5126;
+    readonly UNSIGNED_SHORT = 5123;
+    readonly TEXTURE_2D = 3553;
+    readonly TEXTURE_CUBE_MAP = 34067;
+    readonly TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
+    readonly TEXTURE0 = 33984;
+    readonly TEXTURE_WRAP_S = 10242;
+    readonly TEXTURE_WRAP_T = 10243;
+    readonly TEXTURE_MIN_FILTER = 10241;
+    readonly TEXTURE_MAG_FILTER = 10240;
+    readonly LINEAR = 9729;
+    readonly NEAREST = 9728;
+    readonly CLAMP_TO_EDGE = 33071;
+    readonly RGBA = 6408;
+    readonly UNSIGNED_BYTE = 5121;
+    readonly FRAMEBUFFER = 36160;
+    readonly COLOR_ATTACHMENT0 = 36064;
+    readonly DEPTH_ATTACHMENT = 36096;
+    readonly RENDERBUFFER = 36161;
+    readonly DEPTH_COMPONENT24 = 33190;
+    readonly FRAMEBUFFER_COMPLETE = 36053;
+    readonly TRIANGLES = 4;
+    readonly DEPTH_TEST = 2929;
+    readonly CULL_FACE = 2884;
+    readonly BLEND = 3042;
+    readonly SRC_ALPHA = 770;
+    readonly ONE_MINUS_SRC_ALPHA = 771;
+    readonly ONE = 1;
+    readonly BACK = 1029;
+    readonly LEQUAL = 515;
+    readonly VERTEX_SHADER = 35633;
+    readonly FRAGMENT_SHADER = 35632;
+    readonly COMPILE_STATUS = 35713;
+    readonly LINK_STATUS = 35714;
+    readonly ONE_MINUS_SRC_COLOR = 769;
+    readonly TRIANGLE_STRIP = 5;
+    readonly QUERY_RESULT_AVAILABLE = 34919;
+    readonly QUERY_RESULT = 34918;
+    readonly TRIANGLE_FAN = 6;
+    readonly COLOR_BUFFER_BIT = 16384;
+    readonly DEPTH_BUFFER_BIT = 256;
+    readonly canvas: HTMLCanvasElement | {
+        width: number;
+        height: number;
+    };
+    readonly drawingBufferWidth: number;
+    readonly drawingBufferHeight: number;
+    private shaderCounter;
+    private programCounter;
+    compileSucceeds: boolean;
+    linkSucceeds: boolean;
+    shaderInfoLog: string;
+    programInfoLog: string;
+    readonly extensions: Map<string, unknown>;
+    readonly calls: string[];
+    readonly uniformLocations: Map<string, WebGLUniformLocation | null>;
+    readonly attributeLocations: Map<string, number>;
+    constructor(canvas?: HTMLCanvasElement);
+    enable: vitest.Mock<[cap: number], number>;
+    disable: vitest.Mock<[cap: number], number>;
+    depthFunc: vitest.Mock<[func: number], number>;
+    cullFace: vitest.Mock<[mode: number], number>;
+    depthMask: vitest.Mock<[flag: boolean], number>;
+    blendFuncSeparate: vitest.Mock<[srcRGB: number, dstRGB: number, srcAlpha: number, dstAlpha: number], number>;
+    blendFunc: vitest.Mock<[sfactor: number, dfactor: number], number>;
+    getExtension: vitest.Mock<[name: string], {} | null>;
+    viewport: vitest.Mock<[x: number, y: number, w: number, h: number], number>;
+    clear: vitest.Mock<[mask: number], number>;
+    clearColor: vitest.Mock<[r: number, g: number, b: number, a: number], number>;
+    createShader: vitest.Mock<[type: number], WebGLShader>;
+    shaderSource: vitest.Mock<[shader: ShaderRecord, source: string], number>;
+    compileShader: vitest.Mock<[shader: ShaderRecord], number>;
+    getShaderParameter: vitest.Mock<[shader: ShaderRecord, pname: number], boolean | null>;
+    getShaderInfoLog: vitest.Mock<[], string>;
+    deleteShader: vitest.Mock<[shader: ShaderRecord], number>;
+    createProgram: vitest.Mock<[], WebGLProgram>;
+    attachShader: vitest.Mock<[program: ProgramRecord, shader: ShaderRecord], number>;
+    bindAttribLocation: vitest.Mock<[program: ProgramRecord, index: number, name: string], number>;
+    linkProgram: vitest.Mock<[program: ProgramRecord], number>;
+    getProgramParameter: vitest.Mock<[program: ProgramRecord, pname: number], boolean | null>;
+    getProgramInfoLog: vitest.Mock<[], string>;
+    deleteProgram: vitest.Mock<[program: ProgramRecord], number>;
+    useProgram: vitest.Mock<[program: ProgramRecord | null], number>;
+    getUniformLocation: vitest.Mock<[program: ProgramRecord, name: string], WebGLUniformLocation | null>;
+    getAttribLocation: vitest.Mock<[program: ProgramRecord, name: string], number>;
+    createBuffer: vitest.Mock<[], WebGLBuffer>;
+    bindBuffer: vitest.Mock<[target: number, buffer: WebGLBuffer | null], number>;
+    bufferData: vitest.Mock<[target: number, data: number | BufferSource, usage: number], number>;
+    bufferSubData: vitest.Mock<[target: number, offset: number, data: BufferSource], number>;
+    deleteBuffer: vitest.Mock<[buffer: WebGLBuffer], number>;
+    createVertexArray: vitest.Mock<[], WebGLVertexArrayObject>;
+    bindVertexArray: vitest.Mock<[vao: WebGLVertexArrayObject | null], number>;
+    enableVertexAttribArray: vitest.Mock<[index: number], number>;
+    vertexAttribPointer: vitest.Mock<[index: number, size: number, type: number, normalized: boolean, stride: number, offset: number], number>;
+    vertexAttribDivisor: vitest.Mock<[index: number, divisor: number], number>;
+    deleteVertexArray: vitest.Mock<[vao: WebGLVertexArrayObject], number>;
+    createTexture: vitest.Mock<[], WebGLTexture>;
+    activeTexture: vitest.Mock<[unit: number], number>;
+    bindTexture: vitest.Mock<[target: number, texture: WebGLTexture | null], number>;
+    texParameteri: vitest.Mock<[target: number, pname: number, param: number], number>;
+    texImage2D: vitest.Mock<[target: number, level: number, internalFormat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView<ArrayBufferLike> | null], number>;
+    texImage3D: vitest.Mock<any, any>;
+    deleteTexture: vitest.Mock<[texture: WebGLTexture], number>;
+    createFramebuffer: vitest.Mock<[], WebGLFramebuffer>;
+    bindFramebuffer: vitest.Mock<[target: number, framebuffer: WebGLFramebuffer | null], number>;
+    framebufferTexture2D: vitest.Mock<[target: number, attachment: number, textarget: number, texture: WebGLTexture | null, level: number], number>;
+    deleteFramebuffer: vitest.Mock<[fb: WebGLFramebuffer], number>;
+    checkFramebufferStatus: vitest.Mock<[target: number], number>;
+    createRenderbuffer: vitest.Mock<[], WebGLRenderbuffer>;
+    bindRenderbuffer: vitest.Mock<[target: number, renderbuffer: WebGLRenderbuffer | null], number>;
+    renderbufferStorage: vitest.Mock<[target: number, internalformat: number, width: number, height: number], number>;
+    framebufferRenderbuffer: vitest.Mock<[target: number, attachment: number, renderbuffertarget: number, renderbuffer: WebGLRenderbuffer | null], number>;
+    deleteRenderbuffer: vitest.Mock<[rb: WebGLRenderbuffer], number>;
+    drawArrays: vitest.Mock<[mode: number, first: number, count: number], number>;
+    drawElements: vitest.Mock<[mode: number, count: number, type: number, offset: number], number>;
+    createQuery: vitest.Mock<[], WebGLQuery>;
+    beginQuery: vitest.Mock<any, any>;
+    endQuery: vitest.Mock<any, any>;
+    deleteQuery: vitest.Mock<any, any>;
+    getQueryParameter: vitest.Mock<any, any>;
+    getParameter: vitest.Mock<any, any>;
+    uniform1f: vitest.Mock<[location: WebGLUniformLocation | null, x: number], number>;
+    uniform1i: vitest.Mock<[location: WebGLUniformLocation | null, x: number], number>;
+    uniform4f: vitest.Mock<[location: WebGLUniformLocation | null, x: number, y: number, z: number, w: number], number>;
+    uniform3fv: vitest.Mock<[location: WebGLUniformLocation | null, data: number[] | Float32List], number>;
+    uniform3f: vitest.Mock<[location: WebGLUniformLocation | null, x: number, y: number, z: number], number>;
+    uniform2f: vitest.Mock<[location: WebGLUniformLocation | null, x: number, y: number], number>;
+    uniform4fv: vitest.Mock<[location: WebGLUniformLocation | null, data: Float32List], number>;
+    uniformMatrix4fv: vitest.Mock<[location: WebGLUniformLocation | null, transpose: boolean, data: Iterable<number> | Float32List], number>;
+    uniformBlockBinding: vitest.Mock<any, any>;
+    isContextLost: vitest.Mock<[], boolean>;
+}
+declare function createMockWebGL2Context(overridesOrCanvas?: Partial<WebGL2RenderingContext> | HTMLCanvasElement): MockWebGL2RenderingContext;
+
+declare class FakeAudioParam implements AudioParamLike {
+    value: number;
+    constructor(value: number);
+}
+declare class FakeAudioNode implements AudioNodeLike {
+    readonly connections: AudioNodeLike[];
+    connect(destination: AudioNodeLike): void;
+}
+declare class FakeGainNode extends FakeAudioNode implements GainNodeLike, DynamicsCompressorNodeLike {
+    gain: FakeAudioParam;
+}
+declare class FakePannerNode extends FakeAudioNode implements PannerNodeLike {
+    positionX: FakeAudioParam;
+    positionY: FakeAudioParam;
+    positionZ: FakeAudioParam;
+    refDistance?: number;
+    maxDistance?: number;
+    rolloffFactor?: number;
+    distanceModel?: string;
+}
+declare class FakeBiquadFilterNode extends FakeAudioNode implements BiquadFilterNodeLike {
+    frequency: FakeAudioParam;
+    Q: FakeAudioParam;
+    type: string;
+}
+declare class FakeBufferSource extends FakeAudioNode implements AudioBufferSourceNodeLike {
+    buffer: AudioBufferLike | null;
+    loop: boolean;
+    playbackRate: FakeAudioParam;
+    onended: (() => void) | null;
+    startedAt?: number;
+    stoppedAt?: number;
+    start(when?: number, offset?: number, duration?: number): void;
+    stop(when?: number): void;
+    offset?: number;
+    duration?: number;
+}
+declare class FakeDestination extends FakeAudioNode implements AudioDestinationNodeLike {
+}
+declare class FakeAudioContext implements AudioContextLike {
+    readonly destination: FakeDestination;
+    state: AudioContextLike['state'];
+    currentTime: number;
+    resumeCalls: number;
+    readonly gains: GainNodeLike[];
+    readonly sources: FakeBufferSource[];
+    readonly panners: PannerNodeLike[];
+    readonly filters: BiquadFilterNodeLike[];
+    lastDecoded?: ArrayBuffer;
+    createPanner?: () => PannerNodeLike;
+    constructor(enablePanner?: boolean);
+    resume(): Promise<void>;
+    suspend(): Promise<void>;
+    createGain(): GainNodeLike;
+    createDynamicsCompressor(): DynamicsCompressorNodeLike;
+    createBufferSource(): AudioBufferSourceNodeLike;
+    createBiquadFilter(): BiquadFilterNodeLike;
+    decodeAudioData(data: ArrayBuffer): Promise<AudioBufferLike>;
+    advanceTime(seconds: number): void;
+}
+declare const createMockAudioBuffer: (duration?: number, channels?: number, sampleRate?: number) => AudioBufferLike;
+declare const createMockAudioContext: (overrides?: Partial<AudioContext>) => FakeAudioContext;
+declare const createMockPannerNode: (overrides?: Partial<PannerNode>) => FakePannerNode;
+declare const createMockBufferSource: (buffer?: AudioBuffer) => FakeBufferSource;
+
+declare function createMockRenderer(overrides?: Partial<Renderer>): Renderer;
+declare function createMockFrameRenderer(overrides?: Partial<FrameRenderer>): FrameRenderer;
+declare function createMockBspPipeline(overrides?: Partial<BspSurfacePipeline>): BspSurfacePipeline;
+declare function createMockMd2Pipeline(overrides?: Partial<Md2Pipeline>): Md2Pipeline;
+declare function createMockMd3Pipeline(overrides?: Partial<Md3Pipeline>): Md3Pipeline;
+declare function createMockSpritePipeline(overrides?: Partial<SpriteRenderer>): SpriteRenderer;
+declare function createMockSkyboxPipeline(overrides?: Partial<SkyboxPipeline>): SkyboxPipeline;
+
+declare function createMockAssetManager(overrides?: Partial<AssetManager>): AssetManager;
+declare function createMockTexture(width?: number, height?: number, data?: Uint8Array): PreparedTexture;
+declare function createMockMd2Model(overrides?: Partial<Md2Model>): Md2Model;
+declare function createMockMd3Model(overrides?: Partial<Md3Model>): Md3Model;
+declare function createMockBspMap(overrides?: Partial<BspMap>): BspMap;
+
+/**
+ * Creates a mock VertexBuffer with an optional data array.
+ */
+declare function createMockVertexBuffer(data?: Float32Array, usage?: BufferUsage): VertexBuffer;
+/**
+ * Creates a mock IndexBuffer with an optional data array.
+ */
+declare function createMockIndexBuffer(data?: Uint16Array, usage?: BufferUsage): IndexBuffer;
+/**
+ * Creates a mock ShaderProgram with optional overrides.
+ */
+declare function createMockShaderProgram(overrides?: Partial<ShaderProgram>): ShaderProgram;
+/**
+ * Helper to create a mock ShaderProgram with custom source code.
+ */
+declare function createMockShader(vertSource?: string, fragSource?: string): ShaderProgram;
+
+interface Lightmap {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+/**
+ * Creates a mock DLight with default values.
+ */
+declare function createMockDLight(position?: Vec3, color?: Vec3, intensity?: number): DLight;
+/**
+ * Creates a mock DynamicLightManager with spy methods.
+ */
+declare function createMockDLightManager(overrides?: Partial<DynamicLightManager>): DynamicLightManager;
+/**
+ * Creates a mock lightmap data structure.
+ */
+declare function createMockLightmap(width?: number, height?: number): Lightmap;
+
+interface MockParticle {
+    position: Vec3;
+    velocity: Vec3;
+    color: [number, number, number, number];
+    size: number;
+    lifetime: number;
+    gravity: number;
+    damping: number;
+    bounce: number;
+    blendMode: 'alpha' | 'additive';
+    fade: boolean;
+}
+interface MockParticleEmitter {
+    update: (dt: number) => void;
+    emit: () => void;
+}
+
+/**
+ * Creates a mock Particle with default values.
+ */
+declare function createMockParticle(overrides?: Partial<MockParticle>): MockParticle;
+/**
+ * Creates a mock ParticleEmitter.
+ */
+declare function createMockParticleEmitter(overrides?: Partial<MockParticleEmitter>): MockParticleEmitter;
+/**
+ * Creates a mock ParticleSystem.
+ */
+declare function createMockParticleSystem(overrides?: Partial<ParticleSystem>): ParticleSystem;
+
+interface MockPipeline {
+    render: ReturnType<typeof vi.fn>;
+    init: ReturnType<typeof vi.fn>;
+    resize: ReturnType<typeof vi.fn>;
+}
+interface MockCamera {
+    update: ReturnType<typeof vi.fn>;
+    getViewMatrix: ReturnType<typeof vi.fn>;
+    getProjectionMatrix: ReturnType<typeof vi.fn>;
+    getViewProjectionMatrix: ReturnType<typeof vi.fn>;
+    getPosition: ReturnType<typeof vi.fn>;
+    getForward: ReturnType<typeof vi.fn>;
+    getRight: ReturnType<typeof vi.fn>;
+    getUp: ReturnType<typeof vi.fn>;
+    extractFrustumPlanes: ReturnType<typeof vi.fn>;
+    transform: {
+        origin: number[];
+        angles: number[];
+        fov: number;
+    };
+}
+interface MockRenderingContext {
+    gl: MockWebGL2RenderingContext;
+    camera: MockCamera;
+    pipelines: {
+        md2: MockPipeline;
+        bsp: MockPipeline;
+        sprite: MockPipeline;
+        poly: MockPipeline;
+        particle: MockPipeline;
+    };
+}
+declare function createMockRenderingContext(): MockRenderingContext;
+
+/**
+ * Creates a mock LocalStorage instance.
+ */
+declare function createMockLocalStorage(initialData?: Record<string, string>): Storage;
+/**
+ * Creates a mock SessionStorage instance.
+ */
+declare function createMockSessionStorage(initialData?: Record<string, string>): Storage;
+/**
+ * Creates a mock IndexedDB factory.
+ * Wraps fake-indexeddb.
+ */
+declare function createMockIndexedDB(databases?: IDBDatabase[]): IDBFactory;
+interface StorageScenario {
+    localStorage: Storage;
+    sessionStorage: Storage;
+    indexedDB: IDBFactory;
+}
+/**
+ * Creates a complete storage test scenario.
+ */
+declare function createStorageTestScenario(storageType?: 'local' | 'session' | 'indexed'): StorageScenario;
+
+/**
+ * Mocks for Web Audio API.
+ */
+/**
+ * Sets up a mock AudioContext globally.
+ */
+declare function setupMockAudioContext(): void;
+/**
+ * Restores original AudioContext.
+ */
+declare function teardownMockAudioContext(): void;
+interface AudioEvent {
+    type: string;
+    data?: any;
+}
+/**
+ * Captures audio events from a context.
+ * Requires the context to be instrumented or mocked to emit events.
+ * This helper currently works with the `setupMockAudioContext` mock if extended.
+ */
+declare function captureAudioEvents(context: AudioContext): AudioEvent[];
+
+/**
+ * Interface for render test setup
+ */
+interface RenderTestSetup {
+    context: WebGPUContextState;
+    renderTarget: GPUTexture;
+    renderTargetView: GPUTextureView;
+    commandEncoder: GPUCommandEncoder;
+    cleanup: () => Promise<void>;
+    width: number;
+    height: number;
+}
+/**
+ * Creates a setup for testing rendering pipelines.
+ * Initializes a headless WebGPU context, a render target texture, and a command encoder.
+ */
+declare function createRenderTestSetup(width?: number, height?: number): Promise<RenderTestSetup>;
+/**
+ * Captures texture content to Uint8ClampedArray (RGBA).
+ * Creates its own CommandEncoder and submits immediately.
+ */
+declare function captureTexture(device: GPUDevice, texture: GPUTexture, width: number, height: number): Promise<Uint8ClampedArray>;
+/**
+ * Helper to render and capture the output as pixel data.
+ * It manages the render pass, submission, and buffer readback.
+ */
+declare function renderAndCapture(setup: RenderTestSetup, renderFn: (pass: GPURenderPassEncoder) => void): Promise<Uint8ClampedArray>;
+/**
+ * Interface for compute test setup
+ */
+interface ComputeTestSetup {
+    context: WebGPUContextState;
+    outputBuffer: GPUBuffer;
+    commandEncoder: GPUCommandEncoder;
+    cleanup: () => Promise<void>;
+    outputSize: number;
+}
+/**
+ * Creates a setup for testing compute shaders.
+ */
+declare function createComputeTestSetup(outputSize: number): Promise<ComputeTestSetup>;
+/**
+ * Helper to run a compute pass and read back the output buffer.
+ */
+declare function runComputeAndReadback(setup: ComputeTestSetup, computeFn: (pass: GPUComputePassEncoder) => void): Promise<ArrayBuffer>;
+
+interface GeometryBuffers {
+    vertexBuffer: GPUBuffer;
+    indexBuffer?: GPUBuffer;
+    vertexCount: number;
+    indexCount?: number;
+}
+/**
+ * Template for testing a rendering pipeline
+ */
+declare function testPipelineRendering(name: string, createPipeline: (device: GPUDevice) => GPURenderPipeline, setupGeometry: (device: GPUDevice) => GeometryBuffers, expectedOutput?: Uint8ClampedArray): Promise<void>;
+/**
+ * Template for testing compute shaders
+ */
+declare function testComputeShader(name: string, createComputePipeline: (device: GPUDevice) => GPUComputePipeline, inputData: Float32Array, expectedOutput?: Float32Array): Promise<void>;
+
+/**
+ * Client Input System Mocks
+ *
+ * Provides utilities for simulating user input (keyboard, mouse, pointer lock)
+ * in a test environment (JSDOM/Browser).
+ */
+interface KeyModifiers {
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+/**
+ * Factory for creating a mock KeyboardEvent.
+ */
+declare function createMockKeyboardEvent(key: string, type?: 'keydown' | 'keyup', modifiers?: KeyModifiers): KeyboardEvent;
+/**
+ * Factory for creating a mock MouseEvent with support for movementX/Y.
+ */
+declare function createMockMouseEvent(type: string, options?: MouseEventInit): MouseEvent;
+/**
+ * Factory for creating a mock WheelEvent.
+ */
+declare function createMockWheelEvent(deltaX?: number, deltaY?: number): WheelEvent;
+/**
+ * Class implementing a mock for the Pointer Lock API.
+ * Handles patching the document and element prototypes to simulate pointer lock.
+ */
+declare class MockPointerLock {
+    private _doc;
+    constructor(doc?: Document);
+    private setup;
+    get element(): Element | null;
+    get locked(): boolean;
+    request(element: HTMLElement): void;
+    exit(): void;
+    isLocked(): boolean;
+}
+/**
+ * Class for simulating input events.
+ */
+declare class InputInjector {
+    private doc;
+    private win;
+    constructor(doc?: Document, win?: Window);
+    keyDown(key: string, code?: string, modifiers?: KeyModifiers): void;
+    keyUp(key: string, code?: string, modifiers?: KeyModifiers): void;
+    mouseMove(movementX: number, movementY: number, clientX?: number, clientY?: number): void;
+    mouseButton(button: number, state?: 'down' | 'up'): void;
+    mouseDown(button?: number): void;
+    mouseUp(button?: number): void;
+    mouseWheel(deltaY: number): void;
+    wheel(deltaY: number): void;
+    private dispatchToTarget;
+}
+/**
+ * An implementation of InputSource that listens to DOM events.
+ * Useful for tests that want to verify interaction with real/mocked DOM events.
+ */
+declare class BrowserInputSource {
+    private target;
+    constructor(target?: EventTarget);
+    on(event: string, handler: Function): void;
+}
+/**
+ * Factory for creating a MockPointerLock instance.
+ */
+declare function createMockPointerLock(element?: HTMLElement): MockPointerLock;
+/**
+ * Factory for creating an InputInjector.
+ */
+declare function createInputInjector(target?: EventTarget): InputInjector;
+
+interface RefDef {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fov_x: number;
+    fov_y: number;
+    vieworg: vec3;
+    viewangles: vec3;
+    time: number;
+    rdflags: number;
+}
+interface ViewState {
+    camera: Camera;
+    viewport: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    refdef: RefDef;
+}
+interface ViewScenario {
+    viewState: ViewState;
+    cleanup: () => void;
+}
+interface CameraInput {
+    forward?: number;
+    right?: number;
+    up?: number;
+    pitchDelta?: number;
+    yawDelta?: number;
+    rollDelta?: number;
+}
+interface DemoCameraResult {
+    origin: Vec3;
+    angles: Vec3;
+    fov: number;
+}
+/**
+ * Creates a mock Camera instance with optional overrides.
+ * Accepts partial Camera properties, where position/angles can be Vec3 objects or arrays.
+ */
+declare function createMockCamera(overrides?: Partial<Omit<Camera, 'position' | 'angles'> & {
+    position: any;
+    angles: any;
+}>): Camera;
+/**
+ * Creates a mock Demo Camera state result (for getDemoCamera mock).
+ * This returns a structure using Vec3 interface compatible with angleVectors, unlike Camera class.
+ */
+declare function createMockDemoCameraResult(overrides?: Partial<DemoCameraResult>): DemoCameraResult;
+/**
+ * Creates a mock RefDef object.
+ */
+declare function createMockRefDef(overrides?: Partial<RefDef>): RefDef;
+/**
+ * Creates a mock ViewState object.
+ */
+declare function createMockViewState(overrides?: Partial<ViewState>): ViewState;
+/**
+ * Creates a pre-configured view test scenario.
+ */
+declare function createViewTestScenario(scenarioType: 'firstPerson' | 'thirdPerson' | 'spectator'): ViewScenario;
+/**
+ * Simulates camera movement based on input delta.
+ * This is a helper to verify camera logic, not a replacement for full physics.
+ */
+declare function simulateCameraMovement(camera: Camera, input: CameraInput, deltaTime: number): Camera;
+
+interface HudState {
+    ps: PlayerState;
+    client: PlayerClient;
+    health: number;
+    armor: number;
+    ammo: number;
+    stats: number[];
+    pickupIcon?: string;
+    damageIndicators?: any[];
+    renderStats?: FrameRenderStats;
+    timeMs: number;
+    messages: any;
+}
+declare function createMockHudState(overrides?: Partial<HudState>): HudState;
+declare function createMockScoreboard(players?: any[]): any;
+interface MockChatMessage {
+    text: string;
+    sender?: string;
+    timestamp?: number;
+}
+declare function createMockChatMessage(text: string, sender?: string, timestamp?: number): MockChatMessage;
+interface MockNotification {
+    type: string;
+    message: string;
+    duration?: number;
+}
+declare function createMockNotification(type: string, message: string, duration?: number): MockNotification;
+
+/**
+ * Mocks a server message by just providing the type and data buffer.
+ * In a real scenario, this would be constructing a binary packet.
+ */
+interface MockServerMessage {
+    type: number;
+    data: Uint8Array;
+}
+declare function createMockServerMessage(type: number, data?: Uint8Array): MockServerMessage;
+/**
+ * Creates a mock Snapshot (FrameData) for testing.
+ */
+declare function createMockSnapshot(serverFrame: number, entities?: EntityState$1[], playerState?: Partial<ProtocolPlayerState$1>, deltaFrame?: number): FrameData;
+/**
+ * Creates a mock Delta Frame (FrameData with delta flag).
+ */
+declare function createMockDeltaFrame(serverFrame: number, deltaFrame: number, entities?: EntityState$1[], playerState?: Partial<ProtocolPlayerState$1>): FrameData;
+/**
+ * Simulates network delay for a sequence of messages.
+ */
+declare function simulateNetworkDelay<T>(messages: T[], delayMs: number): Promise<T[]>;
+/**
+ * Simulates packet loss by randomly filtering messages.
+ * @param messages The messages to process
+ * @param lossPercent Percentage of packet loss (0-100)
+ */
+declare function simulatePacketLoss<T>(messages: T[], lossPercent: number): T[];
+/**
+ * Factory for creating a mock EntityState.
+ */
+declare function createMockEntityState(number: number, modelIndex?: number, origin?: Partial<Vec3>, overrides?: Partial<EntityState$1>): EntityState$1;
+declare function createMockDamageIndicator(damage: number, dir?: Vec3, health?: boolean, armor?: boolean, power?: boolean): DamageIndicator;
+declare function createMockFogData(overrides?: Partial<FogData>): FogData;
+
+interface DownloadManager {
+    download(url: string): Promise<ArrayBuffer>;
+    cancel(url: string): void;
+    getProgress(url: string): number;
+}
+declare function createMockDownloadManager(overrides?: Partial<DownloadManager>): DownloadManager;
+interface PrecacheList {
+    models: string[];
+    sounds: string[];
+    images: string[];
+}
+declare function createMockPrecacheList(models?: string[], sounds?: string[], images?: string[]): PrecacheList;
+declare function simulateDownload(url: string, progressCallback?: (percent: number) => void): Promise<ArrayBuffer>;
+
+declare class MockClientConfigStrings {
+    private readonly strings;
+    private readonly models;
+    private readonly sounds;
+    private readonly images;
+    constructor();
+    set(index: number, value: string): void;
+    get(index: number): string | undefined;
+    getModelName(index: number): string | undefined;
+    getSoundName(index: number): string | undefined;
+    getImageName(index: number): string | undefined;
+    getPlayerName(playernum: number): string | undefined;
+    clear(): void;
+}
+interface ClientStateProvider {
+    tickRate: number;
+    frameTimeMs: number;
+    serverFrame: number;
+    serverProtocol: number;
+    configStrings: MockClientConfigStrings;
+    getClientName(num: number): string;
+    getKeyBinding(key: string): string;
+    inAutoDemo: boolean;
+}
+interface ClientInfo {
+    name: string;
+    skin: string;
+    model: string;
+    icon: string;
+}
+interface ClientState extends ClientStateProvider {
+    playerNum: number;
+    serverTime: number;
+    parseEntities: number;
+}
+interface Frame {
+    serverFrame: number;
+    deltaFrame: number;
+    valid: boolean;
+    entities: EntityState[];
+}
+interface ConnectionState {
+    state: 'disconnected' | 'connecting' | 'connected' | 'active';
+}
+declare const createMockClientState: (overrides?: Partial<ClientState>) => ClientState;
+declare const createMockFrame: (overrides?: Partial<Frame>) => Frame;
+declare const createMockClientInfo: (overrides?: Partial<ClientInfo>) => ClientInfo;
+declare const createMockConnectionState: (state?: ConnectionState["state"]) => ConnectionState;
+
+interface MockConsole {
+    print: (text: string) => void;
+    error: (text: string) => void;
+    execute: (text: string) => void;
+    addCommand: (name: string, handler: (args: string[]) => void) => void;
+    getCvar: (name: string) => string | undefined;
+    setCvar: (name: string, value: string) => void;
+    getHistory: () => string[];
+    clearHistory: () => void;
+    getErrors: () => string[];
+}
+interface MockCommand {
+    name: string;
+    handler: (args: string[]) => void;
+}
+interface CvarRegistry {
+    [key: string]: string;
+}
+declare function createMockConsole(overrides?: Partial<MockConsole>): MockConsole;
+declare function createMockCommand(name: string, handler: (args: string[]) => void): MockCommand;
+declare function createMockCvarRegistry(initialCvars?: Record<string, string>): CvarRegistry;
+
+interface PredictionScenario {
+    clientState: ClientState;
+    snapshots: EntityState[][];
+    lagMs: number;
+}
+interface SmoothingAnalysis {
+    smooth: boolean;
+    maxError: number;
+    averageError: number;
+    jumps: number[];
+}
+declare const createPredictionTestScenario: (lagMs?: number) => PredictionScenario;
+declare const simulateClientPrediction: (state: ClientState, input: UserCommand, deltaTime: number) => ClientState;
+declare const createInterpolationTestData: (startState: EntityState, endState: EntityState, steps?: number) => EntityState[];
+declare const verifySmoothing: (states: EntityState[]) => SmoothingAnalysis;
+
+interface CaptureOptions {
+    width: number;
+    height: number;
+    format?: GPUTextureFormat;
+}
+declare function captureFramebufferAsPNG(device: GPUDevice, texture: GPUTexture, options: CaptureOptions): Promise<Buffer>;
+declare function savePNG(pixels: Uint8ClampedArray, width: number, height: number, filepath: string): Promise<void>;
+declare function loadPNG(filepath: string): Promise<{
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+}>;
+interface ComparisonResult {
+    pixelsDifferent: number;
+    totalPixels: number;
+    percentDifferent: number;
+    passed: boolean;
+    diffImage?: Uint8ClampedArray;
+}
+interface ComparisonOptions {
+    threshold?: number;
+    includeAA?: boolean;
+    diffColor?: [number, number, number];
+    maxDifferencePercent?: number;
+}
+declare function compareSnapshots(actual: Uint8ClampedArray, expected: Uint8ClampedArray, width: number, height: number, options?: ComparisonOptions): Promise<ComparisonResult>;
+interface SnapshotTestOptions extends ComparisonOptions {
+    name: string;
+    width?: number;
+    height?: number;
+    updateBaseline?: boolean;
+    snapshotDir?: string;
+}
+declare function getSnapshotPath(name: string, type: 'baseline' | 'actual' | 'diff', snapshotDir?: string): string;
+declare function expectSnapshot(pixels: Uint8ClampedArray, options: SnapshotTestOptions): Promise<void>;
+declare function renderAndExpectSnapshot(setup: RenderTestSetup, renderFn: (pass: GPURenderPassEncoder) => void, options: Omit<SnapshotTestOptions, 'width' | 'height'>): Promise<void>;
+
+interface PlaywrightOptions {
+    headless?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}
+interface PlaywrightTestClient {
+    page: any;
+    browser: any;
+    navigate(url: string): Promise<void>;
+    waitForGame(): Promise<void>;
+    injectInput(type: string, data: any): Promise<void>;
+    screenshot(name: string): Promise<Buffer>;
+    close(): Promise<void>;
+}
+/**
+ * Creates a Playwright test client.
+ * Note: Requires playwright to be installed in the project.
+ */
+declare function createPlaywrightTestClient(options?: PlaywrightOptions): Promise<PlaywrightTestClient>;
+/**
+ * Waits for the game to be ready.
+ */
+declare function waitForGameReady(page: any, timeout?: number): Promise<void>;
+interface GameStateCapture {
+    time: number;
+    entities: number;
+}
+/**
+ * Captures current game state from the browser.
+ */
+declare function captureGameState(page: any): Promise<GameStateCapture>;
+
+type NetworkCondition = 'good' | 'slow' | 'unstable' | 'offline' | 'custom';
+interface NetworkSimulator {
+    latency: number;
+    jitter: number;
+    packetLoss: number;
+    bandwidth: number;
+}
+/**
+ * Simulates network conditions.
+ */
+declare function simulateNetworkCondition(condition: NetworkCondition): NetworkSimulator;
+/**
+ * Creates a custom network condition.
+ */
+declare function createCustomNetworkCondition(latency: number, jitter: number, packetLoss: number): NetworkSimulator;
+/**
+ * Helper to throttle bandwidth (e.g. for Playwright).
+ */
+declare function throttleBandwidth(bytesPerSecond: number): void;
+
+interface VisualDiff {
+    diffPercentage: number;
+    diffImage?: Buffer;
+}
+/**
+ * Captures a screenshot of the game using Playwright.
+ * @param page Playwright Page object
+ * @param name Output filename (without extension)
+ */
+declare function captureGameScreenshot(page: any, name: string): Promise<Buffer>;
+/**
+ * Saves a canvas to a PNG file.
+ * Compatible with both JSDOM/HTMLCanvasElement and @napi-rs/canvas.
+ */
+declare function takeScreenshot(canvas: Canvas | HTMLCanvasElement, filepath: string): Promise<void>;
+/**
+ * Compares a canvas state against a baseline image file.
+ * Returns true if they match (within optional threshold logic, currently strict pixel match).
+ * If baseline does not exist, it saves the current state as baseline and returns true.
+ */
+declare function compareScreenshot(canvas: Canvas | HTMLCanvasElement, baselinePath: string): Promise<boolean>;
+/**
+ * Compares two screenshots (Buffers).
+ * Uses simple buffer check. Kept for backward compatibility or direct buffer comparison.
+ */
+declare function compareScreenshots(baseline: Buffer, current: Buffer, threshold?: number): VisualDiff;
+interface VisualScenario {
+    sceneName: string;
+    setup: () => Promise<void>;
+}
+/**
+ * Creates a visual test scenario.
+ */
+declare function createVisualTestScenario(sceneName: string): VisualScenario;
+
+export { type AudioEvent, type BandwidthScenario, type BinaryStreamMock, type BinaryWriterMock, BrowserInputSource, type BrowserSetupOptions, type CameraInput, type CaptureOptions, type ClientInfo, type ClientState, type ClientStateProvider, type ComparisonOptions, type ComparisonResult, type ComputeTestSetup, type Connection, type ConnectionState, type ConsistencyReport, type ControlledTimer, type CvarRegistry, type DeltaSnapshot, type DemoCameraResult, type DownloadManager, type DrawCall, FakeAudioContext, FakeAudioNode, FakeAudioParam, FakeBiquadFilterNode, FakeBufferSource, FakeDestination, FakeGainNode, FakePannerNode, type Frame, type GameState, type GameStateCapture, type GeometryBuffers, type Handshake, HandshakeStage, type HeadlessWebGPUSetup, type HudState, InputInjector, type KeyModifiers, type LevelFrameState, type Lightmap, type MasterServer, type Message, type MessageReaderMock, type MessageWriterMock, type MockAI, FakeBufferSource as MockAudioBufferSourceNode, type MockChatMessage, MockClientConfigStrings, type MockCollisionEntityIndex, type MockCommand, type MockConsole, type MockDamageInfo, type MockEngine, type MockGame, type MockMonsterAI, MockNetDriver, type MockNetDriverState, MockNetworkTransport, type MockNotification, type MockParticle, type MockParticleEmitter, MockPointerLock, type MockRAF, type MockRConClient, type MockRenderingContext, type MockSaveGame, type MockServer, type MockServerConsole, type MockServerContext, type MockServerMessage, MockTransport, type MockUDPSocket, MockWebGL2RenderingContext, type MockWebGPUContext, type MultiplayerScenario, type NetworkAddress, type NetworkCondition, type NetworkSimulator, type NodeSetupOptions, type PacketMock, type PhysicsScenario, type PlaywrightOptions, type PlaywrightTestClient, type PrecacheList, type PredictionScenario, type RateLimiter, type RecordedPacket, type RefDef, type RenderTestSetup, type SaveGameDiff, type ServerInfo, type ServerListFilter, type SmoothingAnalysis, type Snapshot, type SnapshotTestOptions, type StorageScenario, type SurfaceMock, type TestContext, type TraceMock, type Transform, type UserInfo, type ViewScenario, type ViewState, type VisualDiff, type VisualScenario, type WebGPUContextState, captureAudioEvents, captureCanvasDrawCalls, captureFramebufferAsPNG, captureGameScreenshot, captureGameState, captureTexture, compareSaveGames, compareScreenshot, compareScreenshots, compareSnapshots, createBandwidthTestScenario, createBinaryStreamMock, createBinaryWriterMock, createBounds, createCombatTestContext, createComputeTestSetup, createConfigStringArrayMock, createConfigStringMock, createControlledTimer, createCustomNetworkCondition, createCvarMock, createDeltaSnapshot, createEntity, createEntityFactory, createEntityStateFactory, createGameImportsAndEngine, 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, createMockDLight, createMockDLightManager, createMockDamageIndicator, createMockDamageInfo, createMockDeltaFrame, createMockDemoCameraResult, createMockDownloadManager, createMockEngine, createMockEntityState, createMockFogData, createMockFrame, createMockFrameRenderer, createMockGPUAdapter, createMockGPUBuffer, createMockGPUDevice, createMockGPUTexture, createMockGame, createMockGameExports, createMockGameState, createMockHandshake, createMockHealthItem, createMockHudState, createMockImage, createMockImageData, createMockIndexBuffer, createMockIndexedDB, createMockInventory, createMockItem, createMockKeyboardEvent, createMockLightmap, createMockLocalStorage, createMockMasterServer, createMockMd2Model, createMockMd2Pipeline, createMockMd3Model, createMockMd3Pipeline, createMockMonsterAI, createMockMonsterMove, createMockMouseEvent, createMockNetDriver, createMockNetworkAddress, createMockNotification, createMockPannerNode, createMockParticle, createMockParticleEmitter, createMockParticleSystem, createMockPerformance, createMockPlayerState, createMockPointerLock, createMockPowerupItem, createMockPrecacheList, createMockQueue, createMockRAF, createMockRConClient, createMockRateLimiter, createMockRefDef, createMockRenderPassEncoder, createMockRenderPipeline, createMockRenderer, createMockRenderingContext, createMockSampler, createMockSaveGame, createMockScoreboard, createMockServer, createMockServerClient, createMockServerConsole, createMockServerInfo, createMockServerMessage, createMockServerState, createMockServerStatic, createMockSessionStorage, createMockShader, createMockShaderModule, createMockShaderProgram, createMockSkyboxPipeline, createMockSnapshot, createMockSpritePipeline, createMockTexture, createMockTextureView, createMockTransport, createMockUDPSocket, createMockUserInfo, createMockVertexBuffer, createMockViewState, createMockWeapon, createMockWeaponItem, createMockWebGL2Context, createMockWebGPUContext, createMockWheelEvent, createMonsterEntityFactory, createMultiplayerTestScenario, createNetChanMock, createPacketMock, createPhysicsTestContext, createPhysicsTestScenario, createPlayerEntityFactory, createPlayerStateFactory, createPlaywrightTestClient, createPredictionTestScenario, createProjectileEntityFactory, createRenderTestSetup, createSaveGameSnapshot, createServerSnapshot, createSpawnTestContext, createStorageTestScenario, createSurfaceMock, createTestContext, createTraceMock, createTransform, createTriggerEntityFactory, createVector3, createViewTestScenario, createVisualTestScenario, expectSnapshot, findPakFile, getSnapshotPath, initHeadlessWebGPU, loadMapFromPak, loadPNG, makeAxisBrush, makeBrushFromMinsMaxs, makeBspModel, makeLeaf, makeLeafModel, makeNode, makePlane, measureSnapshotSize, mockMonsterAttacks, parseProtocolPlayerState, randomVector3, renderAndCapture, renderAndExpectSnapshot, restoreSaveGameSnapshot, runComputeAndReadback, savePNG, serializeUserInfo, setupBrowserEnvironment, setupMockAudioContext, setupNodeEnvironment, setupWebGPUMocks, simulateBandwidthLimit, simulateCameraMovement, simulateClientPrediction, simulateDownload, simulateFrames, simulateGravity, simulateHandshake, simulateJump, simulateMovement, simulateNetworkCondition, simulateNetworkDelay, simulatePacketLoss, simulatePlayerInput, simulatePlayerJoin, simulatePlayerLeave, simulateServerCommand, simulateServerRegistration, simulateServerTick, simulateSnapshotDelivery, takeScreenshot, teardownBrowserEnvironment, teardownMockAudioContext, teardownNodeEnvironment, testComputeShader, testPipelineRendering, throttleBandwidth, verifySmoothing, verifySnapshotConsistency, waitForGameReady };