quake2ts 0.0.557 → 0.0.561

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

@@ -34,12 +34,10 @@ __export(index_exports, {
   MockPointerLock: () => MockPointerLock,
   captureAudioEvents: () => captureAudioEvents,
   captureCanvasDrawCalls: () => captureCanvasDrawCalls,
-  captureGameScreenshot: () => captureGameScreenshot,
   captureGameState: () => captureGameState,
-  compareScreenshots: () => compareScreenshots,
   createBinaryStreamMock: () => createBinaryStreamMock,
   createBinaryWriterMock: () => createBinaryWriterMock,
-  createCustomNetworkCondition: () => createCustomNetworkCondition,
+  createControlledTimer: () => createControlledTimer,
   createEntity: () => createEntity,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
@@ -62,7 +60,6 @@ __export(index_exports, {
   createSpawnContext: () => createSpawnContext,
   createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
-  createVisualTestScenario: () => createVisualTestScenario,
   intersects: () => import_shared3.intersects,
   ladderTrace: () => import_shared3.ladderTrace,
   makeAxisBrush: () => makeAxisBrush,
@@ -77,405 +74,13 @@ __export(index_exports, {
   setupNodeEnvironment: () => setupNodeEnvironment,
   simulateFrames: () => simulateFrames,
   simulateFramesWithMock: () => simulateFramesWithMock,
-  simulateNetworkCondition: () => simulateNetworkCondition,
   stairTrace: () => import_shared3.stairTrace,
   teardownBrowserEnvironment: () => teardownBrowserEnvironment,
   teardownMockAudioContext: () => teardownMockAudioContext,
-  throttleBandwidth: () => throttleBandwidth,
   waitForGameReady: () => waitForGameReady
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/shared/mocks.ts
-var import_vitest = require("vitest");
-var createBinaryWriterMock = () => ({
-  writeByte: import_vitest.vi.fn(),
-  writeShort: import_vitest.vi.fn(),
-  writeLong: import_vitest.vi.fn(),
-  writeString: import_vitest.vi.fn(),
-  writeBytes: import_vitest.vi.fn(),
-  getBuffer: import_vitest.vi.fn(() => new Uint8Array(0)),
-  reset: import_vitest.vi.fn(),
-  // Legacy methods (if any)
-  writeInt8: import_vitest.vi.fn(),
-  writeUint8: import_vitest.vi.fn(),
-  writeInt16: import_vitest.vi.fn(),
-  writeUint16: import_vitest.vi.fn(),
-  writeInt32: import_vitest.vi.fn(),
-  writeUint32: import_vitest.vi.fn(),
-  writeFloat: import_vitest.vi.fn(),
-  getData: import_vitest.vi.fn(() => new Uint8Array(0))
-});
-var createNetChanMock = () => ({
-  qport: 1234,
-  // Sequencing
-  incomingSequence: 0,
-  outgoingSequence: 0,
-  incomingAcknowledged: 0,
-  // Reliable messaging
-  incomingReliableAcknowledged: false,
-  incomingReliableSequence: 0,
-  outgoingReliableSequence: 0,
-  reliableMessage: createBinaryWriterMock(),
-  reliableLength: 0,
-  // Fragmentation
-  fragmentSendOffset: 0,
-  fragmentBuffer: null,
-  fragmentLength: 0,
-  fragmentReceived: 0,
-  // Timing
-  lastReceived: 0,
-  lastSent: 0,
-  remoteAddress: { type: "IP", port: 1234 },
-  // Methods
-  setup: import_vitest.vi.fn(),
-  reset: import_vitest.vi.fn(),
-  transmit: import_vitest.vi.fn(),
-  process: import_vitest.vi.fn(),
-  canSendReliable: import_vitest.vi.fn(() => true),
-  writeReliableByte: import_vitest.vi.fn(),
-  writeReliableShort: import_vitest.vi.fn(),
-  writeReliableLong: import_vitest.vi.fn(),
-  writeReliableString: import_vitest.vi.fn(),
-  getReliableData: import_vitest.vi.fn(() => new Uint8Array(0)),
-  needsKeepalive: import_vitest.vi.fn(() => false),
-  isTimedOut: import_vitest.vi.fn(() => false)
-});
-var createBinaryStreamMock = () => ({
-  getPosition: import_vitest.vi.fn(() => 0),
-  getReadPosition: import_vitest.vi.fn(() => 0),
-  getLength: import_vitest.vi.fn(() => 0),
-  getRemaining: import_vitest.vi.fn(() => 0),
-  seek: import_vitest.vi.fn(),
-  setReadPosition: import_vitest.vi.fn(),
-  hasMore: import_vitest.vi.fn(() => true),
-  hasBytes: import_vitest.vi.fn((amount) => true),
-  readChar: import_vitest.vi.fn(() => 0),
-  readByte: import_vitest.vi.fn(() => 0),
-  readShort: import_vitest.vi.fn(() => 0),
-  readUShort: import_vitest.vi.fn(() => 0),
-  readLong: import_vitest.vi.fn(() => 0),
-  readULong: import_vitest.vi.fn(() => 0),
-  readFloat: import_vitest.vi.fn(() => 0),
-  readString: import_vitest.vi.fn(() => ""),
-  readStringLine: import_vitest.vi.fn(() => ""),
-  readCoord: import_vitest.vi.fn(() => 0),
-  readAngle: import_vitest.vi.fn(() => 0),
-  readAngle16: import_vitest.vi.fn(() => 0),
-  readData: import_vitest.vi.fn((length) => new Uint8Array(length)),
-  readPos: import_vitest.vi.fn(),
-  readDir: import_vitest.vi.fn()
-});
-
-// src/shared/bsp.ts
-var import_shared = require("@quake2ts/shared");
-function makePlane(normal, dist) {
-  return {
-    normal,
-    dist,
-    type: Math.abs(normal.x) === 1 ? 0 : Math.abs(normal.y) === 1 ? 1 : Math.abs(normal.z) === 1 ? 2 : 3,
-    signbits: (0, import_shared.computePlaneSignBits)(normal)
-  };
-}
-function makeAxisBrush(size, contents = import_shared.CONTENTS_SOLID) {
-  const half = size / 2;
-  const planes = [
-    makePlane({ x: 1, y: 0, z: 0 }, half),
-    makePlane({ x: -1, y: 0, z: 0 }, half),
-    makePlane({ x: 0, y: 1, z: 0 }, half),
-    makePlane({ x: 0, y: -1, z: 0 }, half),
-    makePlane({ x: 0, y: 0, z: 1 }, half),
-    makePlane({ x: 0, y: 0, z: -1 }, half)
-  ];
-  return {
-    contents,
-    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
-  };
-}
-function makeNode(plane, children) {
-  return { plane, children };
-}
-function makeBspModel(planes, nodes, leaves, brushes, leafBrushes) {
-  return {
-    planes,
-    nodes,
-    leaves,
-    brushes,
-    leafBrushes,
-    bmodels: []
-  };
-}
-function makeLeaf(contents, firstLeafBrush, numLeafBrushes) {
-  return { contents, cluster: 0, area: 0, firstLeafBrush, numLeafBrushes };
-}
-function makeLeafModel(brushes) {
-  const planes = brushes.flatMap((brush) => brush.sides.map((side) => side.plane));
-  return {
-    planes,
-    nodes: [],
-    leaves: [makeLeaf(0, 0, brushes.length)],
-    brushes,
-    leafBrushes: brushes.map((_, i) => i),
-    bmodels: []
-  };
-}
-function makeBrushFromMinsMaxs(mins, maxs, contents = import_shared.CONTENTS_SOLID) {
-  const planes = [
-    makePlane({ x: 1, y: 0, z: 0 }, maxs.x),
-    makePlane({ x: -1, y: 0, z: 0 }, -mins.x),
-    makePlane({ x: 0, y: 1, z: 0 }, maxs.y),
-    makePlane({ x: 0, y: -1, z: 0 }, -mins.y),
-    makePlane({ x: 0, y: 0, z: 1 }, maxs.z),
-    makePlane({ x: 0, y: 0, z: -1 }, -mins.z)
-  ];
-  return {
-    contents,
-    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
-  };
-}
-
-// src/game/factories.ts
-var createPlayerStateFactory = (overrides) => ({
-  pm_type: 0,
-  pm_time: 0,
-  pm_flags: 0,
-  origin: { x: 0, y: 0, z: 0 },
-  velocity: { x: 0, y: 0, z: 0 },
-  viewAngles: { x: 0, y: 0, z: 0 },
-  onGround: false,
-  waterLevel: 0,
-  watertype: 0,
-  mins: { x: 0, y: 0, z: 0 },
-  maxs: { x: 0, y: 0, z: 0 },
-  damageAlpha: 0,
-  damageIndicators: [],
-  blend: [0, 0, 0, 0],
-  stats: [],
-  kick_angles: { x: 0, y: 0, z: 0 },
-  kick_origin: { x: 0, y: 0, z: 0 },
-  gunoffset: { x: 0, y: 0, z: 0 },
-  gunangles: { x: 0, y: 0, z: 0 },
-  gunindex: 0,
-  gun_frame: 0,
-  rdflags: 0,
-  fov: 90,
-  renderfx: 0,
-  ...overrides
-});
-var createEntityStateFactory = (overrides) => ({
-  number: 0,
-  origin: { x: 0, y: 0, z: 0 },
-  angles: { x: 0, y: 0, z: 0 },
-  oldOrigin: { x: 0, y: 0, z: 0 },
-  modelIndex: 0,
-  modelIndex2: 0,
-  modelIndex3: 0,
-  modelIndex4: 0,
-  frame: 0,
-  skinNum: 0,
-  effects: 0,
-  renderfx: 0,
-  solid: 0,
-  sound: 0,
-  event: 0,
-  ...overrides
-});
-var createGameStateSnapshotFactory = (overrides) => ({
-  gravity: { x: 0, y: 0, z: -800 },
-  origin: { x: 0, y: 0, z: 0 },
-  velocity: { x: 0, y: 0, z: 0 },
-  viewangles: { x: 0, y: 0, z: 0 },
-  level: { timeSeconds: 0, frameNumber: 0, previousTimeSeconds: 0, deltaSeconds: 0.1 },
-  entities: {
-    activeCount: 0,
-    worldClassname: "worldspawn"
-  },
-  packetEntities: [],
-  pmFlags: 0,
-  pmType: 0,
-  waterlevel: 0,
-  watertype: 0,
-  deltaAngles: { x: 0, y: 0, z: 0 },
-  health: 100,
-  armor: 0,
-  ammo: 0,
-  blend: [0, 0, 0, 0],
-  damageAlpha: 0,
-  damageIndicators: [],
-  stats: [],
-  kick_angles: { x: 0, y: 0, z: 0 },
-  kick_origin: { x: 0, y: 0, z: 0 },
-  gunoffset: { x: 0, y: 0, z: 0 },
-  gunangles: { x: 0, y: 0, z: 0 },
-  gunindex: 0,
-  pm_time: 0,
-  gun_frame: 0,
-  rdflags: 0,
-  fov: 90,
-  renderfx: 0,
-  pm_flags: 0,
-  pm_type: 0,
-  ...overrides
-});
-
-// src/game/helpers.ts
-var import_vitest2 = require("vitest");
-var import_game = require("@quake2ts/game");
-var import_shared2 = require("@quake2ts/shared");
-var import_shared3 = require("@quake2ts/shared");
-var createMockEngine = () => ({
-  sound: import_vitest2.vi.fn(),
-  soundIndex: import_vitest2.vi.fn((sound) => 0),
-  modelIndex: import_vitest2.vi.fn((model) => 0),
-  centerprintf: import_vitest2.vi.fn()
-});
-var createMockGame = (seed = 12345) => {
-  const spawnRegistry = new import_game.SpawnRegistry();
-  const hooks = new import_game.ScriptHookRegistry();
-  const game = {
-    random: (0, import_shared2.createRandomGenerator)({ seed }),
-    registerEntitySpawn: import_vitest2.vi.fn((classname, spawnFunc) => {
-      spawnRegistry.register(classname, (entity) => spawnFunc(entity));
-    }),
-    unregisterEntitySpawn: import_vitest2.vi.fn((classname) => {
-      spawnRegistry.unregister(classname);
-    }),
-    getCustomEntities: import_vitest2.vi.fn(() => Array.from(spawnRegistry.keys())),
-    hooks,
-    registerHooks: import_vitest2.vi.fn((newHooks) => hooks.register(newHooks)),
-    spawnWorld: import_vitest2.vi.fn(() => {
-      hooks.onMapLoad("q2dm1");
-    }),
-    clientBegin: import_vitest2.vi.fn((client) => {
-      hooks.onPlayerSpawn({});
-    }),
-    damage: import_vitest2.vi.fn((amount) => {
-      hooks.onDamage({}, null, null, amount, 0, 0);
-    })
-  };
-  return { game, spawnRegistry };
-};
-function createTestContext(options) {
-  const engine = createMockEngine();
-  const seed = options?.seed ?? 12345;
-  const { game, spawnRegistry } = createMockGame(seed);
-  const traceFn = import_vitest2.vi.fn((start, end, mins, maxs) => ({
-    fraction: 1,
-    ent: null,
-    allsolid: false,
-    startsolid: false,
-    endpos: end,
-    plane: { normal: { x: 0, y: 0, z: 1 }, dist: 0 },
-    surfaceFlags: 0,
-    contents: 0
-  }));
-  const entityList = options?.initialEntities ? [...options.initialEntities] : [];
-  const hooks = game.hooks;
-  const entities = {
-    spawn: import_vitest2.vi.fn(() => {
-      const ent = new import_game.Entity(entityList.length + 1);
-      entityList.push(ent);
-      hooks.onEntitySpawn(ent);
-      return ent;
-    }),
-    free: import_vitest2.vi.fn((ent) => {
-      const idx = entityList.indexOf(ent);
-      if (idx !== -1) {
-        entityList.splice(idx, 1);
-      }
-      hooks.onEntityRemove(ent);
-    }),
-    finalizeSpawn: import_vitest2.vi.fn(),
-    freeImmediate: import_vitest2.vi.fn((ent) => {
-      const idx = entityList.indexOf(ent);
-      if (idx !== -1) {
-        entityList.splice(idx, 1);
-      }
-    }),
-    setSpawnRegistry: import_vitest2.vi.fn(),
-    timeSeconds: 10,
-    deltaSeconds: 0.1,
-    modelIndex: import_vitest2.vi.fn(() => 0),
-    scheduleThink: import_vitest2.vi.fn((entity, time) => {
-      entity.nextthink = time;
-    }),
-    linkentity: import_vitest2.vi.fn(),
-    trace: traceFn,
-    pointcontents: import_vitest2.vi.fn(() => 0),
-    multicast: import_vitest2.vi.fn(),
-    unicast: import_vitest2.vi.fn(),
-    engine,
-    game,
-    sound: import_vitest2.vi.fn((ent, chan, sound, vol, attn, timeofs) => {
-      engine.sound(ent, chan, sound, vol, attn, timeofs);
-    }),
-    soundIndex: import_vitest2.vi.fn((sound) => engine.soundIndex(sound)),
-    useTargets: import_vitest2.vi.fn((entity, activator) => {
-    }),
-    findByTargetName: import_vitest2.vi.fn(() => []),
-    pickTarget: import_vitest2.vi.fn(() => null),
-    killBox: import_vitest2.vi.fn(),
-    rng: (0, import_shared2.createRandomGenerator)({ seed }),
-    imports: {
-      configstring: import_vitest2.vi.fn(),
-      trace: traceFn,
-      pointcontents: import_vitest2.vi.fn(() => 0)
-    },
-    level: {
-      intermission_angle: { x: 0, y: 0, z: 0 },
-      intermission_origin: { x: 0, y: 0, z: 0 },
-      next_auto_save: 0,
-      health_bar_entities: null
-    },
-    targetNameIndex: /* @__PURE__ */ new Map(),
-    forEachEntity: import_vitest2.vi.fn((callback) => {
-      entityList.forEach(callback);
-    }),
-    find: import_vitest2.vi.fn((predicate) => {
-      return entityList.find(predicate);
-    }),
-    findByClassname: import_vitest2.vi.fn((classname) => {
-      return entityList.find((e) => e.classname === classname);
-    }),
-    beginFrame: import_vitest2.vi.fn((timeSeconds) => {
-      entities.timeSeconds = timeSeconds;
-    }),
-    targetAwareness: {
-      timeSeconds: 10,
-      frameNumber: 1,
-      sightEntity: null,
-      soundEntity: null
-    },
-    // Adding missing properties to satisfy EntitySystem interface partially or fully
-    // We cast to unknown first anyway, but filling these in makes it safer for consumers
-    skill: 1,
-    deathmatch: false,
-    coop: false,
-    activeCount: entityList.length,
-    world: entityList.find((e) => e.classname === "worldspawn") || new import_game.Entity(0)
-    // ... other EntitySystem properties would go here
-  };
-  return {
-    keyValues: {},
-    entities,
-    game,
-    engine,
-    health_multiplier: 1,
-    warn: import_vitest2.vi.fn(),
-    free: import_vitest2.vi.fn(),
-    // Mock precache functions if they are part of SpawnContext in future or TestContext extensions
-    precacheModel: import_vitest2.vi.fn(),
-    precacheSound: import_vitest2.vi.fn(),
-    precacheImage: import_vitest2.vi.fn()
-  };
-}
-function createSpawnContext() {
-  return createTestContext();
-}
-function createEntity() {
-  return new import_game.Entity(1);
-}
-
 // src/setup/browser.ts
 var import_jsdom = require("jsdom");
 var import_canvas = require("@napi-rs/canvas");
@@ -871,12 +476,6 @@ function teardownBrowserEnvironment() {
   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) {
@@ -958,7 +557,127 @@ function createMockImage(width, height, src) {
   return img;
 }
 
+// src/setup/node.ts
+function setupNodeEnvironment() {
+  if (typeof global.fetch === "undefined") {
+  }
+}
+
+// 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/setup/timing.ts
+var activeMockRAF;
 function createMockRAF() {
   let callbacks = [];
   let nextId = 1;
@@ -998,10 +717,14 @@ function createMockRAF() {
       currentTime = 0;
     },
     enable() {
+      activeMockRAF = this;
       global.requestAnimationFrame = raf;
       global.cancelAnimationFrame = cancel;
     },
     disable() {
+      if (activeMockRAF === this) {
+        activeMockRAF = void 0;
+      }
       if (originalRAF) {
         global.requestAnimationFrame = originalRAF;
       } else {
@@ -1024,7 +747,6 @@ function createMockPerformance(startTime = 0) {
     timing: {
       navigationStart: startTime
     },
-    // Add minimal navigation/resource timing interfaces to satisfy types if needed
     clearMarks: () => {
     },
     clearMeasures: () => {
@@ -1053,318 +775,585 @@ function createMockPerformance(startTime = 0) {
   mockPerf.setTime = (time) => {
     currentTime = time;
   };
-  return mockPerf;
+  return mockPerf;
+}
+function createControlledTimer() {
+  let currentTime = 0;
+  let timers = [];
+  let nextId = 1;
+  const originalSetTimeout = global.setTimeout;
+  const originalClearTimeout = global.clearTimeout;
+  const originalSetInterval = global.setInterval;
+  const originalClearInterval = global.clearInterval;
+  const mockSetTimeout = (callback, delay = 0, ...args) => {
+    const id = nextId++;
+    timers.push({ id, callback, dueTime: currentTime + delay, args });
+    return id;
+  };
+  const mockClearTimeout = (id) => {
+    timers = timers.filter((t) => t.id !== id);
+  };
+  const mockSetInterval = (callback, delay = 0, ...args) => {
+    const id = nextId++;
+    timers.push({ id, callback, dueTime: currentTime + delay, interval: delay, args });
+    return id;
+  };
+  const mockClearInterval = (id) => {
+    timers = timers.filter((t) => t.id !== id);
+  };
+  global.setTimeout = mockSetTimeout;
+  global.clearTimeout = mockClearTimeout;
+  global.setInterval = mockSetInterval;
+  global.clearInterval = mockClearInterval;
+  return {
+    tick() {
+      this.advanceBy(0);
+    },
+    advanceBy(ms) {
+      const targetTime = currentTime + ms;
+      while (true) {
+        let earliest = null;
+        for (const t of timers) {
+          if (!earliest || t.dueTime < earliest.dueTime) {
+            earliest = t;
+          }
+        }
+        if (!earliest || earliest.dueTime > targetTime) {
+          break;
+        }
+        currentTime = earliest.dueTime;
+        const { callback, args, interval, id } = earliest;
+        if (interval !== void 0) {
+          earliest.dueTime += interval;
+          if (interval === 0) earliest.dueTime += 1;
+        } else {
+          timers = timers.filter((t) => t.id !== id);
+        }
+        callback(...args);
+      }
+      currentTime = targetTime;
+    },
+    clear() {
+      timers = [];
+    },
+    restore() {
+      global.setTimeout = originalSetTimeout;
+      global.clearTimeout = originalClearTimeout;
+      global.setInterval = originalSetInterval;
+      global.clearInterval = originalClearInterval;
+    }
+  };
+}
+function simulateFrames(count, frameTimeMs = 16.6, callback) {
+  if (!activeMockRAF) {
+    throw new Error("simulateFrames requires an active MockRAF. Ensure createMockRAF().enable() is called.");
+  }
+  for (let i = 0; i < count; i++) {
+    if (callback) callback(i);
+    activeMockRAF.advance(frameTimeMs);
+  }
+}
+function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
+  for (let i = 0; i < count; i++) {
+    if (callback) callback(i);
+    mock.advance(frameTimeMs);
+  }
+}
+
+// src/e2e/playwright.ts
+var import_playwright = require("playwright");
+var import_http = require("http");
+var import_serve_handler = __toESM(require("serve-handler"), 1);
+async function createPlaywrightTestClient(options = {}) {
+  let staticServer;
+  let clientUrl = options.clientUrl;
+  const rootPath = options.rootPath || process.cwd();
+  if (!clientUrl) {
+    staticServer = (0, import_http.createServer)((request, response) => {
+      return (0, import_serve_handler.default)(request, response, {
+        public: rootPath,
+        cleanUrls: false,
+        headers: [
+          {
+            source: "**/*",
+            headers: [
+              { key: "Cache-Control", value: "no-cache" },
+              { key: "Access-Control-Allow-Origin", value: "*" },
+              { key: "Cross-Origin-Opener-Policy", value: "same-origin" },
+              { key: "Cross-Origin-Embedder-Policy", value: "require-corp" }
+            ]
+          }
+        ]
+      });
+    });
+    await new Promise((resolve) => {
+      if (!staticServer) return;
+      staticServer.listen(0, () => {
+        const addr = staticServer?.address();
+        const port = typeof addr === "object" ? addr?.port : 0;
+        clientUrl = `http://localhost:${port}`;
+        console.log(`Test client serving from ${rootPath} at ${clientUrl}`);
+        resolve();
+      });
+    });
+  }
+  const browser = await import_playwright.chromium.launch({
+    headless: options.headless ?? true,
+    args: [
+      "--use-gl=egl",
+      "--ignore-gpu-blocklist",
+      ...options.launchOptions?.args || []
+    ],
+    ...options.launchOptions
+  });
+  const width = options.width || 1280;
+  const height = options.height || 720;
+  const context = await browser.newContext({
+    viewport: { width, height },
+    deviceScaleFactor: 1,
+    ...options.contextOptions
+  });
+  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);
+    },
+    injectInput: async (type, data) => {
+      await page.evaluate(({ type: type2, data: data2 }) => {
+        if (window.injectGameInput) window.injectGameInput(type2, data2);
+      }, { type, data });
+    }
+  };
+}
+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 });
+  }
+}
+async function captureGameState(page) {
+  return await page.evaluate(() => {
+    if (window.gameInstance && window.gameInstance.getState) {
+      return window.gameInstance.getState();
+    }
+    return {};
+  });
+}
+
+// src/shared/bsp.ts
+var import_shared = require("@quake2ts/shared");
+function makePlane(normal, dist) {
+  return {
+    normal,
+    dist,
+    type: Math.abs(normal.x) === 1 ? 0 : Math.abs(normal.y) === 1 ? 1 : Math.abs(normal.z) === 1 ? 2 : 3,
+    signbits: (0, import_shared.computePlaneSignBits)(normal)
+  };
 }
-function simulateFrames(count, frameTimeMs = 16.6, callback) {
-  const raf = global.requestAnimationFrame;
-  if (!raf) return;
+function makeAxisBrush(size, contents = import_shared.CONTENTS_SOLID) {
+  const half = size / 2;
+  const planes = [
+    makePlane({ x: 1, y: 0, z: 0 }, half),
+    makePlane({ x: -1, y: 0, z: 0 }, half),
+    makePlane({ x: 0, y: 1, z: 0 }, half),
+    makePlane({ x: 0, y: -1, z: 0 }, half),
+    makePlane({ x: 0, y: 0, z: 1 }, half),
+    makePlane({ x: 0, y: 0, z: -1 }, half)
+  ];
+  return {
+    contents,
+    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
+  };
 }
-function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
-  for (let i = 0; i < count; i++) {
-    if (callback) callback(i);
-    mock.advance(frameTimeMs);
-  }
+function makeNode(plane, children) {
+  return { plane, children };
 }
-
-// src/setup/storage.ts
-var import_auto2 = require("fake-indexeddb/auto");
-function createMockLocalStorage(initialData = {}) {
-  const storage = new Map(Object.entries(initialData));
+function makeBspModel(planes, nodes, leaves, brushes, leafBrushes) {
   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;
-    }
+    planes,
+    nodes,
+    leaves,
+    brushes,
+    leafBrushes,
+    bmodels: []
   };
 }
-function createMockSessionStorage(initialData = {}) {
-  return createMockLocalStorage(initialData);
+function makeLeaf(contents, firstLeafBrush, numLeafBrushes) {
+  return { contents, cluster: 0, area: 0, firstLeafBrush, numLeafBrushes };
 }
-function createMockIndexedDB() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
-  }
-  return indexedDB;
+function makeLeafModel(brushes) {
+  const planes = brushes.flatMap((brush) => brush.sides.map((side) => side.plane));
+  return {
+    planes,
+    nodes: [],
+    leaves: [makeLeaf(0, 0, brushes.length)],
+    brushes,
+    leafBrushes: brushes.map((_, i) => i),
+    bmodels: []
+  };
 }
-function createStorageTestScenario(storageType = "local") {
-  const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
+function makeBrushFromMinsMaxs(mins, maxs, contents = import_shared.CONTENTS_SOLID) {
+  const planes = [
+    makePlane({ x: 1, y: 0, z: 0 }, maxs.x),
+    makePlane({ x: -1, y: 0, z: 0 }, -mins.x),
+    makePlane({ x: 0, y: 1, z: 0 }, maxs.y),
+    makePlane({ x: 0, y: -1, z: 0 }, -mins.y),
+    makePlane({ x: 0, y: 0, z: 1 }, maxs.z),
+    makePlane({ x: 0, y: 0, z: -1 }, -mins.z)
+  ];
   return {
-    storage,
-    populate(data) {
-      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
-    },
-    verify(key, value) {
-      return storage.getItem(key) === value;
-    }
+    contents,
+    sides: planes.map((plane) => ({ plane, surfaceFlags: 0 }))
   };
 }
 
-// src/setup/audio.ts
-function createMockAudioContext() {
-  return {
-    createGain: () => ({
-      connect: () => {
-      },
-      gain: { value: 1, setValueAtTime: () => {
-      } }
+// src/shared/mocks.ts
+var import_vitest = require("vitest");
+var createBinaryWriterMock = () => ({
+  writeByte: import_vitest.vi.fn(),
+  writeShort: import_vitest.vi.fn(),
+  writeLong: import_vitest.vi.fn(),
+  writeString: import_vitest.vi.fn(),
+  writeBytes: import_vitest.vi.fn(),
+  getBuffer: import_vitest.vi.fn(() => new Uint8Array(0)),
+  reset: import_vitest.vi.fn(),
+  // Legacy methods (if any)
+  writeInt8: import_vitest.vi.fn(),
+  writeUint8: import_vitest.vi.fn(),
+  writeInt16: import_vitest.vi.fn(),
+  writeUint16: import_vitest.vi.fn(),
+  writeInt32: import_vitest.vi.fn(),
+  writeUint32: import_vitest.vi.fn(),
+  writeFloat: import_vitest.vi.fn(),
+  getData: import_vitest.vi.fn(() => new Uint8Array(0))
+});
+var createNetChanMock = () => ({
+  qport: 1234,
+  // Sequencing
+  incomingSequence: 0,
+  outgoingSequence: 0,
+  incomingAcknowledged: 0,
+  // Reliable messaging
+  incomingReliableAcknowledged: false,
+  incomingReliableSequence: 0,
+  outgoingReliableSequence: 0,
+  reliableMessage: createBinaryWriterMock(),
+  reliableLength: 0,
+  // Fragmentation
+  fragmentSendOffset: 0,
+  fragmentBuffer: null,
+  fragmentLength: 0,
+  fragmentReceived: 0,
+  // Timing
+  lastReceived: 0,
+  lastSent: 0,
+  remoteAddress: { type: "IP", port: 1234 },
+  // Methods
+  setup: import_vitest.vi.fn(),
+  reset: import_vitest.vi.fn(),
+  transmit: import_vitest.vi.fn(),
+  process: import_vitest.vi.fn(),
+  canSendReliable: import_vitest.vi.fn(() => true),
+  writeReliableByte: import_vitest.vi.fn(),
+  writeReliableShort: import_vitest.vi.fn(),
+  writeReliableLong: import_vitest.vi.fn(),
+  writeReliableString: import_vitest.vi.fn(),
+  getReliableData: import_vitest.vi.fn(() => new Uint8Array(0)),
+  needsKeepalive: import_vitest.vi.fn(() => false),
+  isTimedOut: import_vitest.vi.fn(() => false)
+});
+var createBinaryStreamMock = () => ({
+  getPosition: import_vitest.vi.fn(() => 0),
+  getReadPosition: import_vitest.vi.fn(() => 0),
+  getLength: import_vitest.vi.fn(() => 0),
+  getRemaining: import_vitest.vi.fn(() => 0),
+  seek: import_vitest.vi.fn(),
+  setReadPosition: import_vitest.vi.fn(),
+  hasMore: import_vitest.vi.fn(() => true),
+  hasBytes: import_vitest.vi.fn((amount) => true),
+  readChar: import_vitest.vi.fn(() => 0),
+  readByte: import_vitest.vi.fn(() => 0),
+  readShort: import_vitest.vi.fn(() => 0),
+  readUShort: import_vitest.vi.fn(() => 0),
+  readLong: import_vitest.vi.fn(() => 0),
+  readULong: import_vitest.vi.fn(() => 0),
+  readFloat: import_vitest.vi.fn(() => 0),
+  readString: import_vitest.vi.fn(() => ""),
+  readStringLine: import_vitest.vi.fn(() => ""),
+  readCoord: import_vitest.vi.fn(() => 0),
+  readAngle: import_vitest.vi.fn(() => 0),
+  readAngle16: import_vitest.vi.fn(() => 0),
+  readData: import_vitest.vi.fn((length) => new Uint8Array(length)),
+  readPos: import_vitest.vi.fn(),
+  readDir: import_vitest.vi.fn()
+});
+
+// src/game/factories.ts
+var createPlayerStateFactory = (overrides) => ({
+  pm_type: 0,
+  pm_time: 0,
+  pm_flags: 0,
+  origin: { x: 0, y: 0, z: 0 },
+  velocity: { x: 0, y: 0, z: 0 },
+  viewAngles: { x: 0, y: 0, z: 0 },
+  onGround: false,
+  waterLevel: 0,
+  watertype: 0,
+  mins: { x: 0, y: 0, z: 0 },
+  maxs: { x: 0, y: 0, z: 0 },
+  damageAlpha: 0,
+  damageIndicators: [],
+  blend: [0, 0, 0, 0],
+  stats: [],
+  kick_angles: { x: 0, y: 0, z: 0 },
+  kick_origin: { x: 0, y: 0, z: 0 },
+  gunoffset: { x: 0, y: 0, z: 0 },
+  gunangles: { x: 0, y: 0, z: 0 },
+  gunindex: 0,
+  gun_frame: 0,
+  rdflags: 0,
+  fov: 90,
+  renderfx: 0,
+  ...overrides
+});
+var createEntityStateFactory = (overrides) => ({
+  number: 0,
+  origin: { x: 0, y: 0, z: 0 },
+  angles: { x: 0, y: 0, z: 0 },
+  oldOrigin: { x: 0, y: 0, z: 0 },
+  modelIndex: 0,
+  modelIndex2: 0,
+  modelIndex3: 0,
+  modelIndex4: 0,
+  frame: 0,
+  skinNum: 0,
+  effects: 0,
+  renderfx: 0,
+  solid: 0,
+  sound: 0,
+  event: 0,
+  ...overrides
+});
+var createGameStateSnapshotFactory = (overrides) => ({
+  gravity: { x: 0, y: 0, z: -800 },
+  origin: { x: 0, y: 0, z: 0 },
+  velocity: { x: 0, y: 0, z: 0 },
+  viewangles: { x: 0, y: 0, z: 0 },
+  level: { timeSeconds: 0, frameNumber: 0, previousTimeSeconds: 0, deltaSeconds: 0.1 },
+  entities: {
+    activeCount: 0,
+    worldClassname: "worldspawn"
+  },
+  packetEntities: [],
+  pmFlags: 0,
+  pmType: 0,
+  waterlevel: 0,
+  watertype: 0,
+  deltaAngles: { x: 0, y: 0, z: 0 },
+  health: 100,
+  armor: 0,
+  ammo: 0,
+  blend: [0, 0, 0, 0],
+  damageAlpha: 0,
+  damageIndicators: [],
+  stats: [],
+  kick_angles: { x: 0, y: 0, z: 0 },
+  kick_origin: { x: 0, y: 0, z: 0 },
+  gunoffset: { x: 0, y: 0, z: 0 },
+  gunangles: { x: 0, y: 0, z: 0 },
+  gunindex: 0,
+  pm_time: 0,
+  gun_frame: 0,
+  rdflags: 0,
+  fov: 90,
+  renderfx: 0,
+  pm_flags: 0,
+  pm_type: 0,
+  ...overrides
+});
+
+// src/game/helpers.ts
+var import_vitest2 = require("vitest");
+var import_game = require("@quake2ts/game");
+var import_shared2 = require("@quake2ts/shared");
+var import_shared3 = require("@quake2ts/shared");
+var createMockEngine = () => ({
+  sound: import_vitest2.vi.fn(),
+  soundIndex: import_vitest2.vi.fn((sound) => 0),
+  modelIndex: import_vitest2.vi.fn((model) => 0),
+  centerprintf: import_vitest2.vi.fn()
+});
+var createMockGame = (seed = 12345) => {
+  const spawnRegistry = new import_game.SpawnRegistry();
+  const hooks = new import_game.ScriptHookRegistry();
+  const game = {
+    random: (0, import_shared2.createRandomGenerator)({ seed }),
+    registerEntitySpawn: import_vitest2.vi.fn((classname, spawnFunc) => {
+      spawnRegistry.register(classname, (entity) => spawnFunc(entity));
     }),
-    createOscillator: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      frequency: { value: 440 }
+    unregisterEntitySpawn: import_vitest2.vi.fn((classname) => {
+      spawnRegistry.unregister(classname);
     }),
-    createBufferSource: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      buffer: null,
-      playbackRate: { value: 1 },
-      loop: false
+    getCustomEntities: import_vitest2.vi.fn(() => Array.from(spawnRegistry.keys())),
+    hooks,
+    registerHooks: import_vitest2.vi.fn((newHooks) => hooks.register(newHooks)),
+    spawnWorld: import_vitest2.vi.fn(() => {
+      hooks.onMapLoad("q2dm1");
     }),
-    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)
+    clientBegin: import_vitest2.vi.fn((client) => {
+      hooks.onPlayerSpawn({});
     }),
-    createBuffer: (channels, length, sampleRate) => ({
-      duration: length / sampleRate,
-      length,
-      sampleRate,
-      numberOfChannels: channels,
-      getChannelData: () => new Float32Array(length)
+    damage: import_vitest2.vi.fn((amount) => {
+      hooks.onDamage({}, null, null, amount, 0, 0);
     })
   };
-}
-function setupMockAudioContext() {
-  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
-    global.AudioContext = class {
-      constructor() {
-        return createMockAudioContext();
+  return { game, spawnRegistry };
+};
+function createTestContext(options) {
+  const engine = createMockEngine();
+  const seed = options?.seed ?? 12345;
+  const { game, spawnRegistry } = createMockGame(seed);
+  const traceFn = import_vitest2.vi.fn((start, end, mins, maxs) => ({
+    fraction: 1,
+    ent: null,
+    allsolid: false,
+    startsolid: false,
+    endpos: end,
+    plane: { normal: { x: 0, y: 0, z: 1 }, dist: 0 },
+    surfaceFlags: 0,
+    contents: 0
+  }));
+  const entityList = options?.initialEntities ? [...options.initialEntities] : [];
+  const hooks = game.hooks;
+  const entities = {
+    spawn: import_vitest2.vi.fn(() => {
+      const ent = new import_game.Entity(entityList.length + 1);
+      entityList.push(ent);
+      hooks.onEntitySpawn(ent);
+      return ent;
+    }),
+    free: import_vitest2.vi.fn((ent) => {
+      const idx = entityList.indexOf(ent);
+      if (idx !== -1) {
+        entityList.splice(idx, 1);
       }
-    };
-    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);
+      hooks.onEntityRemove(ent);
+    }),
+    finalizeSpawn: import_vitest2.vi.fn(),
+    freeImmediate: import_vitest2.vi.fn((ent) => {
+      const idx = entityList.indexOf(ent);
+      if (idx !== -1) {
+        entityList.splice(idx, 1);
       }
+    }),
+    setSpawnRegistry: import_vitest2.vi.fn(),
+    timeSeconds: 10,
+    deltaSeconds: 0.1,
+    modelIndex: import_vitest2.vi.fn(() => 0),
+    scheduleThink: import_vitest2.vi.fn((entity, time) => {
+      entity.nextthink = time;
+    }),
+    linkentity: import_vitest2.vi.fn(),
+    trace: traceFn,
+    pointcontents: import_vitest2.vi.fn(() => 0),
+    multicast: import_vitest2.vi.fn(),
+    unicast: import_vitest2.vi.fn(),
+    engine,
+    game,
+    sound: import_vitest2.vi.fn((ent, chan, sound, vol, attn, timeofs) => {
+      engine.sound(ent, chan, sound, vol, attn, timeofs);
+    }),
+    soundIndex: import_vitest2.vi.fn((sound) => engine.soundIndex(sound)),
+    useTargets: import_vitest2.vi.fn((entity, activator) => {
+    }),
+    findByTargetName: import_vitest2.vi.fn(() => []),
+    pickTarget: import_vitest2.vi.fn(() => null),
+    killBox: import_vitest2.vi.fn(),
+    rng: (0, import_shared2.createRandomGenerator)({ seed }),
+    imports: {
+      configstring: import_vitest2.vi.fn(),
+      trace: traceFn,
+      pointcontents: import_vitest2.vi.fn(() => 0)
     },
-    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" });
-      }
+    level: {
+      intermission_angle: { x: 0, y: 0, z: 0 },
+      intermission_origin: { x: 0, y: 0, z: 0 },
+      next_auto_save: 0,
+      health_bar_entities: null
     },
-    async screenshot(path2) {
-      await page.screenshot({ path: path2 });
+    targetNameIndex: /* @__PURE__ */ new Map(),
+    forEachEntity: import_vitest2.vi.fn((callback) => {
+      entityList.forEach(callback);
+    }),
+    find: import_vitest2.vi.fn((predicate) => {
+      return entityList.find(predicate);
+    }),
+    findByClassname: import_vitest2.vi.fn((classname) => {
+      return entityList.find((e) => e.classname === classname);
+    }),
+    beginFrame: import_vitest2.vi.fn((timeSeconds) => {
+      entities.timeSeconds = timeSeconds;
+    }),
+    targetAwareness: {
+      timeSeconds: 10,
+      frameNumber: 1,
+      sightEntity: null,
+      soundEntity: null
     },
-    async close() {
-      await browser.close();
-    }
+    // Adding missing properties to satisfy EntitySystem interface partially or fully
+    // We cast to unknown first anyway, but filling these in makes it safer for consumers
+    skill: 1,
+    deathmatch: false,
+    coop: false,
+    activeCount: entityList.length,
+    world: entityList.find((e) => e.classname === "worldspawn") || new import_game.Entity(0)
+    // ... other EntitySystem properties would go here
   };
-  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
-      });
-    }
+    keyValues: {},
+    entities,
+    game,
+    engine,
+    health_multiplier: 1,
+    warn: import_vitest2.vi.fn(),
+    free: import_vitest2.vi.fn(),
+    // Mock precache functions if they are part of SpawnContext in future or TestContext extensions
+    precacheModel: import_vitest2.vi.fn(),
+    precacheSound: import_vitest2.vi.fn(),
+    precacheImage: import_vitest2.vi.fn()
   };
 }
-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 createSpawnContext() {
+  return createTestContext();
 }
-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 };
-      }
-    }
-  };
+function createEntity() {
+  return new import_game.Entity(1);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1372,12 +1361,10 @@ function createVisualTestScenario(page, sceneName) {
   MockPointerLock,
   captureAudioEvents,
   captureCanvasDrawCalls,
-  captureGameScreenshot,
   captureGameState,
-  compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
-  createCustomNetworkCondition,
+  createControlledTimer,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
@@ -1400,7 +1387,6 @@ function createVisualTestScenario(page, sceneName) {
   createSpawnContext,
   createStorageTestScenario,
   createTestContext,
-  createVisualTestScenario,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -1415,11 +1401,9 @@ function createVisualTestScenario(page, sceneName) {
   setupNodeEnvironment,
   simulateFrames,
   simulateFramesWithMock,
-  simulateNetworkCondition,
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
-  throttleBandwidth,
   waitForGameReady
 });
 //# sourceMappingURL=index.cjs.map