npm - quake2ts - Versions diffs - 0.0.553 → 0.0.557 - Mend

quake2ts 0.0.553 → 0.0.557

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/package.json +1 -1
package/packages/client/dist/browser/index.global.js +17 -17
package/packages/client/dist/browser/index.global.js.map +1 -1
package/packages/client/dist/cjs/index.cjs +4607 -2885
package/packages/client/dist/cjs/index.cjs.map +1 -1
package/packages/client/dist/esm/index.js +4607 -2885
package/packages/client/dist/esm/index.js.map +1 -1
package/packages/engine/dist/cjs/index.cjs +2256 -534
package/packages/engine/dist/cjs/index.cjs.map +1 -1
package/packages/engine/dist/esm/index.js +2266 -538
package/packages/engine/dist/esm/index.js.map +1 -1
package/packages/engine/dist/tsconfig.tsbuildinfo +1 -1
package/packages/engine/dist/types/assets/visibilityAnalyzer.d.ts +7 -2
package/packages/engine/dist/types/assets/visibilityAnalyzer.d.ts.map +1 -1
package/packages/game/dist/tsconfig.tsbuildinfo +1 -1
package/packages/game/dist/types/entities/target/speaker.d.ts.map +1 -1
package/packages/test-utils/dist/index.cjs +808 -194
package/packages/test-utils/dist/index.cjs.map +1 -1
package/packages/test-utils/dist/index.d.cts +220 -1
package/packages/test-utils/dist/index.d.ts +220 -1
package/packages/test-utils/dist/index.js +771 -193
package/packages/test-utils/dist/index.js.map +1 -1

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

@@ -395,123 +395,99 @@ function createEntity() {
 import { JSDOM } from "jsdom";
 import { Canvas, Image, ImageData } from "@napi-rs/canvas";
 import "fake-indexeddb/auto";
-function setupBrowserEnvironment(options = {}) {
-  const { url = "http://localhost", pretendToBeVisual = true } = options;
-  const dom = new 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 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 = Image;
-  global.ImageData = 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 Canvas(image.width, image.height);
-        const ctx = canvas2.getContext("2d");
-        if (image.data) {
-          ctx.putImageData(image, 0, 0);
-        }
-        return canvas2;
-      }
-      const canvas = new 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) {
@@ -637,113 +613,708 @@ 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 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 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 = Image;
+  global.ImageData = 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 Canvas(image.width, image.height);
+        const ctx = canvas2.getContext("2d");
+        if (image.data) {
+          ctx.putImageData(image, 0, 0);
+        }
+        return canvas2;
+      }
+      const canvas = new 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
+import { Canvas as Canvas2, Image as Image2, ImageData as ImageData2 } from "@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 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);
+  };
+  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 ImageData2(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 Image2();
+  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
+import "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
+import { chromium } from "playwright";
+async function createPlaywrightTestClient(options = {}) {
+  const browser = await 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
+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"
+  });
+}
+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,
+  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,
@@ -754,8 +1325,15 @@ export {
   makeNode,
   makePlane,
   setupBrowserEnvironment,
+  setupMockAudioContext,
   setupNodeEnvironment,
+  simulateFrames,
+  simulateFramesWithMock,
+  simulateNetworkCondition,
   stairTrace,
-  teardownBrowserEnvironment
+  teardownBrowserEnvironment,
+  teardownMockAudioContext,
+  throttleBandwidth,
+  waitForGameReady
 };
 //# sourceMappingURL=index.js.map