quake2ts 0.0.553 → 0.0.557

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

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,18 +32,37 @@ var index_exports = {};
 __export(index_exports, {
   InputInjector: () => InputInjector,
   MockPointerLock: () => MockPointerLock,
+  captureAudioEvents: () => captureAudioEvents,
+  captureCanvasDrawCalls: () => captureCanvasDrawCalls,
+  captureGameScreenshot: () => captureGameScreenshot,
+  captureGameState: () => captureGameState,
+  compareScreenshots: () => compareScreenshots,
   createBinaryStreamMock: () => createBinaryStreamMock,
   createBinaryWriterMock: () => createBinaryWriterMock,
+  createCustomNetworkCondition: () => createCustomNetworkCondition,
   createEntity: () => createEntity,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
+  createMockAudioContext: () => createMockAudioContext,
+  createMockCanvas: () => createMockCanvas,
+  createMockCanvasContext2D: () => createMockCanvasContext2D,
   createMockEngine: () => createMockEngine,
   createMockGame: () => createMockGame,
+  createMockImage: () => createMockImage,
+  createMockImageData: () => createMockImageData,
+  createMockIndexedDB: () => createMockIndexedDB,
+  createMockLocalStorage: () => createMockLocalStorage,
+  createMockPerformance: () => createMockPerformance,
+  createMockRAF: () => createMockRAF,
+  createMockSessionStorage: () => createMockSessionStorage,
   createMockWebGL2Context: () => createMockWebGL2Context,
   createNetChanMock: () => createNetChanMock,
   createPlayerStateFactory: () => createPlayerStateFactory,
+  createPlaywrightTestClient: () => createPlaywrightTestClient,
   createSpawnContext: () => createSpawnContext,
+  createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
+  createVisualTestScenario: () => createVisualTestScenario,
   intersects: () => import_shared3.intersects,
   ladderTrace: () => import_shared3.ladderTrace,
   makeAxisBrush: () => makeAxisBrush,
@@ -44,9 +73,16 @@ __export(index_exports, {
   makeNode: () => makeNode,
   makePlane: () => makePlane,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
+  setupMockAudioContext: () => setupMockAudioContext,
   setupNodeEnvironment: () => setupNodeEnvironment,
+  simulateFrames: () => simulateFrames,
+  simulateFramesWithMock: () => simulateFramesWithMock,
+  simulateNetworkCondition: () => simulateNetworkCondition,
   stairTrace: () => import_shared3.stairTrace,
-  teardownBrowserEnvironment: () => teardownBrowserEnvironment
+  teardownBrowserEnvironment: () => teardownBrowserEnvironment,
+  teardownMockAudioContext: () => teardownMockAudioContext,
+  throttleBandwidth: () => throttleBandwidth,
+  waitForGameReady: () => waitForGameReady
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -444,123 +480,99 @@ function createEntity() {
 var import_jsdom = require("jsdom");
 var import_canvas = require("@napi-rs/canvas");
 var import_auto = require("fake-indexeddb/auto");
-function setupBrowserEnvironment(options = {}) {
-  const { url = "http://localhost", pretendToBeVisual = true } = options;
-  const dom = new import_jsdom.JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
-    url,
-    pretendToBeVisual
-  });
-  global.window = dom.window;
-  global.document = dom.window.document;
-  global.navigator = dom.window.navigator;
-  global.location = dom.window.location;
-  global.HTMLElement = dom.window.HTMLElement;
-  global.Event = dom.window.Event;
-  global.CustomEvent = dom.window.CustomEvent;
-  global.DragEvent = dom.window.DragEvent;
-  global.MouseEvent = dom.window.MouseEvent;
-  global.KeyboardEvent = dom.window.KeyboardEvent;
-  global.FocusEvent = dom.window.FocusEvent;
-  global.WheelEvent = dom.window.WheelEvent;
-  global.InputEvent = dom.window.InputEvent;
-  global.UIEvent = dom.window.UIEvent;
-  try {
-    global.localStorage = dom.window.localStorage;
-  } catch (e) {
-  }
-  if (!global.localStorage) {
-    const storage = /* @__PURE__ */ new Map();
-    global.localStorage = {
-      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,
-      get length() {
-        return storage.size;
+
+// src/e2e/input.ts
+var MockPointerLock = class {
+  static setup(doc) {
+    let _pointerLockElement = null;
+    Object.defineProperty(doc, "pointerLockElement", {
+      get: () => _pointerLockElement,
+      configurable: true
+    });
+    doc.exitPointerLock = () => {
+      if (_pointerLockElement) {
+        _pointerLockElement = null;
+        doc.dispatchEvent(new Event("pointerlockchange"));
       }
     };
-  }
-  const originalCreateElement = document.createElement.bind(document);
-  document.createElement = function(tagName, options2) {
-    if (tagName.toLowerCase() === "canvas") {
-      const napiCanvas = new import_canvas.Canvas(300, 150);
-      const domCanvas = originalCreateElement("canvas", options2);
-      Object.defineProperty(domCanvas, "width", {
-        get: () => napiCanvas.width,
-        set: (value) => {
-          napiCanvas.width = value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      Object.defineProperty(domCanvas, "height", {
-        get: () => napiCanvas.height,
-        set: (value) => {
-          napiCanvas.height = value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      const originalGetContext = domCanvas.getContext.bind(domCanvas);
-      domCanvas.getContext = function(contextId, options3) {
-        if (contextId === "2d") {
-          return napiCanvas.getContext("2d", options3);
-        }
-        if (contextId === "webgl" || contextId === "webgl2") {
-          return originalGetContext(contextId, options3);
-        }
-        return napiCanvas.getContext(contextId, options3);
-      };
-      domCanvas.__napiCanvas = napiCanvas;
-      return domCanvas;
-    }
-    return originalCreateElement(tagName, options2);
-  };
-  global.Image = import_canvas.Image;
-  global.ImageData = import_canvas.ImageData;
-  if (typeof global.createImageBitmap === "undefined") {
-    global.createImageBitmap = async function(image, _options) {
-      if (image && typeof image.width === "number" && typeof image.height === "number") {
-        const canvas2 = new import_canvas.Canvas(image.width, image.height);
-        const ctx = canvas2.getContext("2d");
-        if (image.data) {
-          ctx.putImageData(image, 0, 0);
-        }
-        return canvas2;
-      }
-      const canvas = new import_canvas.Canvas(100, 100);
-      return canvas;
+    global.HTMLElement.prototype.requestPointerLock = function() {
+      _pointerLockElement = this;
+      doc.dispatchEvent(new Event("pointerlockchange"));
     };
   }
-  if (typeof global.btoa === "undefined") {
-    global.btoa = function(str) {
-      return Buffer.from(str, "binary").toString("base64");
-    };
+};
+var InputInjector = class {
+  constructor(doc, win) {
+    this.doc = doc;
+    this.win = win;
   }
-  if (typeof global.atob === "undefined") {
-    global.atob = function(str) {
-      return Buffer.from(str, "base64").toString("binary");
-    };
+  keyDown(key, code) {
+    const event = new this.win.KeyboardEvent("keydown", {
+      key,
+      code: code || key,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    this.doc.dispatchEvent(event);
   }
-}
-function teardownBrowserEnvironment() {
-  delete global.window;
-  delete global.document;
-  delete global.navigator;
-  delete global.localStorage;
-  delete global.location;
-  delete global.HTMLElement;
-  delete global.Image;
-  delete global.ImageData;
-  delete global.createImageBitmap;
-}
-
-// src/setup/node.ts
-function setupNodeEnvironment() {
-  if (typeof global.fetch === "undefined") {
+  keyUp(key, code) {
+    const event = new this.win.KeyboardEvent("keyup", {
+      key,
+      code: code || key,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    this.doc.dispatchEvent(event);
   }
-}
+  mouseMove(movementX, movementY, clientX = 0, clientY = 0) {
+    const event = new this.win.MouseEvent("mousemove", {
+      bubbles: true,
+      cancelable: true,
+      view: this.win,
+      clientX,
+      clientY,
+      movementX,
+      // Note: JSDOM might not support this standard property fully on event init
+      movementY
+    });
+    Object.defineProperty(event, "movementX", { value: movementX });
+    Object.defineProperty(event, "movementY", { value: movementY });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+  mouseDown(button = 0) {
+    const event = new this.win.MouseEvent("mousedown", {
+      button,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+  mouseUp(button = 0) {
+    const event = new this.win.MouseEvent("mouseup", {
+      button,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+  wheel(deltaY) {
+    const event = new this.win.WheelEvent("wheel", {
+      deltaY,
+      bubbles: true,
+      cancelable: true,
+      view: this.win
+    });
+    const target = this.doc.pointerLockElement || this.doc;
+    target.dispatchEvent(event);
+  }
+};
 
 // src/setup/webgl.ts
 function createMockWebGL2Context(canvas) {
@@ -686,114 +698,709 @@ function createMockWebGL2Context(canvas) {
   return gl;
 }
 
-// src/e2e/input.ts
-var MockPointerLock = class {
-  static setup(doc) {
-    let _pointerLockElement = null;
-    Object.defineProperty(doc, "pointerLockElement", {
-      get: () => _pointerLockElement,
-      configurable: true
-    });
-    doc.exitPointerLock = () => {
-      if (_pointerLockElement) {
-        _pointerLockElement = null;
-        doc.dispatchEvent(new Event("pointerlockchange"));
+// src/setup/browser.ts
+function setupBrowserEnvironment(options = {}) {
+  const {
+    url = "http://localhost",
+    pretendToBeVisual = true,
+    resources = void 0,
+    enableWebGL2 = false,
+    enablePointerLock = false
+  } = options;
+  const dom = new import_jsdom.JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
+    url,
+    pretendToBeVisual,
+    resources
+  });
+  global.window = dom.window;
+  global.document = dom.window.document;
+  try {
+    global.navigator = dom.window.navigator;
+  } catch (e) {
+    try {
+      Object.defineProperty(global, "navigator", {
+        value: dom.window.navigator,
+        writable: true,
+        configurable: true
+      });
+    } catch (e2) {
+      console.warn("Could not assign global.navigator, skipping.");
+    }
+  }
+  global.location = dom.window.location;
+  global.HTMLElement = dom.window.HTMLElement;
+  global.HTMLCanvasElement = dom.window.HTMLCanvasElement;
+  global.Event = dom.window.Event;
+  global.CustomEvent = dom.window.CustomEvent;
+  global.DragEvent = dom.window.DragEvent;
+  global.MouseEvent = dom.window.MouseEvent;
+  global.KeyboardEvent = dom.window.KeyboardEvent;
+  global.FocusEvent = dom.window.FocusEvent;
+  global.WheelEvent = dom.window.WheelEvent;
+  global.InputEvent = dom.window.InputEvent;
+  global.UIEvent = dom.window.UIEvent;
+  try {
+    global.localStorage = dom.window.localStorage;
+  } catch (e) {
+  }
+  if (!global.localStorage) {
+    const storage = /* @__PURE__ */ new Map();
+    global.localStorage = {
+      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,
+      get length() {
+        return storage.size;
       }
     };
-    global.HTMLElement.prototype.requestPointerLock = function() {
-      _pointerLockElement = this;
-      doc.dispatchEvent(new Event("pointerlockchange"));
-    };
-  }
-};
-var InputInjector = class {
-  constructor(doc, win) {
-    this.doc = doc;
-    this.win = win;
   }
-  keyDown(key, code) {
-    const event = new this.win.KeyboardEvent("keydown", {
-      key,
-      code: code || key,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    this.doc.dispatchEvent(event);
+  const originalCreateElement = document.createElement.bind(document);
+  document.createElement = function(tagName, options2) {
+    if (tagName.toLowerCase() === "canvas") {
+      const napiCanvas = new import_canvas.Canvas(300, 150);
+      const domCanvas = originalCreateElement("canvas", options2);
+      Object.defineProperty(domCanvas, "width", {
+        get: () => napiCanvas.width,
+        set: (value) => {
+          napiCanvas.width = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(domCanvas, "height", {
+        get: () => napiCanvas.height,
+        set: (value) => {
+          napiCanvas.height = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      const originalGetContext = domCanvas.getContext.bind(domCanvas);
+      domCanvas.getContext = function(contextId, options3) {
+        if (contextId === "2d") {
+          return napiCanvas.getContext("2d", options3);
+        }
+        if (enableWebGL2 && contextId === "webgl2") {
+          return createMockWebGL2Context(domCanvas);
+        }
+        if (contextId === "webgl" || contextId === "webgl2") {
+          return originalGetContext(contextId, options3);
+        }
+        return napiCanvas.getContext(contextId, options3);
+      };
+      domCanvas.__napiCanvas = napiCanvas;
+      return domCanvas;
+    }
+    return originalCreateElement(tagName, options2);
+  };
+  if (enableWebGL2) {
+    const originalProtoGetContext = global.HTMLCanvasElement.prototype.getContext;
+    global.HTMLCanvasElement.prototype.getContext = function(contextId, options2) {
+      if (contextId === "webgl2") {
+        return createMockWebGL2Context(this);
+      }
+      return originalProtoGetContext.call(this, contextId, options2);
+    };
   }
-  keyUp(key, code) {
-    const event = new this.win.KeyboardEvent("keyup", {
-      key,
-      code: code || key,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    this.doc.dispatchEvent(event);
+  global.Image = import_canvas.Image;
+  global.ImageData = import_canvas.ImageData;
+  if (typeof global.createImageBitmap === "undefined") {
+    global.createImageBitmap = async function(image, _options) {
+      if (image && typeof image.width === "number" && typeof image.height === "number") {
+        const canvas2 = new import_canvas.Canvas(image.width, image.height);
+        const ctx = canvas2.getContext("2d");
+        if (image.data) {
+          ctx.putImageData(image, 0, 0);
+        }
+        return canvas2;
+      }
+      const canvas = new import_canvas.Canvas(100, 100);
+      return canvas;
+    };
   }
-  mouseMove(movementX, movementY, clientX = 0, clientY = 0) {
-    const event = new this.win.MouseEvent("mousemove", {
-      bubbles: true,
-      cancelable: true,
-      view: this.win,
-      clientX,
-      clientY,
-      movementX,
-      // Note: JSDOM might not support this standard property fully on event init
-      movementY
-    });
-    Object.defineProperty(event, "movementX", { value: movementX });
-    Object.defineProperty(event, "movementY", { value: movementY });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
+  if (typeof global.btoa === "undefined") {
+    global.btoa = function(str) {
+      return Buffer.from(str, "binary").toString("base64");
+    };
   }
-  mouseDown(button = 0) {
-    const event = new this.win.MouseEvent("mousedown", {
-      button,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
+  if (typeof global.atob === "undefined") {
+    global.atob = function(str) {
+      return Buffer.from(str, "base64").toString("binary");
+    };
   }
-  mouseUp(button = 0) {
-    const event = new this.win.MouseEvent("mouseup", {
-      button,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
+  if (enablePointerLock) {
+    MockPointerLock.setup(global.document);
   }
-  wheel(deltaY) {
-    const event = new this.win.WheelEvent("wheel", {
-      deltaY,
-      bubbles: true,
-      cancelable: true,
-      view: this.win
-    });
-    const target = this.doc.pointerLockElement || this.doc;
-    target.dispatchEvent(event);
+  if (typeof global.requestAnimationFrame === "undefined") {
+    let lastTime = 0;
+    global.requestAnimationFrame = (callback) => {
+      const currTime = Date.now();
+      const timeToCall = Math.max(0, 16 - (currTime - lastTime));
+      const id = setTimeout(() => {
+        callback(currTime + timeToCall);
+      }, timeToCall);
+      lastTime = currTime + timeToCall;
+      return id;
+    };
+    global.cancelAnimationFrame = (id) => {
+      clearTimeout(id);
+    };
+  }
+}
+function teardownBrowserEnvironment() {
+  delete global.window;
+  delete global.document;
+  delete global.navigator;
+  delete global.localStorage;
+  delete global.location;
+  delete global.HTMLElement;
+  delete global.HTMLCanvasElement;
+  delete global.Image;
+  delete global.ImageData;
+  delete global.createImageBitmap;
+  delete global.Event;
+  delete global.CustomEvent;
+  delete global.DragEvent;
+  delete global.MouseEvent;
+  delete global.KeyboardEvent;
+  delete global.FocusEvent;
+  delete global.WheelEvent;
+  delete global.InputEvent;
+  delete global.UIEvent;
+}
+
+// src/setup/node.ts
+function setupNodeEnvironment() {
+  if (typeof global.fetch === "undefined") {
+  }
+}
+
+// src/setup/canvas.ts
+var import_canvas2 = require("@napi-rs/canvas");
+function createMockCanvas(width = 300, height = 150) {
+  if (typeof document !== "undefined" && document.createElement) {
+    const canvas2 = document.createElement("canvas");
+    canvas2.width = width;
+    canvas2.height = height;
+    return canvas2;
+  }
+  const canvas = new import_canvas2.Canvas(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);
+  };
+  return canvas;
+}
+function createMockCanvasContext2D(canvas) {
+  if (!canvas) {
+    canvas = createMockCanvas();
+  }
+  return canvas.getContext("2d");
+}
+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);
+      };
+    }
+  });
+  return drawCalls;
+}
+function createMockImageData(width, height, fillColor) {
+  const imageData = new import_canvas2.ImageData(width, height);
+  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;
+    }
+  }
+  return imageData;
+}
+function createMockImage(width, height, src) {
+  const img = new import_canvas2.Image();
+  if (width) img.width = width;
+  if (height) img.height = height;
+  if (src) img.src = 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/storage.ts
+var import_auto2 = require("fake-indexeddb/auto");
+function createMockLocalStorage(initialData = {}) {
+  const storage = 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,
+    get length() {
+      return storage.size;
+    }
+  };
+}
+function createMockSessionStorage(initialData = {}) {
+  return createMockLocalStorage(initialData);
+}
+function createMockIndexedDB() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
+  }
+  return indexedDB;
+}
+function createStorageTestScenario(storageType = "local") {
+  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;
+    }
+  };
+}
+
+// src/setup/audio.ts
+function createMockAudioContext() {
+  return {
+    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, length, sampleRate) => ({
+      duration: length / sampleRate,
+      length,
+      sampleRate,
+      numberOfChannels: channels,
+      getChannelData: () => new Float32Array(length)
+    })
+  };
+}
+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;
+  }
+}
+function teardownMockAudioContext() {
+  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
+    delete global.AudioContext;
+    delete global.window.AudioContext;
+    delete global.window.webkitAudioContext;
+  }
+}
+function captureAudioEvents(context) {
+  return [];
+}
+
+// src/e2e/playwright.ts
+var import_playwright = require("playwright");
+async function createPlaywrightTestClient(options = {}) {
+  const browser = await import_playwright.chromium.launch({
+    headless: options.headless ?? true,
+    args: options.args || [
+      "--use-gl=egl",
+      "--ignore-gpu-blocklist",
+      "--no-sandbox",
+      "--disable-setuid-sandbox"
+    ]
+  });
+  const context = await browser.newContext({
+    viewport: options.viewport || { width: 1280, height: 720 },
+    recordVideo: options.recordVideo,
+    deviceScaleFactor: 1
+  });
+  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 client = {
+    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();
+    }
+  };
+  return client;
+}
+async function waitForGameReady(page, timeout = 1e4) {
+  await page.waitForFunction(() => {
+    return window.game || document.querySelector("canvas");
+  }, null, { 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
+      });
+    }
+  };
+}
+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
+var import_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+async function captureGameScreenshot(page, name, options = {}) {
+  const dir = options.dir || "__screenshots__";
+  const screenshotPath = import_path.default.join(dir, `${name}.png`);
+  await import_promises.default.mkdir(dir, { recursive: true });
+  return await page.screenshot({
+    path: screenshotPath,
+    fullPage: options.fullPage ?? false,
+    animations: "disabled",
+    // Try to freeze animations if possible
+    caret: "hide"
+  });
+}
+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 = import_path.default.join(baselineDir, `${name}.png`);
+        const baseline = await import_promises.default.readFile(baselinePath);
+        return await compareScreenshots(baseline, current);
+      } catch (e) {
+        return { pixelDiff: -1, matched: false };
+      }
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InputInjector,
   MockPointerLock,
+  captureAudioEvents,
+  captureCanvasDrawCalls,
+  captureGameScreenshot,
+  captureGameState,
+  compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
+  createCustomNetworkCondition,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
+  createMockAudioContext,
+  createMockCanvas,
+  createMockCanvasContext2D,
   createMockEngine,
   createMockGame,
+  createMockImage,
+  createMockImageData,
+  createMockIndexedDB,
+  createMockLocalStorage,
+  createMockPerformance,
+  createMockRAF,
+  createMockSessionStorage,
   createMockWebGL2Context,
   createNetChanMock,
   createPlayerStateFactory,
+  createPlaywrightTestClient,
   createSpawnContext,
+  createStorageTestScenario,
   createTestContext,
+  createVisualTestScenario,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -804,8 +1411,15 @@ var InputInjector = class {
   makeNode,
   makePlane,
   setupBrowserEnvironment,
+  setupMockAudioContext,
   setupNodeEnvironment,
+  simulateFrames,
+  simulateFramesWithMock,
+  simulateNetworkCondition,
   stairTrace,
-  teardownBrowserEnvironment
+  teardownBrowserEnvironment,
+  teardownMockAudioContext,
+  throttleBandwidth,
+  waitForGameReady
 });
 //# sourceMappingURL=index.cjs.map