quake2ts 0.0.557 → 0.0.562

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

@@ -391,6 +391,218 @@ function createEntity() {
   return new Entity(1);
 }
 
+// src/game/mocks.ts
+function createMockGameState(overrides) {
+  return {
+    levelName: "test_level",
+    time: 0,
+    entities: [],
+    clients: [],
+    ...overrides
+  };
+}
+
+// src/server/mocks/transport.ts
+import { vi as vi3 } from "vitest";
+var MockTransport = class {
+  constructor() {
+    this.address = "127.0.0.1";
+    this.port = 27910;
+    this.sentMessages = [];
+    this.receivedMessages = [];
+    this.listening = false;
+    this.listenSpy = vi3.fn().mockImplementation(async (port) => {
+      this.port = port;
+      this.listening = true;
+    });
+    this.closeSpy = vi3.fn().mockImplementation(() => {
+      this.listening = false;
+    });
+  }
+  /**
+   * Start listening on the specified port.
+   */
+  async listen(port) {
+    return this.listenSpy(port);
+  }
+  /**
+   * Close the transport.
+   */
+  close() {
+    this.closeSpy();
+  }
+  /**
+   * Register a callback for new connections.
+   */
+  onConnection(callback) {
+    this.onConnectionCallback = callback;
+  }
+  /**
+   * Register a callback for errors.
+   */
+  onError(callback) {
+    this.onErrorCallback = callback;
+  }
+  /**
+   * Check if the transport is currently listening.
+   */
+  isListening() {
+    return this.listening;
+  }
+  /**
+   * Helper to simulate a new connection.
+   * @param driver The network driver for the connection.
+   * @param info Optional connection info.
+   */
+  simulateConnection(driver, info) {
+    if (this.onConnectionCallback) {
+      this.onConnectionCallback(driver, info);
+    }
+  }
+  /**
+   * Helper to simulate an error.
+   * @param error The error to simulate.
+   */
+  simulateError(error) {
+    if (this.onErrorCallback) {
+      this.onErrorCallback(error);
+    }
+  }
+};
+function createMockUDPSocket(overrides) {
+  const socket = {
+    send: vi3.fn(),
+    on: vi3.fn(),
+    close: vi3.fn(),
+    bind: vi3.fn(),
+    address: vi3.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
+    ...overrides
+  };
+  return socket;
+}
+function createMockNetworkAddress(ip = "127.0.0.1", port = 27910) {
+  return { ip, port };
+}
+function createMockTransport(address = "127.0.0.1", port = 27910, overrides) {
+  const transport = new MockTransport();
+  transport.address = address;
+  transport.port = port;
+  Object.assign(transport, overrides);
+  return transport;
+}
+
+// src/server/mocks/state.ts
+import { ServerState, ClientState } from "@quake2ts/server";
+import { MAX_CONFIGSTRINGS, MAX_EDICTS } from "@quake2ts/shared";
+import { vi as vi4 } from "vitest";
+function createMockServerState(overrides) {
+  return {
+    state: ServerState.Game,
+    attractLoop: false,
+    loadGame: false,
+    startTime: Date.now(),
+    time: 0,
+    frame: 0,
+    name: "test_map",
+    collisionModel: null,
+    configStrings: new Array(MAX_CONFIGSTRINGS).fill(""),
+    baselines: new Array(MAX_EDICTS).fill(null),
+    multicastBuf: new Uint8Array(0),
+    ...overrides
+  };
+}
+function createMockServerStatic(maxClients = 16, overrides) {
+  return {
+    initialized: true,
+    realTime: Date.now(),
+    mapCmd: "",
+    spawnCount: 1,
+    clients: new Array(maxClients).fill(null),
+    lastHeartbeat: 0,
+    challenges: [],
+    ...overrides
+  };
+}
+function createMockServerClient(clientNum, overrides) {
+  const mockNet = {
+    connect: vi4.fn(),
+    disconnect: vi4.fn(),
+    send: vi4.fn(),
+    onMessage: vi4.fn(),
+    onClose: vi4.fn(),
+    onError: vi4.fn(),
+    isConnected: vi4.fn().mockReturnValue(true)
+  };
+  return {
+    index: clientNum,
+    state: ClientState.Connected,
+    edict: { index: clientNum + 1 },
+    net: mockNet,
+    netchan: {
+      qport: 0,
+      remoteAddress: "127.0.0.1",
+      incomingSequence: 0,
+      outgoingSequence: 0,
+      lastReceived: 0,
+      process: vi4.fn(),
+      transmit: vi4.fn(),
+      writeReliableByte: vi4.fn(),
+      writeReliableShort: vi4.fn(),
+      writeReliableLong: vi4.fn(),
+      writeReliableString: vi4.fn(),
+      writeReliableData: vi4.fn()
+    },
+    // Cast as any because NetChan might be complex to fully mock here
+    userInfo: "",
+    lastMessage: 0,
+    lastCommandTime: 0,
+    commandCount: 0,
+    messageQueue: [],
+    frames: [],
+    lastFrame: 0,
+    lastPacketEntities: [],
+    challenge: 0,
+    lastConnect: 0,
+    ping: 0,
+    rate: 0,
+    name: `Client${clientNum}`,
+    messageLevel: 0,
+    datagram: new Uint8Array(0),
+    downloadSize: 0,
+    downloadCount: 0,
+    commandMsec: 0,
+    frameLatency: [],
+    messageSize: [],
+    suppressCount: 0,
+    commandQueue: [],
+    lastCmd: {
+      msec: 0,
+      buttons: 0,
+      angles: { x: 0, y: 0, z: 0 },
+      forwardmove: 0,
+      sidemove: 0,
+      upmove: 0,
+      sequence: 0,
+      lightlevel: 0,
+      impulse: 0,
+      serverFrame: 0
+    },
+    ...overrides
+  };
+}
+function createMockServer(overrides) {
+  return {
+    start: vi4.fn().mockResolvedValue(void 0),
+    stop: vi4.fn(),
+    multicast: vi4.fn(),
+    unicast: vi4.fn(),
+    configstring: vi4.fn(),
+    kickPlayer: vi4.fn(),
+    changeMap: vi4.fn().mockResolvedValue(void 0),
+    ...overrides
+  };
+}
+
 // src/setup/browser.ts
 import { JSDOM } from "jsdom";
 import { Canvas, Image, ImageData } from "@napi-rs/canvas";
