quake2ts 0.0.582 → 0.0.584

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

@@ -1912,7 +1912,7 @@ function teardownBrowserEnvironment() {
 }
 
 // src/setup/canvas.ts
-import { Canvas as Canvas2, Image as Image2, ImageData as ImageData2 } from "@napi-rs/canvas";
+import { Canvas as Canvas2, ImageData as ImageData2 } from "@napi-rs/canvas";
 function createMockCanvas(width = 300, height = 150) {
   if (typeof document !== "undefined" && document.createElement) {
     const canvas2 = document.createElement("canvas");
@@ -1920,75 +1920,92 @@ function createMockCanvas(width = 300, height = 150) {
     canvas2.height = height;
     return canvas2;
   }
-  const canvas = new Canvas2(width, height);
-  const originalGetContext = canvas.getContext.bind(canvas);
-  canvas.getContext = function(contextId, options) {
-    if (contextId === "webgl2") {
-      return createMockWebGL2Context(canvas);
-    }
-    if (contextId === "2d") {
-      return originalGetContext("2d", options);
-    }
-    return originalGetContext(contextId, options);
+  const napiCanvas = new Canvas2(width, height);
+  const canvas = {
+    width,
+    height,
+    getContext: (contextId, options) => {
+      if (contextId === "2d") {
+        return napiCanvas.getContext("2d", options);
+      }
+      if (contextId === "webgl2") {
+        return createMockWebGL2Context(canvas);
+      }
+      return null;
+    },
+    toDataURL: () => napiCanvas.toDataURL(),
+    toBuffer: (mime) => napiCanvas.toBuffer(mime)
+    // Add other properties as needed
   };
   return canvas;
 }
 function createMockCanvasContext2D(canvas) {
-  if (!canvas) {
-    canvas = createMockCanvas();
+  const c = canvas || createMockCanvas();
+  const ctx = c.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to create 2D context");
   }
-  return canvas.getContext("2d");
+  return ctx;
 }
 function captureCanvasDrawCalls(context) {
-  const drawCalls = [];
-  const methodsToSpy = [
-    "fillRect",
-    "strokeRect",
-    "clearRect",
-    "fillText",
-    "strokeText",
-    "drawImage",
-    "beginPath",
-    "closePath",
-    "moveTo",
-    "lineTo",
-    "arc",
-    "arcTo",
-    "bezierCurveTo",
-    "quadraticCurveTo",
-    "stroke",
-    "fill",
-    "putImageData"
-  ];
-  methodsToSpy.forEach((method) => {
-    const original = context[method];
-    if (typeof original === "function") {
-      context[method] = function(...args) {
-        drawCalls.push({ method, args });
-        return original.apply(this, args);
+  const calls = [];
+  const proto = Object.getPrototypeOf(context);
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    const value = context[key];
+    if (typeof value === "function") {
+      context[key] = function(...args) {
+        calls.push({ method: key, args });
+        return value.apply(context, args);
       };
     }
-  });
-  return drawCalls;
+  }
+  return calls;
 }
 function createMockImageData(width, height, fillColor) {
-  const imageData = new ImageData2(width, height);
+  if (typeof global.ImageData !== "undefined") {
+    const data2 = new Uint8ClampedArray(width * height * 4);
+    if (fillColor) {
+      for (let i = 0; i < data2.length; i += 4) {
+        data2[i] = fillColor[0];
+        data2[i + 1] = fillColor[1];
+        data2[i + 2] = fillColor[2];
+        data2[i + 3] = fillColor[3];
+      }
+    }
+    return new global.ImageData(data2, width, height);
+  }
+  const data = new Uint8ClampedArray(width * height * 4);
   if (fillColor) {
-    const [r, g, b, a] = fillColor;
-    for (let i = 0; i < imageData.data.length; i += 4) {
-      imageData.data[i] = r;
-      imageData.data[i + 1] = g;
-      imageData.data[i + 2] = b;
-      imageData.data[i + 3] = a;
+    for (let i = 0; i < data.length; i += 4) {
+      data[i] = fillColor[0];
+      data[i + 1] = fillColor[1];
+      data[i + 2] = fillColor[2];
+      data[i + 3] = fillColor[3];
     }
   }
-  return imageData;
+  return new ImageData2(data, width, height);
 }
-function createMockImage(width, height, src) {
-  const img = new Image2();
-  if (width) img.width = width;
-  if (height) img.height = height;
-  if (src) img.src = src;
+function createMockImage(width = 100, height = 100, src = "") {
+  if (typeof document !== "undefined" && document.createElement) {
+    const img2 = document.createElement("img");
+    img2.width = width;
+    img2.height = height;
+    if (src) img2.src = src;
+    return img2;
+  }
+  const img = {
+    width,
+    height,
+    src,
+    complete: true,
+    onload: null,
+    onerror: null
+  };
+  if (src) {
+    setTimeout(() => {
+      if (img.onload) img.onload();
+    }, 0);
+  }
   return img;
 }
 
@@ -2056,193 +2073,89 @@ function setupWebGPUMocks() {
 }
 
 // src/setup/timing.ts
-var activeMockRAF;
 function createMockRAF() {
   let callbacks = [];
-  let nextId = 1;
+  let lastId = 0;
   let currentTime = 0;
   const originalRAF = global.requestAnimationFrame;
   const originalCancelRAF = global.cancelAnimationFrame;
-  const raf = (callback) => {
-    const id = nextId++;
-    callbacks.push({ id, callback });
-    return id;
+  global.requestAnimationFrame = (callback) => {
+    lastId++;
+    callbacks.push({ id: lastId, callback });
+    return lastId;
   };
-  const cancel = (id) => {
+  global.cancelAnimationFrame = (id) => {
     callbacks = callbacks.filter((cb) => cb.id !== id);
   };
-  const mock = {
-    tick(timestamp) {
-      if (typeof timestamp !== "number") {
-        currentTime += 16.6;
-      } else {
-        currentTime = timestamp;
-      }
+  return {
+    tick(time) {
+      if (time) currentTime = time;
+      else currentTime += 16.66;
       const currentCallbacks = [...callbacks];
       callbacks = [];
-      currentCallbacks.forEach(({ callback }) => {
-        callback(currentTime);
-      });
+      currentCallbacks.forEach((cb) => cb.callback(currentTime));
     },
-    advance(deltaMs = 16.6) {
-      this.tick(currentTime + deltaMs);
+    advance(ms) {
+      currentTime += ms;
+      this.tick(currentTime);
     },
     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 callbacks;
     }
   };
-  return mock;
 }
 function createMockPerformance(startTime = 0) {
-  let currentTime = startTime;
-  const mockPerf = {
-    now: () => currentTime,
+  let now = startTime;
+  const mockPerformance = {
+    now: () => now,
     timeOrigin: startTime,
     timing: {
       navigationStart: startTime
     },
-    clearMarks: () => {
-    },
-    clearMeasures: () => {
+    mark: (_name) => {
     },
-    clearResourceTimings: () => {
+    measure: (_name, _start, _end) => {
     },
     getEntries: () => [],
-    getEntriesByName: () => [],
-    getEntriesByType: () => [],
-    mark: () => {
-    },
-    measure: () => {
+    getEntriesByName: (_name) => [],
+    getEntriesByType: (_type) => [],
+    clearMarks: (_name) => {
     },
-    setResourceTimingBufferSize: () => {
+    clearMeasures: (_name) => {
     },
-    toJSON: () => ({}),
-    addEventListener: () => {
+    clearResourceTimings: () => {
     },
-    removeEventListener: () => {
+    setResourceTimingBufferSize: (_maxSize) => {
     },
-    dispatchEvent: () => true
-  };
-  mockPerf.advance = (deltaMs) => {
-    currentTime += deltaMs;
+    onresourcetimingbufferfull: null,
+    toJSON: () => ({})
   };
-  mockPerf.setTime = (time) => {
-    currentTime = time;
-  };
-  return mockPerf;
+  if (typeof global.performance === "undefined") {
+    global.performance = mockPerformance;
+  }
+  return mockPerformance;
 }
 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;
+  console.warn("createControlledTimer: Recommend using vi.useFakeTimers() instead.");
   return {
-    tick() {
-      this.advanceBy(0);
+    advanceBy: (ms) => {
     },
-    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;
+    runAll: () => {
     },
-    clear() {
-      timers = [];
-    },
-    restore() {
-      global.setTimeout = originalSetTimeout;
-      global.clearTimeout = originalClearTimeout;
-      global.setInterval = originalSetInterval;
-      global.clearInterval = originalClearInterval;
+    clear: () => {
     }
   };
 }
-function simulateFrames(count, frameTimeMs = 16.6, callback) {
-  if (!activeMockRAF) {
-    throw new Error("simulateFrames requires an active MockRAF. Ensure createMockRAF().enable() is called.");
-  }
+function simulateFrames(count, frameTime = 16, callback) {
   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/setup/node.ts
 function setupNodeEnvironment(options = {}) {
-  if (options.polyfillFetch && typeof global.fetch === "undefined") {
-  }
+}
+function teardownNodeEnvironment() {
 }
 
 // src/engine/rendering.ts
@@ -2304,186 +2217,141 @@ function createMockRenderingContext() {
 }
 
 // src/setup/storage.ts
-import "fake-indexeddb/auto";
-function createMockLocalStorage(initialData = {}) {
-  const storage = new Map(Object.entries(initialData));
+function createStorageMock(initialData = {}) {
+  const store = new Map(Object.entries(initialData));
   return {
-    getItem: (key) => storage.get(key) || null,
-    setItem: (key, value) => storage.set(key, value),
-    removeItem: (key) => storage.delete(key),
-    clear: () => storage.clear(),
-    key: (index) => Array.from(storage.keys())[index] || null,
+    getItem: (key) => store.get(key) || null,
+    setItem: (key, value) => store.set(key, value.toString()),
+    removeItem: (key) => store.delete(key),
+    clear: () => store.clear(),
+    key: (index) => Array.from(store.keys())[index] || null,
     get length() {
-      return storage.size;
+      return store.size;
     }
   };
 }
+function createMockLocalStorage(initialData = {}) {
+  return createStorageMock(initialData);
+}
 function createMockSessionStorage(initialData = {}) {
-  return createMockLocalStorage(initialData);
+  return createStorageMock(initialData);
 }
-function createMockIndexedDB() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
-  }
-  return indexedDB;
+function createMockIndexedDB(databases) {
+  return global.indexedDB;
 }
 function createStorageTestScenario(storageType = "local") {
-  if (storageType === "indexed") {
-    const dbName = `test-db-${Math.random().toString(36).substring(7)}`;
-    const storeName = "test-store";
-    const storage2 = createMockIndexedDB();
-    return {
-      storage: storage2,
-      populate: async (data) => {
-        return new Promise((resolve, reject) => {
-          const req = storage2.open(dbName, 1);
-          req.onupgradeneeded = (e) => {
-            const db = e.target.result;
-            db.createObjectStore(storeName);
-          };
-          req.onsuccess = (e) => {
-            const db = e.target.result;
-            const tx = db.transaction(storeName, "readwrite");
-            const store = tx.objectStore(storeName);
-            Object.entries(data).forEach(([k, v]) => store.put(v, k));
-            tx.oncomplete = () => {
-              db.close();
-              resolve();
-            };
-            tx.onerror = () => reject(tx.error);
-          };
-          req.onerror = () => reject(req.error);
-        });
-      },
-      verify: async (key, value) => {
-        return new Promise((resolve, reject) => {
-          const req = storage2.open(dbName, 1);
-          req.onsuccess = (e) => {
-            const db = e.target.result;
-            if (!db.objectStoreNames.contains(storeName)) {
-              db.close();
-              resolve(false);
-              return;
-            }
-            const tx = db.transaction(storeName, "readonly");
-            const store = tx.objectStore(storeName);
-            const getReq = store.get(key);
-            getReq.onsuccess = () => {
-              const result = getReq.result === value;
-              db.close();
-              resolve(result);
-            };
-            getReq.onerror = () => {
-              db.close();
-              resolve(false);
-            };
-          };
-          req.onerror = () => reject(req.error);
-        });
-      }
-    };
-  }
-  const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
   return {
-    storage,
-    populate(data) {
-      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
-    },
-    verify(key, value) {
-      return storage.getItem(key) === value;
-    }
+    localStorage: createMockLocalStorage(),
+    sessionStorage: createMockSessionStorage(),
+    indexedDB: createMockIndexedDB()
   };
 }
 
 // src/setup/audio.ts
-function createMockAudioContext() {
-  const context = {
-    createGain: () => ({
-      connect: () => {
-      },
-      gain: { value: 1, setValueAtTime: () => {
-      } }
-    }),
-    createOscillator: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      frequency: { value: 440 }
-    }),
-    createBufferSource: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      buffer: null,
-      playbackRate: { value: 1 },
-      loop: false
-    }),
-    destination: {},
-    currentTime: 0,
-    state: "running",
-    resume: async () => {
-    },
-    suspend: async () => {
-    },
-    close: async () => {
-    },
-    decodeAudioData: async (buffer) => ({
-      duration: 1,
-      length: 44100,
-      sampleRate: 44100,
-      numberOfChannels: 2,
-      getChannelData: () => new Float32Array(44100)
-    }),
-    createBuffer: (channels, length2, sampleRate) => ({
-      duration: length2 / sampleRate,
-      length: length2,
-      sampleRate,
-      numberOfChannels: channels,
-      getChannelData: () => new Float32Array(length2)
-    }),
-    // Helper to track events if needed
-    _events: []
-  };
-  return new Proxy(context, {
-    get(target, prop, receiver) {
-      if (prop === "_events") return target._events;
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === "function") {
-        return (...args) => {
-          target._events.push({ type: String(prop), args });
-          return Reflect.apply(value, target, args);
-        };
-      }
-      return value;
-    }
-  });
-}
 function setupMockAudioContext() {
-  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
-    global.AudioContext = class {
-      constructor() {
-        return createMockAudioContext();
-      }
-    };
-    global.window.AudioContext = global.AudioContext;
-    global.window.webkitAudioContext = global.AudioContext;
+  class MockAudioContext {
+    constructor() {
+      this.state = "suspended";
+      this.destination = {};
+      this.currentTime = 0;
+      this.listener = {
+        positionX: { value: 0 },
+        positionY: { value: 0 },
+        positionZ: { value: 0 },
+        forwardX: { value: 0 },
+        forwardY: { value: 0 },
+        forwardZ: { value: 0 },
+        upX: { value: 0 },
+        upY: { value: 0 },
+        upZ: { value: 0 },
+        setOrientation: () => {
+        },
+        setPosition: () => {
+        }
+      };
+    }
+    createGain() {
+      return {
+        gain: { value: 1, linearRampToValueAtTime: () => {
+        } },
+        connect: () => {
+        },
+        disconnect: () => {
+        }
+      };
+    }
+    createBufferSource() {
+      return {
+        buffer: null,
+        loop: false,
+        playbackRate: { value: 1 },
+        connect: () => {
+        },
+        start: () => {
+        },
+        stop: () => {
+        },
+        disconnect: () => {
+        },
+        onended: null
+      };
+    }
+    createPanner() {
+      return {
+        panningModel: "equalpower",
+        distanceModel: "inverse",
+        positionX: { value: 0 },
+        positionY: { value: 0 },
+        positionZ: { value: 0 },
+        orientationX: { value: 0 },
+        orientationY: { value: 0 },
+        orientationZ: { value: 0 },
+        coneInnerAngle: 360,
+        coneOuterAngle: 360,
+        coneOuterGain: 0,
+        connect: () => {
+        },
+        disconnect: () => {
+        },
+        setPosition: () => {
+        },
+        setOrientation: () => {
+        }
+      };
+    }
+    createBuffer(numOfChannels, length2, sampleRate) {
+      return {
+        duration: length2 / sampleRate,
+        length: length2,
+        sampleRate,
+        numberOfChannels: numOfChannels,
+        getChannelData: () => new Float32Array(length2)
+      };
+    }
+    decodeAudioData(data, success) {
+      const buffer = this.createBuffer(2, 100, 44100);
+      if (success) success(buffer);
+      return Promise.resolve(buffer);
+    }
+    resume() {
+      return Promise.resolve();
+    }
+    suspend() {
+      return Promise.resolve();
+    }
+    close() {
+      return Promise.resolve();
+    }
   }
+  global.AudioContext = MockAudioContext;
+  global.webkitAudioContext = MockAudioContext;
 }
 function teardownMockAudioContext() {
-  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
-    delete global.AudioContext;
-    delete global.window.AudioContext;
-    delete global.window.webkitAudioContext;
-  }
+  delete global.AudioContext;
+  delete global.webkitAudioContext;
 }
 function captureAudioEvents(context) {
-  return context._events || [];
+  return [];
 }
 
 // ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/common.js
@@ -2973,217 +2841,110 @@ function simulateCameraMovement(camera, input, deltaTime) {
 }
 
 // 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();
-      });
-    });
+  let playwright;
+  try {
+    playwright = await import("playwright");
+  } catch (e) {
+    throw new Error("Playwright is not installed. Please install it to use this utility.");
   }
-  const browser = await chromium.launch({
-    headless: options.headless ?? true,
-    args: [
-      "--use-gl=egl",
-      "--ignore-gpu-blocklist",
-      ...options.launchOptions?.args || []
-    ],
-    ...options.launchOptions
+  const browser = await playwright.chromium.launch({
+    headless: options.headless ?? true
   });
-  const width = options.width || 1280;
-  const height = options.height || 720;
   const context = await browser.newContext({
-    viewport: { width, height },
-    deviceScaleFactor: 1,
-    ...options.contextOptions
+    viewport: options.viewport || { width: 1280, height: 720 }
   });
   const page = await context.newPage();
-  const close = async () => {
-    await browser.close();
-    if (staticServer) {
-      staticServer.close();
-    }
-  };
-  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,
-    server: staticServer,
-    close,
-    navigate,
-    waitForGame: async (timeout = 1e4) => {
-      await waitForGameReady(page, timeout);
+    browser,
+    async navigate(url) {
+      await page.goto(url);
     },
-    injectInput: async (type, data) => {
+    async waitForGame() {
+      await waitForGameReady(page);
+    },
+    async injectInput(type, data) {
       await page.evaluate(({ type: type2, data: data2 }) => {
-        if (window.injectGameInput) window.injectGameInput(type2, data2);
+        console.log("Injecting input", type2, data2);
       }, { type, data });
+    },
+    async screenshot(name) {
+      return await page.screenshot({ path: `${name}.png` });
+    },
+    async close() {
+      await browser.close();
     }
   };
 }
 async function waitForGameReady(page, timeout = 1e4) {
-  try {
-    await page.waitForFunction(() => {
-      return window.gameInstance && window.gameInstance.isReady;
-    }, null, { timeout });
-  } catch (e) {
-    await page.waitForSelector("canvas", { timeout });
-  }
+  await page.waitForFunction(() => {
+    return window.game && window.game.isRunning;
+  }, { timeout });
 }
 async function captureGameState(page) {
   return await page.evaluate(() => {
-    if (window.gameInstance && window.gameInstance.getState) {
-      return window.gameInstance.getState();
-    }
-    return {};
+    const game = window.game;
+    return {
+      time: game ? game.time : 0,
+      entities: game && game.entities ? game.entities.length : 0
+    };
   });
 }
 
 // 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
-  },
-  "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) {
+  switch (condition) {
+    case "good":
+      return { latency: 20, jitter: 5, packetLoss: 0, bandwidth: 10 * 1024 * 1024 };
+    case "slow":
+      return { latency: 150, jitter: 20, packetLoss: 0.01, bandwidth: 1 * 1024 * 1024 };
+    case "unstable":
+      return { latency: 100, jitter: 100, packetLoss: 0.05, bandwidth: 512 * 1024 };
+    case "offline":
+      return { latency: 0, jitter: 0, packetLoss: 1, bandwidth: 0 };
+    case "custom":
+    default:
+      return { latency: 0, jitter: 0, packetLoss: 0, bandwidth: Infinity };
+  }
+}
+function createCustomNetworkCondition(latency, jitter, packetLoss) {
   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,
-        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
-      });
-    }
+    latency,
+    jitter,
+    packetLoss,
+    bandwidth: Infinity
+    // Default to unlimited unless specified
   };
 }
-async function throttleBandwidth(page, bytesPerSecond) {
-  const simulator = createCustomNetworkCondition(0, 0, 0, {
-    offline: false,
-    latency: 0,
-    downloadThroughput: bytesPerSecond,
-    uploadThroughput: bytesPerSecond
-  });
-  await simulator.apply(page);
+function throttleBandwidth(bytesPerSecond) {
 }
 
 // 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",
-    caret: "hide"
-  });
-}
-async function compareScreenshots(baseline, current, threshold = 0.1) {
-  if (baseline.equals(current)) {
-    return { pixelDiff: 0, matched: true };
+async function captureGameScreenshot(page, name) {
+  return await page.screenshot({ path: `${name}.png` });
+}
+function compareScreenshots(baseline, current, threshold = 0.01) {
+  if (baseline.length !== current.length) {
+    return { diffPercentage: 1 };
+  }
+  let diffPixels = 0;
+  const totalPixels = baseline.length;
+  for (let i = 0; i < baseline.length; i++) {
+    if (baseline[i] !== current[i]) {
+      diffPixels++;
+    }
   }
+  const diffPercentage = diffPixels / totalPixels;
   return {
-    pixelDiff: -1,
-    // Unknown magnitude
-    matched: false
+    diffPercentage
+    // Generating a diff image buffer would require a library like pixelmatch
   };
 }
-function createVisualTestScenario(page, sceneName) {
+function createVisualTestScenario(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 };
-      }
+    sceneName,
+    setup: async () => {
     }
   };
 }
@@ -3214,7 +2975,6 @@ export {
   createMockAI,
   createMockAmmoItem,
   createMockArmorItem,
-  createMockAudioContext,
   createMockCamera,
   createMockCanvas,
   createMockCanvasContext2D,
@@ -3300,7 +3060,6 @@ export {
   simulateBandwidthLimit,
   simulateCameraMovement,
   simulateFrames,
-  simulateFramesWithMock,
   simulateHandshake,
   simulateNetworkCondition,
   simulatePlayerInput,
@@ -3313,6 +3072,7 @@ export {
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
+  teardownNodeEnvironment,
   throttleBandwidth,
   verifySnapshotConsistency,
   waitForGameReady