murow 0.0.70 → 0.0.71

package/src/ecs/benchmark.test.ts

@@ -1,1645 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { BinaryCodec } from "../core/binary-codec";
-import { defineComponent } from "./component";
-import { World } from "./world";
-
-
-describe("ECS Performance Benchmarks", () => {
-  // Define components for benchmarking
-  const Transform = defineComponent("Transform", {
-    x: BinaryCodec.f32,
-    y: BinaryCodec.f32,
-    rotation: BinaryCodec.f32,
-  });
-
-  const Velocity = defineComponent("Velocity", {
-    vx: BinaryCodec.f32,
-    vy: BinaryCodec.f32,
-  });
-
-  const Health = defineComponent("Health", {
-    current: BinaryCodec.u16,
-    max: BinaryCodec.u16,
-  });
-
-  test("spawn/despawn 10,000 entities (should be < 50ms)", () => {
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform, Velocity, Health],
-    });
-
-    const start = performance.now();
-
-    // Spawn 10,000 entities
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      entities.push(world.spawn());
-    }
-
-    // Despawn all
-    for (const entity of entities) {
-      world.despawn(entity);
-    }
-
-    const elapsed = performance.now() - start;
-
-    console.log(`Spawn/despawn 10k entities: ${elapsed.toFixed(2)}ms`);
-    expect(elapsed).toBeLessThan(50);
-  });
-
-  test("add components to 10,000 entities (should be < 100ms)", () => {
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform, Velocity, Health],
-    });
-
-    // Spawn entities
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      entities.push(world.spawn());
-    }
-
-    const start = performance.now();
-
-    // Add components
-    for (const entity of entities) {
-      world.add(entity, Transform, { x: 0, y: 0, rotation: 0 });
-      world.add(entity, Velocity, { vx: 1, vy: 1 });
-      world.add(entity, Health, { current: 100, max: 100 });
-    }
-
-    const elapsed = performance.now() - start;
-
-    console.log(`Add 3 components to 10k entities: ${elapsed.toFixed(2)}ms`);
-    expect(elapsed).toBeLessThan(100);
-  });
-
-  test("query and update 10,000 entities (should be < 20ms)", () => {
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform, Velocity],
-    });
-
-    // Setup: spawn and add components
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: i, y: i, rotation: 0 });
-      world.add(entity, Velocity, { vx: 1, vy: 1 });
-    }
-
-    const start = performance.now();
-
-    // Query and update (simulates physics system)
-    const deltaTime = 0.016;
-    for (const entity of world.query(Transform, Velocity)) {
-      const t = world.get(entity, Transform);
-      const v = world.get(entity, Velocity);
-
-      // Update using partial update (most efficient)
-      world.update(entity, Transform, {
-        x: t.x + v.vx * deltaTime,
-        y: t.y + v.vy * deltaTime,
-      });
-    }
-
-    const elapsed = performance.now() - start;
-
-    console.log(`Query + update 10k entities: ${elapsed.toFixed(2)}ms`);
-    expect(elapsed).toBeLessThan(20);
-  });
-
-  test("repeated queries with caching (should be < 5ms)", () => {
-    const world = new World({
-      maxEntities: 5000,
-      components: [Transform, Velocity, Health],
-    });
-
-    // Setup
-    for (let i = 0; i < 5000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: 0, y: 0, rotation: 0 });
-      world.add(entity, Velocity, { vx: 1, vy: 1 });
-    }
-
-    const start = performance.now();
-
-    // Run the same query 10 times (should be cached)
-    for (let iteration = 0; iteration < 10; iteration++) {
-      let count = 0;
-      for (const entity of world.query(Transform, Velocity)) {
-        const t = world.get(entity, Transform);
-        world.update(entity, Transform, { x: t.x + 1 });
-        count++;
-      }
-      expect(count).toBe(5000);
-    }
-
-    const elapsed = performance.now() - start;
-
-    console.log(`10 iterations of query/update 5k entities: ${elapsed.toFixed(2)}ms`);
-    expect(elapsed).toBeLessThan(50);
-  });
-
-  test("memory efficiency: ArrayBuffer vs Float32Array savings", () => {
-    const world = new World({
-      maxEntities: 10000,
-      components: [Health], // u16 + u16 = 4 bytes
-    });
-
-    // Spawn entities with Health component
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Health, { current: 100, max: 100 });
-    }
-
-    // Health component: 2 × u16 = 4 bytes per entity
-    // ArrayBuffer: 10,000 × 4 = 40 KB
-    // Float32Array (old): 10,000 × 8 = 80 KB (would round up to 2 floats)
-    // Savings: 50%
-
-    const expectedBytes = 10000 * 4;
-    console.log(`Memory for 10k Health components: ${(expectedBytes / 1024).toFixed(2)} KB`);
-    console.log(`(Float32Array would use: ${(10000 * 8 / 1024).toFixed(2)} KB - 50% savings!)`);
-
-    expect(true).toBe(true); // Memory check is informational
-  });
-
-  test("zero allocations in hot path", () => {
-    const world = new World({
-      maxEntities: 1000,
-      components: [Transform, Velocity],
-    });
-
-    // Setup
-    for (let i = 0; i < 1000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: 0, y: 0, rotation: 0 });
-      world.add(entity, Velocity, { vx: 1, vy: 1 });
-    }
-
-    // Force GC
-    if (global.gc) global.gc();
-
-    const memBefore = (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2);
-
-    // Run many iterations (should have zero allocations due to reusable objects)
-    for (let i = 0; i < 100; i++) {
-      for (const entity of world.query(Transform, Velocity)) {
-        const t = world.get(entity, Transform); // Reuses same object!
-        const v = world.get(entity, Velocity); // Reuses same object!
-        world.update(entity, Transform, {
-          x: t.x + v.vx,
-          y: t.y + v.vy,
-        });
-      }
-    }
-
-    const memAfter = (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2);
-
-    console.log(`Memory before: ${memBefore} MB, after: ${memAfter} MB`);
-    console.log(`Memory delta: ${(parseFloat(memAfter) - parseFloat(memBefore)).toFixed(2)} MB (should be ~0)`);
-
-    // Memory should not grow significantly (< 5 MB for 100 iterations × 1000 entities)
-    const delta = parseFloat(memAfter) - parseFloat(memBefore);
-    expect(delta).toBeLessThan(5);
-  });
-
-  test("realistic game loop: 1000 entities at 60 FPS", () => {
-    const world = new World({
-      maxEntities: 2000,
-      components: [Transform, Velocity, Health],
-    });
-
-    // Setup game world
-    for (let i = 0; i < 1000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: Math.random() * 800, y: Math.random() * 600, rotation: 0 });
-      world.add(entity, Velocity, { vx: (Math.random() - 0.5) * 100, vy: (Math.random() - 0.5) * 100 });
-      world.add(entity, Health, { current: 100, max: 100 });
-    }
-
-    const frameTimings: number[] = [];
-    const targetFPS = 60;
-    const targetFrameTime = 1000 / targetFPS; // 16.67ms
-
-    // Simulate 100 frames
-    for (let frame = 0; frame < 100; frame++) {
-      const frameStart = performance.now();
-
-      const deltaTime = 1 / 60;
-
-      // Physics system
-      for (const entity of world.query(Transform, Velocity)) {
-        const t = world.get(entity, Transform);
-        const v = world.get(entity, Velocity);
-
-        world.update(entity, Transform, {
-          x: t.x + v.vx * deltaTime,
-          y: t.y + v.vy * deltaTime,
-        });
-      }
-
-      // Health system
-      for (const entity of world.query(Health)) {
-        const h = world.get(entity, Health);
-        if (h.current <= 0) {
-          world.despawn(entity);
-        }
-      }
-
-      const frameTime = performance.now() - frameStart;
-      frameTimings.push(frameTime);
-    }
-
-    const avgFrameTime = frameTimings.reduce((a, b) => a + b, 0) / frameTimings.length;
-    const maxFrameTime = Math.max(...frameTimings);
-
-    console.log(`Average frame time: ${avgFrameTime.toFixed(2)}ms (${(1000 / avgFrameTime).toFixed(0)} FPS)`);
-    console.log(`Max frame time: ${maxFrameTime.toFixed(2)}ms`);
-    console.log(`Target: ${targetFrameTime.toFixed(2)}ms (60 FPS)`);
-
-    // Should easily maintain 60 FPS
-    expect(avgFrameTime).toBeLessThan(targetFrameTime);
-  });
-
-  test("performance shows zero-allocation benefit in repeated queries", () => {
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform],
-    });
-
-    // Setup
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: 0, y: 0, rotation: 0 });
-    }
-
-    // The key benefit of zero allocations shows up in GC pressure over time
-    // Single-pass comparison doesn't show the full picture
-    console.log("\nZero-allocation design benefits:");
-    console.log("- No GC pauses during gameplay");
-    console.log("- Consistent frame times");
-    console.log("- Lower memory pressure");
-    console.log("- See 'zero allocations in hot path' test for proof");
-
-    expect(true).toBe(true); // This is informational
-  });
-
-  test("benchmark: spawn performance at scale", () => {
-    console.log("\n=== Spawn Performance Benchmark ===");
-
-    const sizes = [1000, 5000, 10000, 50000];
-
-    for (const size of sizes) {
-      const world = new World({
-        maxEntities: size,
-        components: [Transform],
-      });
-
-      const start = performance.now();
-      for (let i = 0; i < size; i++) {
-        world.spawn();
-      }
-      const elapsed = performance.now() - start;
-
-      console.log(`Spawn ${size.toLocaleString()} entities: ${elapsed.toFixed(2)}ms (${(size / elapsed * 1000).toFixed(0)} entities/sec)`);
-    }
-
-    expect(true).toBe(true);
-  });
-
-  test("benchmark: spawn + despawn cycle (entity reuse)", () => {
-    console.log("\n=== Spawn/Despawn Cycle Benchmark ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform],
-    });
-
-    // Initial spawn
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      entities.push(world.spawn());
-    }
-
-    // Measure despawn
-    const despawnStart = performance.now();
-    for (const entity of entities) {
-      world.despawn(entity);
-    }
-    const despawnTime = performance.now() - despawnStart;
-
-    // Measure respawn (should reuse IDs)
-    const respawnStart = performance.now();
-    for (let i = 0; i < 10000; i++) {
-      world.spawn();
-    }
-    const respawnTime = performance.now() - respawnStart;
-
-    console.log(`Despawn 10k entities: ${despawnTime.toFixed(2)}ms`);
-    console.log(`Respawn 10k entities (ID reuse): ${respawnTime.toFixed(2)}ms`);
-    console.log(`Total cycle: ${(despawnTime + respawnTime).toFixed(2)}ms`);
-
-    expect(world.getEntityCount()).toBe(10000);
-  });
-
-  test("benchmark: component add/remove operations", () => {
-    console.log("\n=== Component Operations Benchmark ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform, Velocity, Health],
-    });
-
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      entities.push(world.spawn());
-    }
-
-    // Add components
-    const addStart = performance.now();
-    for (const entity of entities) {
-      world.add(entity, Transform, { x: 0, y: 0, rotation: 0 });
-      world.add(entity, Velocity, { vx: 0, vy: 0 });
-      world.add(entity, Health, { current: 100, max: 100 });
-    }
-    const addTime = performance.now() - addStart;
-
-    // Remove components
-    const removeStart = performance.now();
-    for (const entity of entities) {
-      world.remove(entity, Velocity);
-    }
-    const removeTime = performance.now() - removeStart;
-
-    console.log(`Add 3 components to 10k entities: ${addTime.toFixed(2)}ms`);
-    console.log(`Remove 1 component from 10k entities: ${removeTime.toFixed(2)}ms`);
-
-    expect(true).toBe(true);
-  });
-
-  test("benchmark: query performance with different entity counts", () => {
-    console.log("\n=== Query Performance Benchmark ===");
-
-    const sizes = [100, 1000, 5000, 10000];
-
-    for (const size of sizes) {
-      const world = new World({
-        maxEntities: size,
-        components: [Transform, Velocity],
-      });
-
-      // Setup entities
-      for (let i = 0; i < size; i++) {
-        const entity = world.spawn();
-        world.add(entity, Transform, { x: i, y: i, rotation: 0 });
-        world.add(entity, Velocity, { vx: 1, vy: 1 });
-      }
-
-      // Single query
-      const singleStart = performance.now();
-      world.query(Transform, Velocity);
-      const singleTime = performance.now() - singleStart;
-
-      // 100 queries (typical frame)
-      const multiStart = performance.now();
-      for (let i = 0; i < 100; i++) {
-        world.query(Transform, Velocity);
-      }
-      const multiTime = performance.now() - multiStart;
-
-      console.log(`Query ${size.toLocaleString()} entities: ${singleTime.toFixed(3)}ms (single), ${multiTime.toFixed(2)}ms (100x)`);
-    }
-
-    expect(true).toBe(true);
-  });
-
-  test("benchmark: get() vs getMutable() performance", () => {
-    console.log("\n=== Get vs GetMutable Benchmark ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform],
-    });
-
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: i, y: i, rotation: 0 });
-      entities.push(entity);
-    }
-
-    // Benchmark get() (readonly, reusable)
-    const getStart = performance.now();
-    let sum1 = 0;
-    for (const entity of entities) {
-      const t = world.get(entity, Transform);
-      sum1 += t.x + t.y; // Use values
-    }
-    const getTime = performance.now() - getStart;
-
-    // Benchmark getMutable() (allocates)
-    const getMutableStart = performance.now();
-    let sum2 = 0;
-    for (const entity of entities) {
-      const t = world.getMutable(entity, Transform);
-      sum2 += t.x + t.y; // Use values
-    }
-    const getMutableTime = performance.now() - getMutableStart;
-
-    console.log(`get() 10k times: ${getTime.toFixed(2)}ms (${(10000 / getTime * 1000).toFixed(0)} ops/sec)`);
-    console.log(`getMutable() 10k times: ${getMutableTime.toFixed(2)}ms (${(10000 / getMutableTime * 1000).toFixed(0)} ops/sec)`);
-    console.log(`get() is ${(getMutableTime / getTime).toFixed(1)}x faster`);
-
-    expect(getTime).toBeLessThan(getMutableTime);
-  });
-
-  test("benchmark: update() vs set() for partial changes", () => {
-    console.log("\n=== Update vs Set Benchmark ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: [Transform],
-    });
-
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: 0, y: 0, rotation: 0 });
-      entities.push(entity);
-    }
-
-    // Benchmark update() (partial, optimized)
-    const updateStart = performance.now();
-    for (const entity of entities) {
-      world.update(entity, Transform, { x: 100 });
-    }
-    const updateTime = performance.now() - updateStart;
-
-    // Reset
-    for (const entity of entities) {
-      world.set(entity, Transform, { x: 0, y: 0, rotation: 0 });
-    }
-
-    // Benchmark set() (full replace)
-    const setStart = performance.now();
-    for (const entity of entities) {
-      world.set(entity, Transform, { x: 100, y: 0, rotation: 0 });
-    }
-    const setTime = performance.now() - setStart;
-
-    console.log(`update() 1 field on 10k entities: ${updateTime.toFixed(2)}ms`);
-    console.log(`set() all fields on 10k entities: ${setTime.toFixed(2)}ms`);
-    console.log(`update() is ${(setTime / updateTime).toFixed(1)}x faster for partial changes`);
-
-    expect(true).toBe(true);
-  });
-
-  test("benchmark: complex game simulation (realistic workload)", () => {
-    console.log("\n=== Complex Game Simulation Benchmark (10+ Systems) ===");
-
-    // Define additional components for more realistic simulation
-    const Armor = defineComponent("Armor", {
-      value: BinaryCodec.u16,
-    });
-
-    const Damage = defineComponent("Damage", {
-      amount: BinaryCodec.u16,
-    });
-
-    const Cooldown = defineComponent("Cooldown", {
-      current: BinaryCodec.f32,
-      max: BinaryCodec.f32,
-    });
-
-    const Team = defineComponent("Team", {
-      id: BinaryCodec.u8,
-    });
-
-    const Target = defineComponent("Target", {
-      entityId: BinaryCodec.u32,
-    });
-
-    const Status = defineComponent("Status", {
-      stunned: BinaryCodec.u8,
-      slowed: BinaryCodec.u8,
-    });
-
-    const Lifetime = defineComponent("Lifetime", {
-      remaining: BinaryCodec.f32,
-    });
-
-    const entityCounts = [500, 1000, 5000, 10000, 25000, 50000];
-    const fps60Budget = 16.67; // 60 FPS
-    const fps30Budget = 33.33; // 30 FPS
-
-    for (const count of entityCounts) {
-      const world = new World({
-        maxEntities: count,
-        components: [Transform, Velocity, Health, Armor, Damage, Cooldown, Team, Target, Status, Lifetime],
-      });
-
-      // Setup entities with varied component combinations
-      for (let i = 0; i < count; i++) {
-        const entity = world.spawn();
-        world.add(entity, Transform, { x: Math.random() * 1000, y: Math.random() * 1000, rotation: Math.random() * Math.PI * 2 });
-        world.add(entity, Velocity, { vx: Math.random() * 10 - 5, vy: Math.random() * 10 - 5 });
-        world.add(entity, Health, { current: 100, max: 100 });
-
-        // 80% have armor
-        if (Math.random() > 0.2) {
-          world.add(entity, Armor, { value: Math.floor(Math.random() * 50) });
-        }
-
-        // 60% can deal damage
-        if (Math.random() > 0.4) {
-          world.add(entity, Damage, { amount: Math.floor(Math.random() * 20) + 10 });
-          world.add(entity, Cooldown, { current: 0, max: 1.0 });
-        }
-
-        // Assign to teams
-        world.add(entity, Team, { id: Math.floor(Math.random() * 4) });
-
-        // 30% have targets
-        if (Math.random() > 0.7) {
-          world.add(entity, Target, { entityId: Math.floor(Math.random() * count) });
-        }
-
-        // 20% have status effects
-        if (Math.random() > 0.8) {
-          world.add(entity, Status, { stunned: Math.random() > 0.5 ? 1 : 0, slowed: Math.random() > 0.5 ? 1 : 0 });
-        }
-
-        // 15% are temporary entities (projectiles, effects, etc.)
-        if (Math.random() > 0.85) {
-          world.add(entity, Lifetime, { remaining: Math.random() * 5 });
-        }
-      }
-
-      // Simulate 60 frames
-      const frameCount = 60;
-      const deltaTime = 0.016;
-      const frameTimes: number[] = [];
-
-      for (let frame = 0; frame < frameCount; frame++) {
-        const frameStart = performance.now();
-
-        // System 1: Movement system (applies velocity to transform)
-        for (const entity of world.query(Transform, Velocity)) {
-          const t = world.get(entity, Transform);
-          const v = world.get(entity, Velocity);
-
-          world.update(entity, Transform, {
-            x: t.x + v.vx * deltaTime,
-            y: t.y + v.vy * deltaTime,
-          });
-        }
-
-        // System 2: Rotation system (rotate entities based on velocity)
-        for (const entity of world.query(Transform, Velocity)) {
-          const v = world.get(entity, Velocity);
-          if (v.vx !== 0 || v.vy !== 0) {
-            world.update(entity, Transform, {
-              rotation: Math.atan2(v.vy, v.vx),
-            });
-          }
-        }
-
-        // System 3: Boundary system (wrap around screen edges)
-        for (const entity of world.query(Transform)) {
-          const t = world.get(entity, Transform);
-          let needsUpdate = false;
-          let newX = t.x;
-          let newY = t.y;
-
-          if (t.x < 0) { newX = 1000; needsUpdate = true; }
-          if (t.x > 1000) { newX = 0; needsUpdate = true; }
-          if (t.y < 0) { newY = 1000; needsUpdate = true; }
-          if (t.y > 1000) { newY = 0; needsUpdate = true; }
-
-          if (needsUpdate) {
-            world.update(entity, Transform, { x: newX, y: newY });
-          }
-        }
-
-        // System 4: Health regeneration system
-        if (frame % 30 === 0) {
-          for (const entity of world.query(Health)) {
-            const h = world.get(entity, Health);
-            if (h.current > 0 && h.current < h.max) {
-              const newHealth = h.current + 5;
-              world.update(entity, Health, {
-                current: newHealth > h.max ? h.max : newHealth,
-              });
-            }
-          }
-        }
-
-        // System 5: Cooldown system
-        for (const entity of world.query(Cooldown)) {
-          const cd = world.get(entity, Cooldown);
-          if (cd.current > 0) {
-            const newCooldown = cd.current - deltaTime;
-            world.update(entity, Cooldown, {
-              current: newCooldown < 0 ? 0 : newCooldown,
-            });
-          }
-        }
-
-        // System 6: Combat system (entities with damage and target)
-        if (frame % 5 === 0) {
-          for (const entity of world.query(Damage, Cooldown, Target)) {
-            const cd = world.get(entity, Cooldown);
-            const target = world.get(entity, Target);
-
-            if (cd.current === 0 && world.isAlive(target.entityId)) {
-              const dmg = world.get(entity, Damage);
-
-              if (world.has(target.entityId, Health)) {
-                const targetHealth = world.get(target.entityId, Health);
-                let damageDealt = dmg.amount;
-
-                // Apply armor reduction
-                if (world.has(target.entityId, Armor)) {
-                  const armor = world.get(target.entityId, Armor);
-                  const reduced = dmg.amount - armor.value * 0.1;
-                  damageDealt = reduced < 1 ? 1 : reduced;
-                }
-
-                const newHealth = targetHealth.current - damageDealt;
-                world.update(target.entityId, Health, {
-                  current: newHealth < 0 ? 0 : newHealth,
-                });
-
-                // Reset cooldown
-                world.update(entity, Cooldown, { current: cd.max });
-              }
-            }
-          }
-        }
-
-        // System 7: Death system (despawn dead entities)
-        const toRemove: number[] = [];
-        for (const entity of world.query(Health)) {
-          const h = world.get(entity, Health);
-          if (h.current <= 0) {
-            toRemove.push(entity);
-          }
-        }
-        for (const entity of toRemove) {
-          world.despawn(entity);
-        }
-
-        // System 8: Status effect system
-        for (const entity of world.query(Status, Velocity)) {
-          const status = world.get(entity, Status);
-          const v = world.get(entity, Velocity);
-
-          if (status.stunned === 1) {
-            world.update(entity, Velocity, { vx: 0, vy: 0 });
-          } else if (status.slowed === 1) {
-            world.update(entity, Velocity, {
-              vx: v.vx * 0.5,
-              vy: v.vy * 0.5,
-            });
-          }
-        }
-
-        // System 9: Lifetime system (despawn temporary entities)
-        const expiredEntities: number[] = [];
-        for (const entity of world.query(Lifetime)) {
-          const lifetime = world.get(entity, Lifetime);
-          const remaining = lifetime.remaining - deltaTime;
-
-          if (remaining <= 0) {
-            expiredEntities.push(entity);
-          } else {
-            world.update(entity, Lifetime, { remaining });
-          }
-        }
-        for (const entity of expiredEntities) {
-          world.despawn(entity);
-        }
-
-        // System 10: Velocity damping system (apply friction)
-        for (const entity of world.query(Velocity)) {
-          const v = world.get(entity, Velocity);
-          world.update(entity, Velocity, {
-            vx: v.vx * 0.99,
-            vy: v.vy * 0.99,
-          });
-        }
-
-        // System 11: Random velocity changes (simulates AI behavior)
-        if (frame % 20 === 0) {
-          for (const entity of world.query(Velocity)) {
-            if (Math.random() > 0.9) {
-              const v = world.get(entity, Velocity);
-              world.update(entity, Velocity, {
-                vx: v.vx + (Math.random() - 0.5) * 2,
-                vy: v.vy + (Math.random() - 0.5) * 2,
-              });
-            }
-          }
-        }
-
-        frameTimes.push(performance.now() - frameStart);
-      }
-
-      const avgFrameTime = frameTimes.reduce((a, b) => a + b, 0) / frameTimes.length;
-      const maxFrameTime = Math.max(...frameTimes);
-      const minFrameTime = Math.min(...frameTimes);
-      const fps = 1000 / avgFrameTime;
-
-      // Determine status
-      let status60 = avgFrameTime < fps60Budget ? "✅" : "❌";
-      let status30 = avgFrameTime < fps30Budget ? "✅" : "⚠️";
-
-      console.log(`${count.toLocaleString()} entities: ${avgFrameTime.toFixed(2)}ms avg (${fps.toFixed(0)} FPS) - 60fps: ${status60} 30fps: ${status30}`);
-      console.log(`  Min: ${minFrameTime.toFixed(2)}ms, Max: ${maxFrameTime.toFixed(2)}ms`);
-    }
-
-    expect(true).toBe(true);
-  }, { timeout: 15000 });
-
-  test("benchmark: memory usage comparison", () => {
-    console.log("\n=== Memory Usage Benchmark ===");
-
-    const sizes = [1000, 5000, 10000];
-
-    for (const size of sizes) {
-      const world = new World({
-        maxEntities: size,
-        components: [Transform, Velocity, Health],
-      });
-
-      const memBefore = (performance as any).memory?.usedJSHeapSize || 0;
-
-      // Create entities with components
-      for (let i = 0; i < size; i++) {
-        const entity = world.spawn();
-        world.add(entity, Transform, { x: i, y: i, rotation: 0 });
-        world.add(entity, Velocity, { vx: 1, vy: 1 });
-        world.add(entity, Health, { current: 100, max: 100 });
-      }
-
-      const memAfter = (performance as any).memory?.usedJSHeapSize || 0;
-      const delta = (memAfter - memBefore) / 1024 / 1024;
-
-      console.log(`${size} entities: ${delta.toFixed(2)} MB (~${(delta / size * 1024).toFixed(2)} KB per entity)`);
-    }
-
-    expect(true).toBe(true);
-  });
-
-  test("benchmark: worst case scenario (many components per entity)", () => {
-    console.log("\n=== Worst Case Benchmark (Many Components) ===");
-
-    // Create 16 different components
-    const components = [];
-    for (let i = 0; i < 16; i++) {
-      components.push(
-        defineComponent(`Component${i}`, {
-          value: BinaryCodec.f32,
-        })
-      );
-    }
-
-    const world = new World({
-      maxEntities: 1000,
-      components,
-    });
-
-    const entities: number[] = [];
-
-    // Spawn and add all components
-    const setupStart = performance.now();
-    for (let i = 0; i < 1000; i++) {
-      const entity = world.spawn();
-      for (const component of components) {
-        world.add(entity, component, { value: i });
-      }
-      entities.push(entity);
-    }
-    const setupTime = performance.now() - setupStart;
-
-    // Query with many component requirements
-    const queryStart = performance.now();
-    const results = world.query(...components.slice(0, 8));
-    const queryTime = performance.now() - queryStart;
-
-    console.log(`Setup 1000 entities with 16 components each: ${setupTime.toFixed(2)}ms`);
-    console.log(`Query with 8 component requirements: ${queryTime.toFixed(3)}ms`);
-    console.log(`Result count: ${results.length}`);
-
-    expect(results.length).toBe(1000);
-  });
-
-  test("benchmark: EntityHandle vs Raw API in complex simulation", () => {
-    console.log("\n=== EntityHandle vs Raw API Performance (Complex Simulation) ===");
-
-    // Define components
-    const Armor = defineComponent("Armor", { value: BinaryCodec.u16 });
-    const Damage = defineComponent("Damage", { amount: BinaryCodec.u16 });
-    const Cooldown = defineComponent("Cooldown", { current: BinaryCodec.f32, max: BinaryCodec.f32 });
-
-    const entityCount = 5000;
-    const frameCount = 60;
-    const deltaTime = 0.016;
-
-    // Test with Raw API
-    const worldRaw = new World({
-      maxEntities: entityCount,
-      components: [Transform, Velocity, Health, Armor, Damage, Cooldown],
-    });
-
-    for (let i = 0; i < entityCount; i++) {
-      const entity = worldRaw.spawn();
-      worldRaw.add(entity, Transform, { x: Math.random() * 1000, y: Math.random() * 1000, rotation: 0 });
-      worldRaw.add(entity, Velocity, { vx: Math.random() * 10 - 5, vy: Math.random() * 10 - 5 });
-      worldRaw.add(entity, Health, { current: 100, max: 100 });
-      if (Math.random() > 0.2) worldRaw.add(entity, Armor, { value: 50 });
-      if (Math.random() > 0.4) {
-        worldRaw.add(entity, Damage, { amount: 10 });
-        worldRaw.add(entity, Cooldown, { current: 0, max: 1.0 });
-      }
-    }
-
-    const rawFrameTimes: number[] = [];
-    for (let frame = 0; frame < frameCount; frame++) {
-      const frameStart = performance.now();
-
-      // Movement system
-      for (const entity of worldRaw.query(Transform, Velocity)) {
-        const t = worldRaw.get(entity, Transform);
-        const v = worldRaw.get(entity, Velocity);
-        worldRaw.update(entity, Transform, {
-          x: t.x + v.vx * deltaTime,
-          y: t.y + v.vy * deltaTime,
-        });
-      }
-
-      // Health regeneration
-      if (frame % 30 === 0) {
-        for (const entity of worldRaw.query(Health)) {
-          const h = worldRaw.get(entity, Health);
-          if (h.current > 0 && h.current < h.max) {
-            const newHealth = h.current + 5;
-            worldRaw.update(entity, Health, {
-              current: newHealth > h.max ? h.max : newHealth,
-            });
-          }
-        }
-      }
-
-      // Cooldown system
-      for (const entity of worldRaw.query(Cooldown)) {
-        const cd = worldRaw.get(entity, Cooldown);
-        if (cd.current > 0) {
-          const newCooldown = cd.current - deltaTime;
-          worldRaw.update(entity, Cooldown, {
-            current: newCooldown < 0 ? 0 : newCooldown,
-          });
-        }
-      }
-
-      rawFrameTimes.push(performance.now() - frameStart);
-    }
-
-    // Test with EntityHandle API
-    const worldHandle = new World({
-      maxEntities: entityCount,
-      components: [Transform, Velocity, Health, Armor, Damage, Cooldown],
-    });
-
-    for (let i = 0; i < entityCount; i++) {
-      const entity = worldHandle.entity(worldHandle.spawn())
-        .add(Transform, { x: Math.random() * 1000, y: Math.random() * 1000, rotation: 0 })
-        .add(Velocity, { vx: Math.random() * 10 - 5, vy: Math.random() * 10 - 5 })
-        .add(Health, { current: 100, max: 100 });
-
-      if (Math.random() > 0.2) entity.add(Armor, { value: 50 });
-      if (Math.random() > 0.4) {
-        entity.add(Damage, { amount: 10 });
-        entity.add(Cooldown, { current: 0, max: 1.0 });
-      }
-    }
-
-    const handleFrameTimes: number[] = [];
-    for (let frame = 0; frame < frameCount; frame++) {
-      const frameStart = performance.now();
-
-      // Movement system
-      for (const id of worldHandle.query(Transform, Velocity)) {
-        const entity = worldHandle.entity(id);
-        const t = entity.get(Transform);
-        const v = entity.get(Velocity);
-        entity.update(Transform, {
-          x: t.x + v.vx * deltaTime,
-          y: t.y + v.vy * deltaTime,
-        });
-      }
-
-      // Health regeneration
-      if (frame % 30 === 0) {
-        for (const id of worldHandle.query(Health)) {
-          const entity = worldHandle.entity(id);
-          const h = entity.get(Health);
-          if (h.current > 0 && h.current < h.max) {
-            const newHealth = h.current + 5;
-            entity.update(Health, {
-              current: newHealth > h.max ? h.max : newHealth,
-            });
-          }
-        }
-      }
-
-      // Cooldown system
-      for (const id of worldHandle.query(Cooldown)) {
-        const entity = worldHandle.entity(id);
-        const cd = entity.get(Cooldown);
-        if (cd.current > 0) {
-          const newCooldown = cd.current - deltaTime;
-          entity.update(Cooldown, {
-            current: newCooldown < 0 ? 0 : newCooldown,
-          });
-        }
-      }
-
-      handleFrameTimes.push(performance.now() - frameStart);
-    }
-
-    const rawAvg = rawFrameTimes.reduce((a, b) => a + b, 0) / rawFrameTimes.length;
-    const handleAvg = handleFrameTimes.reduce((a, b) => a + b, 0) / handleFrameTimes.length;
-    const overhead = ((handleAvg / rawAvg - 1) * 100);
-
-    console.log(`Raw API:       ${rawAvg.toFixed(2)}ms avg (${(1000 / rawAvg).toFixed(0)} FPS)`);
-    console.log(`EntityHandle:  ${handleAvg.toFixed(2)}ms avg (${(1000 / handleAvg).toFixed(0)} FPS)`);
-    console.log(`Overhead:      ${overhead >= 0 ? '+' : ''}${overhead.toFixed(1)}%`);
-
-    if (overhead < 0) {
-      console.log(`✨ EntityHandle is ${Math.abs(overhead).toFixed(1)}% FASTER (JIT optimization)`);
-    } else if (overhead < 5) {
-      console.log(`✅ Zero overhead achieved (within measurement noise)`);
-    } else if (overhead < 10) {
-      console.log(`✅ Minimal overhead (acceptable for ergonomics)`);
-    }
-
-    // EntityHandle should be within 50% (accounting for JIT warmup variance in CI)
-    // In production with warmed JIT, typical overhead is 0-15%
-    // CI environments often show higher variance due to cold JIT and shared resources
-    expect(handleAvg).toBeLessThan(rawAvg * 1.5);
-  }, { timeout: 15000 });
-
-  test("benchmark: memory usage scales linearly", () => {
-    console.log("\n=== Memory Scaling Benchmark ===");
-
-    const entityCounts = [100, 1000, 10000, 25000];
-    const worldSizes: number[] = [];
-
-    // Calculate theoretical memory usage based on component layout
-    const transformSize = 12; // 3 x f32 = 12 bytes
-    const healthSize = 4;     // 2 x u16 = 4 bytes
-    const componentOverhead = 8; // Bitmask + index overhead per entity (estimated)
-    const theoreticalBytesPerEntity = transformSize + healthSize + componentOverhead;
-
-    console.log(`Theoretical memory per entity: ${theoreticalBytesPerEntity} bytes`);
-    console.log(`  Transform: ${transformSize} bytes (x: f32, y: f32, rotation: f32)`);
-    console.log(`  Health: ${healthSize} bytes (current: u16, max: u16)`);
-    console.log(`  Overhead: ${componentOverhead} bytes (estimated)\n`);
-
-    for (const count of entityCounts) {
-      const world = new World({
-        maxEntities: count,
-        components: [Transform, Health],
-      });
-
-      // Create entities with components
-      for (let i = 0; i < count; i++) {
-        world.entity(world.spawn())
-          .add(Transform, { x: i, y: i, rotation: 0 })
-          .add(Health, { current: 100, max: 100 });
-      }
-
-      // Calculate actual memory used (component stores + world structures)
-      // This is deterministic based on entity count
-      const actualBytes = count * theoreticalBytesPerEntity;
-      worldSizes.push(actualBytes);
-
-      console.log(`${count.toLocaleString()} entities: ${(actualBytes / 1024).toFixed(2)} KB (${theoreticalBytesPerEntity} bytes/entity)`);
-    }
-
-    // Verify linear scaling (memory ratio should equal entity ratio)
-    console.log("\nLinear scaling verification:");
-    for (let i = 1; i < worldSizes.length; i++) {
-      const memoryRatio = worldSizes[i] / worldSizes[i - 1];
-      const entityRatio = entityCounts[i] / entityCounts[i - 1];
-
-      console.log(`  ${entityCounts[i - 1]} → ${entityCounts[i]}: memory ratio ${memoryRatio.toFixed(2)}x, entity ratio ${entityRatio.toFixed(2)}x`);
-
-      // Perfect linear scaling
-      expect(memoryRatio).toBeCloseTo(entityRatio, 2);
-    }
-
-    // Verify consistent per-entity memory
-    const bytesPerEntity = worldSizes.map((size, i) => size / entityCounts[i]);
-    const allSame = bytesPerEntity.every(b => b === theoreticalBytesPerEntity);
-
-    console.log(`\nMemory per entity: ${bytesPerEntity[0]} bytes (consistent: ${allSame})`);
-    expect(allSame).toBe(true);
-
-    console.log("\n✅ Memory scales linearly with entity count (TypedArray-based storage)");
-  });
-}); // Extended timeout for benchmarks
-
-
-describe("ECS Stress Test Benchmarks (25 Components)", () => {
-  // Define a comprehensive set of components for stress testing
-  const Transform = defineComponent("Transform", {
-    x: BinaryCodec.f32,
-    y: BinaryCodec.f32,
-    z: BinaryCodec.f32,
-    rotation: BinaryCodec.f32,
-    scale: BinaryCodec.f32,
-  });
-
-  const Velocity = defineComponent("Velocity", {
-    vx: BinaryCodec.f32,
-    vy: BinaryCodec.f32,
-    vz: BinaryCodec.f32,
-  });
-
-  const Acceleration = defineComponent("Acceleration", {
-    ax: BinaryCodec.f32,
-    ay: BinaryCodec.f32,
-    az: BinaryCodec.f32,
-  });
-
-  const Health = defineComponent("Health", {
-    current: BinaryCodec.u16,
-    max: BinaryCodec.u16,
-  });
-
-  const Armor = defineComponent("Armor", {
-    physical: BinaryCodec.u16,
-    magical: BinaryCodec.u16,
-  });
-
-  const Damage = defineComponent("Damage", {
-    physical: BinaryCodec.u16,
-    magical: BinaryCodec.u16,
-    critical: BinaryCodec.f32,
-  });
-
-  const Stats = defineComponent("Stats", {
-    strength: BinaryCodec.u16,
-    dexterity: BinaryCodec.u16,
-    intelligence: BinaryCodec.u16,
-    vitality: BinaryCodec.u16,
-  });
-
-  const Inventory = defineComponent("Inventory", {
-    slot1: BinaryCodec.u32,
-    slot2: BinaryCodec.u32,
-    slot3: BinaryCodec.u32,
-    slot4: BinaryCodec.u32,
-    gold: BinaryCodec.u32,
-  });
-
-  const Animation = defineComponent("Animation", {
-    currentFrame: BinaryCodec.u16,
-    totalFrames: BinaryCodec.u16,
-    fps: BinaryCodec.u8,
-    loop: BinaryCodec.u8,
-  });
-
-  const Collider = defineComponent("Collider", {
-    width: BinaryCodec.f32,
-    height: BinaryCodec.f32,
-    offsetX: BinaryCodec.f32,
-    offsetY: BinaryCodec.f32,
-  });
-
-  const Rigidbody = defineComponent("Rigidbody", {
-    mass: BinaryCodec.f32,
-    drag: BinaryCodec.f32,
-    angularDrag: BinaryCodec.f32,
-    useGravity: BinaryCodec.u8,
-  });
-
-  const AI = defineComponent("AI", {
-    state: BinaryCodec.u8,
-    targetId: BinaryCodec.u32,
-    aggroRange: BinaryCodec.f32,
-    chaseSpeed: BinaryCodec.f32,
-  });
-
-  const Cooldowns = defineComponent("Cooldowns", {
-    ability1: BinaryCodec.f32,
-    ability2: BinaryCodec.f32,
-    ability3: BinaryCodec.f32,
-    ability4: BinaryCodec.f32,
-  });
-
-  const Status = defineComponent("Status", {
-    stunned: BinaryCodec.u8,
-    slowed: BinaryCodec.u8,
-    poisoned: BinaryCodec.u8,
-    burning: BinaryCodec.u8,
-    frozen: BinaryCodec.u8,
-    invulnerable: BinaryCodec.u8,
-  });
-
-  const Team = defineComponent("Team", {
-    id: BinaryCodec.u8,
-    rank: BinaryCodec.u8,
-  });
-
-  const Experience = defineComponent("Experience", {
-    current: BinaryCodec.u32,
-    level: BinaryCodec.u16,
-    toNextLevel: BinaryCodec.u32,
-  });
-
-  const Lifetime = defineComponent("Lifetime", {
-    remaining: BinaryCodec.f32,
-    fadeOut: BinaryCodec.u8,
-  });
-
-  const Parent = defineComponent("Parent", {
-    entityId: BinaryCodec.u32,
-  });
-
-  const Children = defineComponent("Children", {
-    count: BinaryCodec.u8,
-    child1: BinaryCodec.u32,
-    child2: BinaryCodec.u32,
-    child3: BinaryCodec.u32,
-    child4: BinaryCodec.u32,
-  });
-
-  const Network = defineComponent("Network", {
-    ownerId: BinaryCodec.u32,
-    lastSyncTime: BinaryCodec.f32,
-    dirty: BinaryCodec.u8,
-  });
-
-  const Sprite = defineComponent("Sprite", {
-    textureId: BinaryCodec.u32,
-    tintR: BinaryCodec.u8,
-    tintG: BinaryCodec.u8,
-    tintB: BinaryCodec.u8,
-    alpha: BinaryCodec.u8,
-  });
-
-  const Audio = defineComponent("Audio", {
-    soundId: BinaryCodec.u32,
-    volume: BinaryCodec.f32,
-    loop: BinaryCodec.u8,
-    playing: BinaryCodec.u8,
-  });
-
-  const Particle = defineComponent("Particle", {
-    emissionRate: BinaryCodec.f32,
-    lifetime: BinaryCodec.f32,
-    speed: BinaryCodec.f32,
-    size: BinaryCodec.f32,
-  });
-
-  const Light = defineComponent("Light", {
-    intensity: BinaryCodec.f32,
-    radius: BinaryCodec.f32,
-    colorR: BinaryCodec.u8,
-    colorG: BinaryCodec.u8,
-    colorB: BinaryCodec.u8,
-  });
-
-  const Camera = defineComponent("Camera", {
-    fov: BinaryCodec.f32,
-    near: BinaryCodec.f32,
-    far: BinaryCodec.f32,
-    targetId: BinaryCodec.u32,
-  });
-
-  const ALL_COMPONENTS = [
-    Transform, Velocity, Acceleration, Health, Armor, Damage, Stats,
-    Inventory, Animation, Collider, Rigidbody, AI, Cooldowns, Status,
-    Team, Experience, Lifetime, Parent, Children, Network, Sprite,
-    Audio, Particle, Light, Camera
-  ];
-  test("stress: spawn 10,000 entities with 25 components", () => {
-    console.log("\n=== STRESS TEST: 25 Components per Entity ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: ALL_COMPONENTS,
-    });
-
-    const entities: number[] = [];
-
-    const spawnStart = performance.now();
-    for (let i = 0; i < 10000; i++) {
-      entities.push(world.spawn());
-    }
-    const spawnTime = performance.now() - spawnStart;
-
-    const addStart = performance.now();
-    for (const entity of entities) {
-      world.add(entity, Transform, { x: 0, y: 0, z: 0, rotation: 0, scale: 1 });
-      world.add(entity, Velocity, { vx: 1, vy: 1, vz: 0 });
-      world.add(entity, Acceleration, { ax: 0, ay: 0, az: 0 });
-      world.add(entity, Health, { current: 100, max: 100 });
-      world.add(entity, Armor, { physical: 50, magical: 30 });
-      world.add(entity, Damage, { physical: 20, magical: 10, critical: 1.5 });
-      world.add(entity, Stats, { strength: 10, dexterity: 10, intelligence: 10, vitality: 10 });
-      world.add(entity, Inventory, { slot1: 0, slot2: 0, slot3: 0, slot4: 0, gold: 100 });
-      world.add(entity, Animation, { currentFrame: 0, totalFrames: 10, fps: 30, loop: 1 });
-      world.add(entity, Collider, { width: 32, height: 32, offsetX: 0, offsetY: 0 });
-      world.add(entity, Rigidbody, { mass: 1, drag: 0.1, angularDrag: 0.05, useGravity: 1 });
-      world.add(entity, AI, { state: 0, targetId: 0, aggroRange: 100, chaseSpeed: 5 });
-      world.add(entity, Cooldowns, { ability1: 0, ability2: 0, ability3: 0, ability4: 0 });
-      world.add(entity, Status, { stunned: 0, slowed: 0, poisoned: 0, burning: 0, frozen: 0, invulnerable: 0 });
-      world.add(entity, Team, { id: 1, rank: 1 });
-      world.add(entity, Experience, { current: 0, level: 1, toNextLevel: 100 });
-      world.add(entity, Lifetime, { remaining: 999, fadeOut: 0 });
-      world.add(entity, Parent, { entityId: 0 });
-      world.add(entity, Children, { count: 0, child1: 0, child2: 0, child3: 0, child4: 0 });
-      world.add(entity, Network, { ownerId: 0, lastSyncTime: 0, dirty: 0 });
-      world.add(entity, Sprite, { textureId: 1, tintR: 255, tintG: 255, tintB: 255, alpha: 255 });
-      world.add(entity, Audio, { soundId: 0, volume: 1.0, loop: 0, playing: 0 });
-      world.add(entity, Particle, { emissionRate: 10, lifetime: 2, speed: 5, size: 1 });
-      world.add(entity, Light, { intensity: 1, radius: 100, colorR: 255, colorG: 255, colorB: 255 });
-      world.add(entity, Camera, { fov: 60, near: 0.1, far: 1000, targetId: 0 });
-    }
-    const addTime = performance.now() - addStart;
-
-    console.log(`Spawn 10k entities: ${spawnTime.toFixed(2)}ms`);
-    console.log(`Add 25 components to 10k entities: ${addTime.toFixed(2)}ms`);
-    console.log(`Total setup: ${(spawnTime + addTime).toFixed(2)}ms`);
-    console.log(`Average per entity: ${((spawnTime + addTime) / 10000).toFixed(3)}ms`);
-
-    expect(entities.length).toBe(10000);
-  }, { timeout: 30000 });
-
-  test("stress: complex multi-system simulation with 25 components", () => {
-    console.log("\n=== STRESS TEST: Multi-System Simulation (25 Components) ===");
-
-    const entityCounts = [500, 1000, 2500, 5000, 10000];
-
-    for (const count of entityCounts) {
-      const world = new World({
-        maxEntities: count,
-        components: ALL_COMPONENTS,
-      });
-
-      // Setup entities with all components
-      for (let i = 0; i < count; i++) {
-        const entity = world.spawn();
-        world.add(entity, Transform, { x: Math.random() * 1000, y: Math.random() * 1000, z: 0, rotation: 0, scale: 1 });
-        world.add(entity, Velocity, { vx: Math.random() * 10 - 5, vy: Math.random() * 10 - 5, vz: 0 });
-        world.add(entity, Acceleration, { ax: 0, ay: 0, az: 0 });
-        world.add(entity, Health, { current: 100, max: 100 });
-        world.add(entity, Armor, { physical: 50, magical: 30 });
-        world.add(entity, Damage, { physical: 20, magical: 10, critical: 1.5 });
-        world.add(entity, Stats, { strength: 10, dexterity: 10, intelligence: 10, vitality: 10 });
-        world.add(entity, Inventory, { slot1: 0, slot2: 0, slot3: 0, slot4: 0, gold: 100 });
-        world.add(entity, Animation, { currentFrame: 0, totalFrames: 10, fps: 30, loop: 1 });
-        world.add(entity, Collider, { width: 32, height: 32, offsetX: 0, offsetY: 0 });
-        world.add(entity, Rigidbody, { mass: 1, drag: 0.1, angularDrag: 0.05, useGravity: 1 });
-        world.add(entity, AI, { state: 0, targetId: 0, aggroRange: 100, chaseSpeed: 5 });
-        world.add(entity, Cooldowns, { ability1: 0, ability2: 0, ability3: 0, ability4: 0 });
-        world.add(entity, Status, { stunned: 0, slowed: 0, poisoned: 0, burning: 0, frozen: 0, invulnerable: 0 });
-        world.add(entity, Team, { id: Math.floor(Math.random() * 4), rank: 1 });
-        world.add(entity, Experience, { current: 0, level: 1, toNextLevel: 100 });
-        world.add(entity, Network, { ownerId: i, lastSyncTime: 0, dirty: 0 });
-        world.add(entity, Sprite, { textureId: 1, tintR: 255, tintG: 255, tintB: 255, alpha: 255 });
-      }
-
-      // Run simulation for 60 frames
-      const frameCount = 60;
-      const deltaTime = 0.016;
-      const frameTimes: number[] = [];
-
-      for (let frame = 0; frame < frameCount; frame++) {
-        const frameStart = performance.now();
-
-        // System 1: Physics - Apply acceleration to velocity
-        for (const entity of world.query(Velocity, Acceleration)) {
-          const v = world.get(entity, Velocity);
-          const a = world.get(entity, Acceleration);
-          world.update(entity, Velocity, {
-            vx: v.vx + a.ax * deltaTime,
-            vy: v.vy + a.ay * deltaTime,
-            vz: v.vz + a.az * deltaTime,
-          });
-        }
-
-        // System 2: Movement - Apply velocity to position
-        for (const entity of world.query(Transform, Velocity)) {
-          const t = world.get(entity, Transform);
-          const v = world.get(entity, Velocity);
-          world.update(entity, Transform, {
-            x: t.x + v.vx * deltaTime,
-            y: t.y + v.vy * deltaTime,
-            z: t.z + v.vz * deltaTime,
-          });
-        }
-
-        // System 3: Rotation - Update rotation based on velocity
-        for (const entity of world.query(Transform, Velocity)) {
-          const v = world.get(entity, Velocity);
-          if (v.vx !== 0 || v.vy !== 0) {
-            world.update(entity, Transform, {
-              rotation: Math.atan2(v.vy, v.vx),
-            });
-          }
-        }
-
-        // System 4: Rigidbody - Apply drag
-        for (const entity of world.query(Velocity, Rigidbody)) {
-          const v = world.get(entity, Velocity);
-          const rb = world.get(entity, Rigidbody);
-          const drag = 1 - rb.drag;
-          world.update(entity, Velocity, {
-            vx: v.vx * drag,
-            vy: v.vy * drag,
-            vz: v.vz * drag,
-          });
-        }
-
-        // System 5: Animation - Update animation frames
-        for (const entity of world.query(Animation)) {
-          const anim = world.get(entity, Animation);
-          const newFrame = (anim.currentFrame + 1) % anim.totalFrames;
-          world.update(entity, Animation, { currentFrame: newFrame });
-        }
-
-        // System 6: Health regeneration
-        if (frame % 30 === 0) {
-          for (const entity of world.query(Health, Stats)) {
-            const h = world.get(entity, Health);
-            const stats = world.get(entity, Stats);
-            if (h.current < h.max) {
-              const regen = Math.floor(stats.vitality * 0.1);
-              world.update(entity, Health, {
-                current: Math.min(h.current + regen, h.max),
-              });
-            }
-          }
-        }
-
-        // System 7: Cooldown reduction
-        for (const entity of world.query(Cooldowns)) {
-          const cd = world.get(entity, Cooldowns);
-          world.update(entity, Cooldowns, {
-            ability1: Math.max(0, cd.ability1 - deltaTime),
-            ability2: Math.max(0, cd.ability2 - deltaTime),
-            ability3: Math.max(0, cd.ability3 - deltaTime),
-            ability4: Math.max(0, cd.ability4 - deltaTime),
-          });
-        }
-
-        // System 8: Status effect processing
-        for (const entity of world.query(Status, Health)) {
-          const status = world.get(entity, Status);
-          const h = world.get(entity, Health);
-          let damage = 0;
-
-          if (status.poisoned) damage += 1;
-          if (status.burning) damage += 2;
-
-          if (damage > 0 && !status.invulnerable) {
-            world.update(entity, Health, {
-              current: Math.max(0, h.current - damage),
-            });
-          }
-        }
-
-        // System 9: AI state machine
-        if (frame % 10 === 0) {
-          for (const entity of world.query(AI, Transform)) {
-            const ai = world.get(entity, AI);
-            const newState = (ai.state + 1) % 4; // Cycle through states
-            world.update(entity, AI, { state: newState });
-          }
-        }
-
-        // System 10: Network dirty flag
-        for (const entity of world.query(Network, Transform)) {
-          world.update(entity, Network, {
-            dirty: 1,
-            lastSyncTime: frame * deltaTime,
-          });
-        }
-
-        // System 11: Experience gain (every second)
-        if (frame % 60 === 0) {
-          for (const entity of world.query(Experience)) {
-            const exp = world.get(entity, Experience);
-            const newExp = exp.current + 10;
-            if (newExp >= exp.toNextLevel) {
-              world.update(entity, Experience, {
-                current: 0,
-                level: exp.level + 1,
-                toNextLevel: exp.toNextLevel * 2,
-              });
-            } else {
-              world.update(entity, Experience, { current: newExp });
-            }
-          }
-        }
-
-        // System 12: Boundary wrapping
-        for (const entity of world.query(Transform)) {
-          const t = world.get(entity, Transform);
-          let updated = false;
-          let newX = t.x, newY = t.y;
-
-          if (t.x < 0) { newX = 1000; updated = true; }
-          if (t.x > 1000) { newX = 0; updated = true; }
-          if (t.y < 0) { newY = 1000; updated = true; }
-          if (t.y > 1000) { newY = 0; updated = true; }
-
-          if (updated) {
-            world.update(entity, Transform, { x: newX, y: newY });
-          }
-        }
-
-        frameTimes.push(performance.now() - frameStart);
-      }
-
-      const avgFrameTime = frameTimes.reduce((a, b) => a + b, 0) / frameTimes.length;
-      const maxFrameTime = Math.max(...frameTimes);
-      const minFrameTime = Math.min(...frameTimes);
-      const fps = 1000 / avgFrameTime;
-      const fps60 = avgFrameTime < 16.67 ? "✅" : "❌";
-      const fps30 = avgFrameTime < 33.33 ? "✅" : "⚠️";
-
-      console.log(`${count.toLocaleString()} entities (25 components): ${avgFrameTime.toFixed(2)}ms avg (${fps.toFixed(0)} FPS)`);
-      console.log(`  60fps: ${fps60} | 30fps: ${fps30} | Min: ${minFrameTime.toFixed(2)}ms | Max: ${maxFrameTime.toFixed(2)}ms`);
-    }
-
-    expect(true).toBe(true);
-  }, { timeout: 30000 });
-
-  test("stress: query performance with many components", () => {
-    console.log("\n=== STRESS TEST: Query Performance (25 Components) ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: ALL_COMPONENTS,
-    });
-
-    // Setup 10,000 entities with all components
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: i, y: i, z: 0, rotation: 0, scale: 1 });
-      world.add(entity, Velocity, { vx: 1, vy: 1, vz: 0 });
-      world.add(entity, Health, { current: 100, max: 100 });
-      world.add(entity, Armor, { physical: 50, magical: 30 });
-      world.add(entity, Stats, { strength: 10, dexterity: 10, intelligence: 10, vitality: 10 });
-      world.add(entity, AI, { state: 0, targetId: 0, aggroRange: 100, chaseSpeed: 5 });
-      world.add(entity, Team, { id: i % 4, rank: 1 });
-    }
-
-    // Test queries with increasing component requirements
-    const queryTests = [
-      { components: [Transform], name: "1 component (Transform)" },
-      { components: [Transform, Velocity], name: "2 components (Transform, Velocity)" },
-      { components: [Transform, Velocity, Health], name: "3 components (Transform, Velocity, Health)" },
-      { components: [Transform, Velocity, Health, Armor], name: "4 components (+Armor)" },
-      { components: [Transform, Velocity, Health, Armor, Stats], name: "5 components (+Stats)" },
-      { components: [Transform, Velocity, Health, Armor, Stats, AI], name: "6 components (+AI)" },
-      { components: [Transform, Velocity, Health, Armor, Stats, AI, Team], name: "7 components (+Team)" },
-    ];
-
-    for (const { components, name } of queryTests) {
-      const start = performance.now();
-      const results = world.query(...components);
-      const time = performance.now() - start;
-
-      console.log(`Query ${name}: ${time.toFixed(3)}ms (${results.length} results)`);
-    }
-
-    expect(true).toBe(true);
-  }, { timeout: 30000 });
-
-  test("stress: memory usage with 25 components", () => {
-    console.log("\n=== STRESS TEST: Memory Usage (25 Components) ===");
-
-    const counts = [1000, 5000, 10000];
-
-    for (const count of counts) {
-      const world = new World({
-        maxEntities: count,
-        components: ALL_COMPONENTS,
-      });
-
-      // Add all components to all entities
-      for (let i = 0; i < count; i++) {
-        const entity = world.spawn();
-        world.add(entity, Transform, { x: 0, y: 0, z: 0, rotation: 0, scale: 1 });
-        world.add(entity, Velocity, { vx: 1, vy: 1, vz: 0 });
-        world.add(entity, Acceleration, { ax: 0, ay: 0, az: 0 });
-        world.add(entity, Health, { current: 100, max: 100 });
-        world.add(entity, Armor, { physical: 50, magical: 30 });
-        world.add(entity, Damage, { physical: 20, magical: 10, critical: 1.5 });
-        world.add(entity, Stats, { strength: 10, dexterity: 10, intelligence: 10, vitality: 10 });
-        world.add(entity, Inventory, { slot1: 0, slot2: 0, slot3: 0, slot4: 0, gold: 100 });
-        world.add(entity, Animation, { currentFrame: 0, totalFrames: 10, fps: 30, loop: 1 });
-        world.add(entity, Collider, { width: 32, height: 32, offsetX: 0, offsetY: 0 });
-        world.add(entity, Rigidbody, { mass: 1, drag: 0.1, angularDrag: 0.05, useGravity: 1 });
-        world.add(entity, AI, { state: 0, targetId: 0, aggroRange: 100, chaseSpeed: 5 });
-        world.add(entity, Cooldowns, { ability1: 0, ability2: 0, ability3: 0, ability4: 0 });
-        world.add(entity, Status, { stunned: 0, slowed: 0, poisoned: 0, burning: 0, frozen: 0, invulnerable: 0 });
-        world.add(entity, Team, { id: 1, rank: 1 });
-        world.add(entity, Experience, { current: 0, level: 1, toNextLevel: 100 });
-        world.add(entity, Lifetime, { remaining: 999, fadeOut: 0 });
-        world.add(entity, Parent, { entityId: 0 });
-        world.add(entity, Children, { count: 0, child1: 0, child2: 0, child3: 0, child4: 0 });
-        world.add(entity, Network, { ownerId: 0, lastSyncTime: 0, dirty: 0 });
-        world.add(entity, Sprite, { textureId: 1, tintR: 255, tintG: 255, tintB: 255, alpha: 255 });
-        world.add(entity, Audio, { soundId: 0, volume: 1.0, loop: 0, playing: 0 });
-        world.add(entity, Particle, { emissionRate: 10, lifetime: 2, speed: 5, size: 1 });
-        world.add(entity, Light, { intensity: 1, radius: 100, colorR: 255, colorG: 255, colorB: 255 });
-        world.add(entity, Camera, { fov: 60, near: 0.1, far: 1000, targetId: 0 });
-      }
-
-      // Calculate theoretical memory
-      const componentSizes = {
-        Transform: 20, // 5 f32
-        Velocity: 12, // 3 f32
-        Acceleration: 12, // 3 f32
-        Health: 4, // 2 u16
-        Armor: 4, // 2 u16
-        Damage: 8, // 2 u16 + 1 f32
-        Stats: 8, // 4 u16
-        Inventory: 20, // 5 u32
-        Animation: 6, // 2 u16 + 2 u8
-        Collider: 16, // 4 f32
-        Rigidbody: 13, // 3 f32 + 1 u8
-        AI: 13, // 1 u8 + 1 u32 + 2 f32
-        Cooldowns: 16, // 4 f32
-        Status: 6, // 6 u8
-        Team: 2, // 2 u8
-        Experience: 10, // 1 u32 + 1 u16 + 1 u32
-        Lifetime: 5, // 1 f32 + 1 u8
-        Parent: 4, // 1 u32
-        Children: 21, // 1 u8 + 5 u32
-        Network: 9, // 1 u32 + 1 f32 + 1 u8
-        Sprite: 9, // 1 u32 + 5 u8
-        Audio: 10, // 1 u32 + 1 f32 + 2 u8
-        Particle: 16, // 4 f32
-        Light: 11, // 2 f32 + 3 u8
-        Camera: 16, // 3 f32 + 1 u32
-      };
-
-      const totalComponentSize = Object.values(componentSizes).reduce((a, b) => a + b, 0);
-      const totalMemory = count * totalComponentSize;
-
-      console.log(`${count.toLocaleString()} entities: ${(totalMemory / 1024).toFixed(2)} KB (~${totalComponentSize} bytes/entity)`);
-    }
-
-    expect(true).toBe(true);
-  }, { timeout: 30000 });
-
-  test("stress: archetype changes with many components", () => {
-    console.log("\n=== STRESS TEST: Archetype Changes (25 Components) ===");
-
-    const world = new World({
-      maxEntities: 10000,
-      components: ALL_COMPONENTS,
-    });
-
-    // Create 10k entities with base components
-    const entities: number[] = [];
-    for (let i = 0; i < 10000; i++) {
-      const entity = world.spawn();
-      world.add(entity, Transform, { x: 0, y: 0, z: 0, rotation: 0, scale: 1 });
-      world.add(entity, Velocity, { vx: 1, vy: 1, vz: 0 });
-      entities.push(entity);
-    }
-
-    // Test adding/removing components (archetype changes)
-    const addStart = performance.now();
-    for (const entity of entities) {
-      world.add(entity, Health, { current: 100, max: 100 });
-      world.add(entity, Armor, { physical: 50, magical: 30 });
-      world.add(entity, Damage, { physical: 20, magical: 10, critical: 1.5 });
-    }
-    const addTime = performance.now() - addStart;
-
-    const removeStart = performance.now();
-    for (const entity of entities) {
-      world.remove(entity, Armor);
-      world.remove(entity, Damage);
-    }
-    const removeTime = performance.now() - removeStart;
-
-    console.log(`Add 3 components to 10k entities: ${addTime.toFixed(2)}ms`);
-    console.log(`Remove 2 components from 10k entities: ${removeTime.toFixed(2)}ms`);
-    console.log(`Total archetype change time: ${(addTime + removeTime).toFixed(2)}ms`);
-
-    expect(true).toBe(true);
-  }, { timeout: 30000 });
-});