@@ -786,12 +998,6 @@ function teardownBrowserEnvironment() {
   delete global.UIEvent;
 }
 
-// src/setup/node.ts
-function setupNodeEnvironment() {
-  if (typeof global.fetch === "undefined") {
-  }
-}
-
 // src/setup/canvas.ts
 import { Canvas as Canvas2, Image as Image2, ImageData as ImageData2 } from "@napi-rs/canvas";
 function createMockCanvas(width = 300, height = 150) {
@@ -873,111 +1079,9 @@ function createMockImage(width, height, src) {
   return img;
 }
 
-// src/setup/timing.ts
-function createMockRAF() {
-  let callbacks = [];
-  let nextId = 1;
-  let currentTime = 0;
-  const originalRAF = global.requestAnimationFrame;
-  const originalCancelRAF = global.cancelAnimationFrame;
-  const raf = (callback) => {
-    const id = nextId++;
-    callbacks.push({ id, callback });
-    return id;
-  };
-  const cancel = (id) => {
-    callbacks = callbacks.filter((cb) => cb.id !== id);
-  };
-  const mock = {
-    tick(timestamp) {
-      if (typeof timestamp !== "number") {
-        currentTime += 16.6;
-      } else {
-        currentTime = timestamp;
-      }
-      const currentCallbacks = [...callbacks];
-      callbacks = [];
-      currentCallbacks.forEach(({ callback }) => {
-        callback(currentTime);
-      });
-    },
-    advance(deltaMs = 16.6) {
-      this.tick(currentTime + deltaMs);
-    },
-    getCallbacks() {
-      return callbacks.map((c) => c.callback);
-    },
-    reset() {
-      callbacks = [];
-      nextId = 1;
-      currentTime = 0;
-    },
-    enable() {
-      global.requestAnimationFrame = raf;
-      global.cancelAnimationFrame = cancel;
-    },
-    disable() {
-      if (originalRAF) {
-        global.requestAnimationFrame = originalRAF;
-      } else {
-        delete global.requestAnimationFrame;
-      }
-      if (originalCancelRAF) {
-        global.cancelAnimationFrame = originalCancelRAF;
-      } else {
-        delete global.cancelAnimationFrame;
-      }
-    }
-  };
-  return mock;
-}
-function createMockPerformance(startTime = 0) {
-  let currentTime = startTime;
-  const mockPerf = {
-    now: () => currentTime,
-    timeOrigin: startTime,
-    timing: {
-      navigationStart: startTime
-    },
-    // Add minimal navigation/resource timing interfaces to satisfy types if needed
-    clearMarks: () => {
-    },
-    clearMeasures: () => {
-    },
-    clearResourceTimings: () => {
-    },
-    getEntries: () => [],
-    getEntriesByName: () => [],
-    getEntriesByType: () => [],
-    mark: () => {
-    },
-    measure: () => {
-    },
-    setResourceTimingBufferSize: () => {
-    },
-    toJSON: () => ({}),
-    addEventListener: () => {
-    },
-    removeEventListener: () => {
-    },
-    dispatchEvent: () => true
-  };
-  mockPerf.advance = (deltaMs) => {
-    currentTime += deltaMs;
-  };
-  mockPerf.setTime = (time) => {
-    currentTime = time;
-  };
-  return mockPerf;
-}
-function simulateFrames(count, frameTimeMs = 16.6, callback) {
-  const raf = global.requestAnimationFrame;
-  if (!raf) return;
-}
-function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
-  for (let i = 0; i < count; i++) {
-    if (callback) callback(i);
-    mock.advance(frameTimeMs);
+// src/setup/node.ts
+function setupNodeEnvironment() {
+  if (typeof global.fetch === "undefined") {
   }
 }
 
@@ -1094,204 +1198,305 @@ function captureAudioEvents(context) {
   return [];
 }
 
+// src/setup/timing.ts
+var activeMockRAF;
+function createMockRAF() {
+  let callbacks = [];
+  let nextId = 1;
+  let currentTime = 0;
+  const originalRAF = global.requestAnimationFrame;
+  const originalCancelRAF = global.cancelAnimationFrame;
+  const raf = (callback) => {
+    const id = nextId++;
+    callbacks.push({ id, callback });
+    return id;
+  };
+  const cancel = (id) => {
+    callbacks = callbacks.filter((cb) => cb.id !== id);
+  };
+  const mock = {
+    tick(timestamp) {
+      if (typeof timestamp !== "number") {
+        currentTime += 16.6;
+      } else {
+        currentTime = timestamp;
+      }
+      const currentCallbacks = [...callbacks];
+      callbacks = [];
+      currentCallbacks.forEach(({ callback }) => {
+        callback(currentTime);
+      });
+    },
+    advance(deltaMs = 16.6) {
+      this.tick(currentTime + deltaMs);
+    },
+    getCallbacks() {
+      return callbacks.map((c) => c.callback);
+    },
+    reset() {
+      callbacks = [];
+      nextId = 1;
+      currentTime = 0;
+    },
+    enable() {
+      activeMockRAF = this;
+      global.requestAnimationFrame = raf;
+      global.cancelAnimationFrame = cancel;
+    },
+    disable() {
+      if (activeMockRAF === this) {
+        activeMockRAF = void 0;
+      }
+      if (originalRAF) {
+        global.requestAnimationFrame = originalRAF;
+      } else {
+        delete global.requestAnimationFrame;
+      }
+      if (originalCancelRAF) {
+        global.cancelAnimationFrame = originalCancelRAF;
+      } else {
+        delete global.cancelAnimationFrame;
+      }
+    }
+  };
+  return mock;
+}
+function createMockPerformance(startTime = 0) {
+  let currentTime = startTime;
+  const mockPerf = {
+    now: () => currentTime,
+    timeOrigin: startTime,
+    timing: {
+      navigationStart: startTime
+    },
+    clearMarks: () => {
+    },
+    clearMeasures: () => {
+    },
+    clearResourceTimings: () => {
+    },
+    getEntries: () => [],
+    getEntriesByName: () => [],
+    getEntriesByType: () => [],
+    mark: () => {
+    },
+    measure: () => {
+    },
+    setResourceTimingBufferSize: () => {
+    },
+    toJSON: () => ({}),
+    addEventListener: () => {
+    },
+    removeEventListener: () => {
+    },
+    dispatchEvent: () => true
+  };
+  mockPerf.advance = (deltaMs) => {
+    currentTime += deltaMs;
+  };
+  mockPerf.setTime = (time) => {
+    currentTime = time;
+  };
+  return mockPerf;
+}
+function createControlledTimer() {
+  let currentTime = 0;
+  let timers = [];
+  let nextId = 1;
+  const originalSetTimeout = global.setTimeout;
+  const originalClearTimeout = global.clearTimeout;
+  const originalSetInterval = global.setInterval;
+  const originalClearInterval = global.clearInterval;
+  const mockSetTimeout = (callback, delay = 0, ...args) => {
+    const id = nextId++;
+    timers.push({ id, callback, dueTime: currentTime + delay, args });
+    return id;
+  };
+  const mockClearTimeout = (id) => {
+    timers = timers.filter((t) => t.id !== id);
+  };
+  const mockSetInterval = (callback, delay = 0, ...args) => {
+    const id = nextId++;
+    timers.push({ id, callback, dueTime: currentTime + delay, interval: delay, args });
+    return id;
+  };
+  const mockClearInterval = (id) => {
+    timers = timers.filter((t) => t.id !== id);
+  };
+  global.setTimeout = mockSetTimeout;
+  global.clearTimeout = mockClearTimeout;
+  global.setInterval = mockSetInterval;
+  global.clearInterval = mockClearInterval;
+  return {
+    tick() {
+      this.advanceBy(0);
+    },
+    advanceBy(ms) {
+      const targetTime = currentTime + ms;
+      while (true) {
+        let earliest = null;
+        for (const t of timers) {
+          if (!earliest || t.dueTime < earliest.dueTime) {
+            earliest = t;
+          }
+        }
+        if (!earliest || earliest.dueTime > targetTime) {
+          break;
+        }
+        currentTime = earliest.dueTime;
+        const { callback, args, interval, id } = earliest;
+        if (interval !== void 0) {
+          earliest.dueTime += interval;
+          if (interval === 0) earliest.dueTime += 1;
+        } else {
+          timers = timers.filter((t) => t.id !== id);
+        }
+        callback(...args);
+      }
+      currentTime = targetTime;
+    },
+    clear() {
+      timers = [];
+    },
+    restore() {
+      global.setTimeout = originalSetTimeout;
+      global.clearTimeout = originalClearTimeout;
+      global.setInterval = originalSetInterval;
+      global.clearInterval = originalClearInterval;
+    }
+  };
+}
+function simulateFrames(count, frameTimeMs = 16.6, callback) {
+  if (!activeMockRAF) {
+    throw new Error("simulateFrames requires an active MockRAF. Ensure createMockRAF().enable() is called.");
+  }
+  for (let i = 0; i < count; i++) {
+    if (callback) callback(i);
+    activeMockRAF.advance(frameTimeMs);
+  }
+}
+function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
+  for (let i = 0; i < count; i++) {
+    if (callback) callback(i);
+    mock.advance(frameTimeMs);
+  }
+}
+
 // src/e2e/playwright.ts
 import { chromium } from "playwright";
+import { createServer } from "http";
+import handler from "serve-handler";
 async function createPlaywrightTestClient(options = {}) {
+  let staticServer;
+  let clientUrl = options.clientUrl;
+  const rootPath = options.rootPath || process.cwd();
+  if (!clientUrl) {
+    staticServer = createServer((request, response) => {
+      return handler(request, response, {
+        public: rootPath,
+        cleanUrls: false,
+        headers: [
+          {
+            source: "**/*",
+            headers: [
+              { key: "Cache-Control", value: "no-cache" },
+              { key: "Access-Control-Allow-Origin", value: "*" },
+              { key: "Cross-Origin-Opener-Policy", value: "same-origin" },
+              { key: "Cross-Origin-Embedder-Policy", value: "require-corp" }
+            ]
+          }
+        ]
+      });
+    });
+    await new Promise((resolve) => {
+      if (!staticServer) return;
+      staticServer.listen(0, () => {
+        const addr = staticServer?.address();
+        const port = typeof addr === "object" ? addr?.port : 0;
+        clientUrl = `http://localhost:${port}`;
+        console.log(`Test client serving from ${rootPath} at ${clientUrl}`);
+        resolve();
+      });
+    });
+  }
   const browser = await chromium.launch({
     headless: options.headless ?? true,
-    args: options.args || [
+    args: [
       "--use-gl=egl",
       "--ignore-gpu-blocklist",
-      "--no-sandbox",
-      "--disable-setuid-sandbox"
-    ]
+      ...options.launchOptions?.args || []
+    ],
+    ...options.launchOptions
   });
+  const width = options.width || 1280;
+  const height = options.height || 720;
   const context = await browser.newContext({
-    viewport: options.viewport || { width: 1280, height: 720 },
-    recordVideo: options.recordVideo,
-    deviceScaleFactor: 1
+    viewport: { width, height },
+    deviceScaleFactor: 1,
+    ...options.contextOptions
   });
   const page = await context.newPage();
-  const waitForGame = async (timeout = 1e4) => {
-    try {
-      await page.waitForFunction(() => {
-        return window.game || document.querySelector("canvas");
-      }, null, { timeout });
-    } catch (e) {
-      throw new Error(`Game did not initialize within ${timeout}ms`);
+  const close = async () => {
+    await browser.close();
+    if (staticServer) {
+      staticServer.close();
     }
   };
-  const client = {
+  const navigate = async (url) => {
+    const targetUrl = url || clientUrl;
+    if (!targetUrl) throw new Error("No URL to navigate to");
+    let finalUrl = targetUrl;
+    if (options.serverUrl && !targetUrl.includes("connect=")) {
+      const separator = targetUrl.includes("?") ? "&" : "?";
+      finalUrl = `${targetUrl}${separator}connect=${encodeURIComponent(options.serverUrl)}`;
+    }
+    console.log(`Navigating to: ${finalUrl}`);
+    await page.goto(finalUrl, { waitUntil: "domcontentloaded" });
+  };
+  return {
     browser,
     context,
     page,
-    async navigate(url) {
-      await page.goto(url, { waitUntil: "domcontentloaded" });
-    },
-    async waitForGame(timeout) {
-      await waitForGame(timeout);
-    },
-    async injectInput(type, key) {
-      if (type === "keydown") {
-        await page.keyboard.down(key);
-      } else {
-        await page.keyboard.up(key);
-      }
-    },
-    async injectMouse(type, x = 0, y = 0, button = 0) {
-      if (type === "move") {
-        await page.mouse.move(x, y);
-      } else if (type === "down") {
-        await page.mouse.down({ button: button === 0 ? "left" : button === 2 ? "right" : "middle" });
-      } else if (type === "up") {
-        await page.mouse.up({ button: button === 0 ? "left" : button === 2 ? "right" : "middle" });
-      }
-    },
-    async screenshot(path2) {
-      await page.screenshot({ path: path2 });
-    },
-    async close() {
-      await browser.close();
+    server: staticServer,
+    close,
+    navigate,
+    waitForGame: async (timeout = 1e4) => {
+      await waitForGameReady(page, timeout);
+    },
+    injectInput: async (type, data) => {
+      await page.evaluate(({ type: type2, data: data2 }) => {
+        if (window.injectGameInput) window.injectGameInput(type2, data2);
+      }, { type, data });
     }
   };
-  return client;
 }
 async function waitForGameReady(page, timeout = 1e4) {
-  await page.waitForFunction(() => {
-    return window.game || document.querySelector("canvas");
-  }, null, { timeout });
+  try {
+    await page.waitForFunction(() => {
+      return window.gameInstance && window.gameInstance.isReady;
+    }, null, { timeout });
+  } catch (e) {
+    await page.waitForSelector("canvas", { timeout });
+  }
 }
 async function captureGameState(page) {
   return await page.evaluate(() => {
-    const game = window.game;
-    if (!game) return {};
-    return {};
-  });
-}
-
-// src/e2e/network.ts
-var CONDITIONS = {
-  "good": {
-    offline: false,
-    downloadThroughput: 10 * 1024 * 1024,
-    // 10 Mbps
-    uploadThroughput: 5 * 1024 * 1024,
-    // 5 Mbps
-    latency: 20
-  },
-  "slow": {
-    offline: false,
-    downloadThroughput: 500 * 1024,
-    // 500 Kbps
-    uploadThroughput: 500 * 1024,
-    latency: 400
-  },
-  "unstable": {
-    offline: false,
-    downloadThroughput: 1 * 1024 * 1024,
-    uploadThroughput: 1 * 1024 * 1024,
-    latency: 100
-    // Jitter needs logic not simple preset
-  },
-  "offline": {
-    offline: true,
-    downloadThroughput: 0,
-    uploadThroughput: 0,
-    latency: 0
-  }
-};
-function simulateNetworkCondition(condition) {
-  const config = CONDITIONS[condition];
-  return createCustomNetworkCondition(config.latency, 0, 0, config);
-}
-function createCustomNetworkCondition(latency, jitter = 0, packetLoss = 0, baseConfig) {
-  return {
-    async apply(page) {
-      const client = await page.context().newCDPSession(page);
-      await client.send("Network.enable");
-      await client.send("Network.emulateNetworkConditions", {
-        offline: baseConfig?.offline || false,
-        latency: latency + Math.random() * jitter,
-        // Basic jitter application on setup (static)
-        downloadThroughput: baseConfig?.downloadThroughput || -1,
-        uploadThroughput: baseConfig?.uploadThroughput || -1
-      });
-    },
-    async clear(page) {
-      const client = await page.context().newCDPSession(page);
-      await client.send("Network.emulateNetworkConditions", {
-        offline: false,
-        latency: 0,
-        downloadThroughput: -1,
-        uploadThroughput: -1
-      });
+    if (window.gameInstance && window.gameInstance.getState) {
+      return window.gameInstance.getState();
     }
-  };
-}
-async function throttleBandwidth(page, bytesPerSecond) {
-  const simulator = createCustomNetworkCondition(0, 0, 0, {
-    offline: false,
-    latency: 0,
-    downloadThroughput: bytesPerSecond,
-    uploadThroughput: bytesPerSecond
-  });
-  await simulator.apply(page);
-}
-
-// src/e2e/visual.ts
-import path from "path";
-import fs from "fs/promises";
-async function captureGameScreenshot(page, name, options = {}) {
-  const dir = options.dir || "__screenshots__";
-  const screenshotPath = path.join(dir, `${name}.png`);
-  await fs.mkdir(dir, { recursive: true });
-  return await page.screenshot({
-    path: screenshotPath,
-    fullPage: options.fullPage ?? false,
-    animations: "disabled",
-    // Try to freeze animations if possible
-    caret: "hide"
+    return {};
   });
 }
-async function compareScreenshots(baseline, current, threshold = 0.1) {
-  if (baseline.equals(current)) {
-    return { pixelDiff: 0, matched: true };
-  }
-  return {
-    pixelDiff: -1,
-    // Unknown magnitude
-    matched: false
-  };
-}
-function createVisualTestScenario(page, sceneName) {
-  return {
-    async capture(snapshotName) {
-      return await captureGameScreenshot(page, `${sceneName}-${snapshotName}`);
-    },
-    async compare(snapshotName, baselineDir) {
-      const name = `${sceneName}-${snapshotName}`;
-      const current = await captureGameScreenshot(page, name, { dir: "__screenshots__/current" });
-      try {
-        const baselinePath = path.join(baselineDir, `${name}.png`);
-        const baseline = await fs.readFile(baselinePath);
-        return await compareScreenshots(baseline, current);
-      } catch (e) {
-        return { pixelDiff: -1, matched: false };
-      }
-    }
-  };
-}
 export {
   InputInjector,
   MockPointerLock,
+  MockTransport,
   captureAudioEvents,
   captureCanvasDrawCalls,
-  captureGameScreenshot,
   captureGameState,
-  compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
-  createCustomNetworkCondition,
+  createControlledTimer,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
@@ -1300,13 +1505,21 @@ export {
   createMockCanvasContext2D,
   createMockEngine,
   createMockGame,
+  createMockGameState,
   createMockImage,
   createMockImageData,
   createMockIndexedDB,
   createMockLocalStorage,
+  createMockNetworkAddress,
   createMockPerformance,
   createMockRAF,
+  createMockServer,
+  createMockServerClient,
+  createMockServerState,
+  createMockServerStatic,
   createMockSessionStorage,
+  createMockTransport,
+  createMockUDPSocket,
   createMockWebGL2Context,
   createNetChanMock,
   createPlayerStateFactory,
@@ -1314,7 +1527,6 @@ export {
   createSpawnContext,
   createStorageTestScenario,
   createTestContext,
-  createVisualTestScenario,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -1329,11 +1541,9 @@ export {
   setupNodeEnvironment,
   simulateFrames,
   simulateFramesWithMock,
-  simulateNetworkCondition,
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
-  throttleBandwidth,
   waitForGameReady
 };
 //# sourceMappingURL=index.js.map