@codehz/ecs 0.8.1 → 0.9.0

package/src/__tests__/perf/comprehensive.perf.test.ts

@@ -117,7 +117,7 @@ describe("Comprehensive ECS performance benchmarks", () => {
     }
     world.sync();
 
-    const movementQuery = world.createQuery([Position, Velocity]);
+    using movementQuery = world.createQuery([Position, Velocity]);
 
     // Pure iteration (no writes)
     const readAvg = benchmark("10k entities: forEach read-only query", 2, 6, () => {
@@ -137,8 +137,6 @@ describe("Comprehensive ECS performance benchmarks", () => {
       });
     });
 
-    movementQuery.dispose();
-
     console.log(`Sum X (to prevent optimization): ${sumX}`);
     expect(readAvg).toBeLessThan(20);
     expect(updateAvg).toBeLessThan(20);
@@ -195,7 +193,7 @@ describe("Comprehensive ECS performance benchmarks", () => {
     }
     world.sync();
 
-    const movementQuery = world.createQuery([Position, Health]);
+    using movementQuery = world.createQuery([Position, Health]);
 
     const mixedAvg = benchmark("2k entities: mixed ops (update 90%, spawn 5%, delete 5%) + sync", 2, 6, (round) => {
       const deleteCount = Math.floor(entities.length * 0.05);
@@ -226,7 +224,6 @@ describe("Comprehensive ECS performance benchmarks", () => {
       world.sync();
     });
 
-    movementQuery.dispose();
     expect(mixedAvg).toBeLessThan(300);
   });
 
@@ -265,12 +262,12 @@ describe("Comprehensive ECS performance benchmarks", () => {
   });
 
   /**
-   * Benchmark 7: dontFragment relation updates (the existing benchmark scenario)
+   * Benchmark 7: sparse relation updates
    */
-  it("should handle dontFragment exclusive relation flips efficiently", () => {
+  it("should handle exclusive sparse relation flips efficiently", () => {
     const world = new World();
     const Position = component<{ x: number; y: number }>();
-    const ChildOf = component({ dontFragment: true, exclusive: true });
+    const ChildOf = component({ sparse: true, exclusive: true });
 
     const parentA = world.new();
     const parentB = world.new();
@@ -285,7 +282,7 @@ describe("Comprehensive ECS performance benchmarks", () => {
     }
     world.sync();
 
-    const relationFlipAvg = benchmark("4k entities: exclusive dontFragment relation flip + sync", 2, 8, (round) => {
+    const relationFlipAvg = benchmark("4k entities: exclusive sparse relation flip + sync", 2, 8, (round) => {
       const target = round % 2 === 0 ? parentB : parentA;
       for (let i = 0; i < entities.length; i++) {
         world.set(entities[i]!, relation(ChildOf, target));

package/src/__tests__/perf/serialization.perf.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, it } from "bun:test";
+import { component, relation, type EntityId } from "../../entity";
+import { World } from "../../world/world";
+
+function benchmark(label: string, warmupRounds: number, measuredRounds: number, fn: (round: number) => void): number {
+  const durations: number[] = [];
+
+  const totalRounds = warmupRounds + measuredRounds;
+  for (let round = 0; round < totalRounds; round++) {
+    const start = performance.now();
+    fn(round);
+    const duration = performance.now() - start;
+    if (round >= warmupRounds) {
+      durations.push(duration);
+    }
+  }
+
+  const average = durations.reduce((sum, duration) => sum + duration, 0) / durations.length;
+  console.log(
+    `${label}: avg ${average.toFixed(2)}ms after ${warmupRounds} warmup rounds (${durations
+      .map((d) => d.toFixed(2))
+      .join("ms, ")}ms per measured round)`,
+  );
+  return average;
+}
+
+/**
+ * Serialization performance benchmarks.
+ *
+ * These benchmarks validate the post-optimization serialization path
+ * (see optimization plan for src/world/serialization.ts):
+ *
+ * Key optimizations exercised:
+ * - Column-oriented direct export from Archetype (bypasses per-entity Map + dump())
+ * - Per-archetype pre-encoding of component type IDs
+ * - ID encoding cache (encodeEntityIdCached) for repeated component/relation IDs
+ * - Removal of redundant per-entity work in deserialization
+ *
+ * Target scale: 8k–12k entities across multiple archetypes + relations.
+ * This is large enough to show meaningful differences while keeping test runtime reasonable.
+ */
+describe("Serialization performance (post-optimization baseline)", () => {
+  it("should serialize and deserialize large mixed worlds efficiently", () => {
+    const world = new World();
+
+    // Named components (realistic serialization path with name lookup)
+    const Position = component<{ x: number; y: number }>("Position");
+    const Velocity = component<{ vx: number; vy: number }>("Velocity");
+    const Health = component<{ hp: number; maxHp: number }>("Health");
+    const Name = component<{ value: string }>("Name");
+    const Inventory = component<{ items: string[] }>("Inventory");
+
+    // Entity-valued component (creates entity references)
+    const Target = component<{ entity: EntityId }>("Target");
+
+    // Relations
+    const ChildOf = component<void>("ChildOf");
+
+    const entityCount = 12_000;
+    const entities: EntityId[] = [];
+
+    // Distribute entities across several archetypes for realistic archetype diversity
+    // Archetype A: Position + Velocity + Health
+    // Archetype B: Position + Name + Inventory
+    // Archetype C: Position + Velocity + Target (entity-valued component)
+    // Archetype D: Position only (minimal)
+
+    const parents: EntityId[] = [];
+
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+
+      const archetypeKind = i % 4;
+
+      world.set(entity, Position, { x: i, y: i * 2 });
+
+      if (archetypeKind === 0) {
+        // Archetype A
+        world.set(entity, Velocity, { vx: 1, vy: 0.5 });
+        world.set(entity, Health, { hp: 100, maxHp: 100 });
+      } else if (archetypeKind === 1) {
+        // Archetype B
+        world.set(entity, Name, { value: `Entity-${i}` });
+        world.set(entity, Inventory, { items: ["sword", "potion"] });
+      } else if (archetypeKind === 2) {
+        // Archetype C — has entity reference
+        world.set(entity, Velocity, { vx: 0.2, vy: -1 });
+        // Point to a previous entity (creates realistic entity-valued component)
+        const targetIdx = Math.max(0, i - 7);
+        world.set(entity, Target, { entity: entities[targetIdx]! });
+      } else {
+        // Archetype D — minimal
+        // Only Position
+      }
+
+      // Every 17th entity becomes a parent and gets some children via relations
+      if (i % 17 === 0) {
+        parents.push(entity);
+      }
+    }
+
+    // Add relations (ChildOf) — creates entity-relation IDs that must be encoded
+    for (let i = 0; i < entityCount; i++) {
+      const parentIdx = Math.floor(i / 8) % Math.max(1, parents.length);
+      const parent = parents[parentIdx] ?? entities[0]!;
+      if (parent !== entities[i]) {
+        world.set(entities[i]!, relation(ChildOf, parent));
+      }
+    }
+
+    world.sync();
+
+    expect(entities.length).toBe(entityCount);
+
+    const warmup = 2;
+    const measured = 5;
+
+    // === Serialize ===
+    let lastSnapshot: ReturnType<World["serialize"]> | null = null;
+
+    const serializeAvg = benchmark(
+      `serialize ${entityCount} entities (mixed archetypes + relations)`,
+      warmup,
+      measured,
+      () => {
+        lastSnapshot = world.serialize();
+      },
+    );
+
+    expect(lastSnapshot).toBeDefined();
+    expect(lastSnapshot!.entities.length).toBeGreaterThanOrEqual(entityCount * 0.9); // rough sanity
+
+    // Measure rough heap impact of a serialize call.
+    // Note: Bun may require --smol or explicit GC for more stable allocation numbers.
+    if (typeof Bun !== "undefined" && Bun.gc) {
+      Bun.gc(true);
+    }
+    const memBefore = process.memoryUsage();
+    void world.serialize();
+    const memAfter = process.memoryUsage();
+    const heapDeltaMB = ((memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024).toFixed(2);
+    console.log(
+      `serialize heap delta (one call): ~${heapDeltaMB} MB (rss delta: ${((memAfter.rss - memBefore.rss) / 1024 / 1024).toFixed(2)} MB)`,
+    );
+
+    // === Deserialize (new World from snapshot) ===
+    const deserializeAvg = benchmark(
+      `deserialize ${entityCount} entities (new World(snapshot))`,
+      warmup,
+      measured,
+      () => {
+        // We create and immediately let go of the world to measure allocation + construction cost
+        const restored = new World(lastSnapshot!);
+        // Touch one value to prevent dead-code elimination in theory
+        if (restored.exists(entities[0]!)) {
+          void restored.get(entities[0]!, Position);
+        }
+      },
+    );
+
+    // === Full JSON roundtrip (very common user pattern) ===
+    const jsonRoundtripAvg = benchmark(
+      `full JSON roundtrip (stringify + parse + new World) — ${entityCount} entities`,
+      warmup,
+      measured,
+      () => {
+        const json = JSON.stringify(world.serialize());
+        const parsed = JSON.parse(json);
+        const restored = new World(parsed);
+        if (restored.exists(entities[42]!)) {
+          void restored.get(entities[42]!, Position);
+        }
+      },
+    );
+
+    // Loose upper bounds — these act as regression guards.
+    // The numbers are intentionally generous to account for CI machine variance.
+    // The main value is the detailed console output for manual before/after comparison.
+    expect(serializeAvg).toBeLessThan(80); // ~12k entities serialize
+    expect(deserializeAvg).toBeLessThan(120); // new World(snapshot) tends to be heavier
+    expect(jsonRoundtripAvg).toBeLessThan(200); // includes JSON + full deserialize
+
+    // Final sanity: the last deserialized world should still have most entities
+    const finalRestored = new World(lastSnapshot!);
+    expect(finalRestored.exists(entities[0]!)).toBe(true);
+    expect(finalRestored.exists(entities[entityCount - 1]!)).toBe(true);
+  });
+
+  it("should handle worlds with heavy entity-relation usage", () => {
+    const world = new World();
+
+    const Position = component<{ x: number; y: number }>("Pos");
+    const Owes = component<{ amount: number }>("Owes"); // used for relations
+
+    const entityCount = 8_000;
+    const entities: EntityId[] = [];
+
+    for (let i = 0; i < entityCount; i++) {
+      const e = world.new();
+      entities.push(e);
+      world.set(e, Position, { x: i, y: i });
+    }
+
+    // Create a dense web of entity-relations (every entity owes 3 others)
+    for (let i = 0; i < entityCount; i++) {
+      for (let j = 1; j <= 3; j++) {
+        const target = entities[(i + j * 17) % entityCount]!;
+        if (target !== entities[i]) {
+          world.set(entities[i]!, relation(Owes, target), { amount: (i + j) % 100 });
+        }
+      }
+    }
+
+    world.sync();
+
+    const warmup = 1;
+    const measured = 4;
+
+    const serializeAvg = benchmark(
+      `serialize ${entityCount} entities (dense entity-relations)`,
+      warmup,
+      measured,
+      () => {
+        void world.serialize();
+      },
+    );
+
+    // Deserialize with many relations exercises decode + reference tracking
+    let snapshot: ReturnType<World["serialize"]> | undefined;
+
+    const deserializeAvg = benchmark(`deserialize ${entityCount} entities (dense relations)`, warmup, measured, () => {
+      if (!snapshot) snapshot = world.serialize();
+      const w = new World(snapshot);
+      void w;
+    });
+
+    // Very loose bounds — this scenario is intentionally expensive
+    expect(serializeAvg).toBeLessThan(150);
+    expect(deserializeAvg).toBeLessThan(220);
+  });
+});

package/src/__tests__/perf/{dontfragment-wildcard.perf.test.ts → sparse-wildcard.perf.test.ts}

@@ -3,10 +3,10 @@ import { component, relation, type EntityId } from "../../entity";
 import { World } from "../../world/world";
 
 /**
- * Focused performance tests for the refactored DontFragmentStore.
+ * Focused performance tests for sparse relation storage.
  *
- * These tests specifically exercise the X-class paths that motivated the refactor:
- * - Wildcard queries over dontFragment relations (relation(Comp, "*"))
+ * These tests specifically exercise the hot paths:
+ * - Wildcard queries over sparse relations (relation(Comp, "*"))
  * - Frequent exclusive relation flips (the classic ChildOf pattern)
  * - hasRelationWithComponentId / archetype filtering cost
  */
@@ -31,11 +31,11 @@ function benchmark(label: string, warmupRounds: number, measuredRounds: number,
   return average;
 }
 
-describe("DontFragment + Wildcard Performance (post-refactor)", () => {
-  it("should handle large numbers of entities with exclusive dontFragment + wildcard queries efficiently", () => {
+describe("Sparse + Wildcard Performance", () => {
+  it("should handle large numbers of entities with exclusive sparse relations + wildcard queries efficiently", () => {
     const world = new World();
     const Position = component<{ x: number; y: number }>();
-    const ChildOf = component({ dontFragment: true, exclusive: true });
+    const ChildOf = component({ sparse: true, exclusive: true });
 
     const parentCount = 20;
     const parents: EntityId[] = [];
@@ -56,9 +56,9 @@ describe("DontFragment + Wildcard Performance (post-refactor)", () => {
     world.sync();
 
     const wildcard = relation(ChildOf, "*");
-    const q = world.createQuery([Position, wildcard]);
+    using q = world.createQuery([Position, wildcard]);
 
-    const avg = benchmark("10k entities: wildcard query over exclusive dontFragment", 2, 6, () => {
+    const avg = benchmark("10k entities: wildcard query over exclusive sparse relations", 2, 6, () => {
       let count = 0;
       q.forEach([Position, wildcard], (_entity, _pos, rels) => {
         count += rels.length; // force materialization
@@ -66,16 +66,13 @@ describe("DontFragment + Wildcard Performance (post-refactor)", () => {
       expect(count).toBeGreaterThan(0);
     });
 
-    q.dispose();
-
-    // These numbers will be tuned after the implementation stabilizes.
-    // The goal is to verify we did not regress the hot wildcard + dontFragment path.
-    expect(avg).toBeLessThan(50); // generous upper bound post-refactor
+    // The goal is to verify we did not regress the hot wildcard + sparse storage path.
+    expect(avg).toBeLessThan(50); // generous upper bound
   });
 
-  it("should support frequent exclusive dontFragment flips without leaking relations", () => {
+  it("should support frequent exclusive sparse relation flips without leaking relations", () => {
     const world = new World();
-    const ChildOf = component({ dontFragment: true, exclusive: true });
+    const ChildOf = component({ sparse: true, exclusive: true });
 
     const parentA = world.new();
     const parentB = world.new();
@@ -90,7 +87,7 @@ describe("DontFragment + Wildcard Performance (post-refactor)", () => {
     world.sync();
 
     // Flip many times
-    const flipAvg = benchmark("2k entities: exclusive dontFragment flip (100 rounds)", 1, 3, (round) => {
+    const flipAvg = benchmark("2k entities: exclusive sparse relation flip (100 rounds)", 1, 3, (round) => {
       const target = round % 2 === 0 ? parentB : parentA;
       for (const e of entities) {
         world.set(e, relation(ChildOf, target));

package/src/__tests__/query/caching.test.ts

@@ -109,4 +109,66 @@ describe("Query", () => {
       expect(query1).not.toBe(query3);
     });
   });
+
+  describe("Query disposal and archetype removal notification", () => {
+    type Pos = { x: number };
+    const PosC = component<Pos>();
+
+    it("should support dispose and disposed flag, and release via registry refcount", () => {
+      const world = new World();
+      const q1 = world.createQuery([PosC]);
+      expect(q1.disposed).toBe(false);
+
+      q1.dispose();
+      // After dispose, further use may be no-op but flag set when ref hits 0
+      // Note: createQuery reuses, so need unique to drop ref
+    });
+
+    it("should trigger removeArchetype on query when archetypes are cleaned up", () => {
+      const world = new World();
+      const q = world.createQuery([PosC]);
+
+      // Spawn then delete all of archetype to trigger cleanup
+      const e1 = world.spawn().with(PosC, { x: 1 }).build();
+      const e2 = world.spawn().with(PosC, { x: 2 }).build();
+      world.sync();
+
+      expect(q.getEntities().length).toBe(2);
+
+      world.delete(e1);
+      world.delete(e2);
+      world.sync();
+
+      // Archetype should be removed, query notified (no crash, internal removeArchetype called)
+      expect(q.getEntities().length).toBe(0);
+
+      // Also test Symbol.dispose via fixture or direct (dispose marks)
+      q.dispose();
+      expect(q.disposed).toBe(true);
+    });
+
+    it("should directly cover Query removeArchetype and dispose internal branches", () => {
+      const world = new World();
+      const q = world.createQuery([PosC]);
+      // Force an archetype in cache then remove it (covers splice path)
+      const dummy: any = {};
+      (q as any).cachedArchetypes.push(dummy);
+      (q as any).removeArchetype(dummy);
+      expect((q as any).cachedArchetypes).not.toContain(dummy);
+
+      // cover disposed early return
+      (q as any).isDisposed = true;
+      (q as any).removeArchetype({} as any); // no-op
+      (q as any).checkNewArchetype({} as any); // no-op
+
+      // cover _disposeInternal again
+      (q as any)._disposeInternal();
+
+      // cover disposed getter (line ~310)
+      void (q as any).disposed;
+
+      // cover Symbol.dispose method
+      (q as any)[Symbol.dispose]();
+    });
+  });
 });

package/src/__tests__/query/filter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { Archetype } from "../../archetype/archetype";
-import { DontFragmentStoreImpl } from "../../archetype/store";
+import { SparseStoreImpl } from "../../archetype/store";
 import type { ComponentId, EntityId } from "../../entity";
 import { relation } from "../../entity";
 import { matchesComponentTypes, matchesFilter, type QueryFilter } from "../../query/filter";
@@ -11,34 +11,31 @@ const velocityComponent = 2 as ComponentId<{ dx: number; dy: number }>;
 const healthComponent = 3 as ComponentId<{ value: number }>;
 const relationComponent = 4 as ComponentId<{ strength: number }>;
 
-// Helper function to create a real DontFragmentStore for testing.
-const createDontFragmentRelations = () => new DontFragmentStoreImpl();
+// Helper function to create a real SparseStore for testing.
+const createSparseStore = () => new SparseStoreImpl();
 
 describe("Query Filter Functions", () => {
   describe("matchesComponentTypes", () => {
     it("should return true when archetype contains all required component types", () => {
-      const archetype = new Archetype([positionComponent, velocityComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, velocityComponent], createSparseStore());
       const componentTypes = [positionComponent, velocityComponent];
       expect(matchesComponentTypes(archetype, componentTypes)).toBe(true);
     });
 
     it("should return true when archetype contains required component types and more", () => {
-      const archetype = new Archetype(
-        [positionComponent, velocityComponent, healthComponent],
-        createDontFragmentRelations(),
-      );
+      const archetype = new Archetype([positionComponent, velocityComponent, healthComponent], createSparseStore());
       const componentTypes = [positionComponent, velocityComponent];
       expect(matchesComponentTypes(archetype, componentTypes)).toBe(true);
     });
 
     it("should return false when archetype is missing a required component type", () => {
-      const archetype = new Archetype([positionComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent], createSparseStore());
       const componentTypes = [positionComponent, velocityComponent];
       expect(matchesComponentTypes(archetype, componentTypes)).toBe(false);
     });
 
     it("should return true for empty component types array", () => {
-      const archetype = new Archetype([positionComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent], createSparseStore());
       const componentTypes: EntityId<any>[] = [];
       expect(matchesComponentTypes(archetype, componentTypes)).toBe(true);
     });
@@ -46,41 +43,38 @@ describe("Query Filter Functions", () => {
 
   describe("matchesFilter", () => {
     it("should return true when no negative component types are specified", () => {
-      const archetype = new Archetype([positionComponent, velocityComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, velocityComponent], createSparseStore());
       const filter: QueryFilter = {};
       expect(matchesFilter(archetype, filter)).toBe(true);
     });
 
     it("should return true when archetype does not contain any negative component types", () => {
-      const archetype = new Archetype([positionComponent, velocityComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, velocityComponent], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [healthComponent] };
       expect(matchesFilter(archetype, filter)).toBe(true);
     });
 
     it("should return false when archetype contains a negative component type", () => {
-      const archetype = new Archetype(
-        [positionComponent, velocityComponent, healthComponent],
-        createDontFragmentRelations(),
-      );
+      const archetype = new Archetype([positionComponent, velocityComponent, healthComponent], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [healthComponent] };
       expect(matchesFilter(archetype, filter)).toBe(false);
     });
 
     it("should return false when archetype contains any of multiple negative component types", () => {
-      const archetype = new Archetype([positionComponent, healthComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, healthComponent], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [velocityComponent, healthComponent] };
       expect(matchesFilter(archetype, filter)).toBe(false);
     });
 
     it("should return true when archetype contains none of multiple negative component types", () => {
-      const archetype = new Archetype([positionComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [velocityComponent, healthComponent] };
       expect(matchesFilter(archetype, filter)).toBe(true);
     });
 
     it("should return false when archetype contains a negative wildcard relation component", () => {
       const wildcardRelation = relation(relationComponent, "*");
-      const archetype = new Archetype([positionComponent, wildcardRelation], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, wildcardRelation], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [wildcardRelation] };
       expect(matchesFilter(archetype, filter)).toBe(false);
     });
@@ -88,7 +82,7 @@ describe("Query Filter Functions", () => {
     it("should return false when archetype contains a specific relation matching negative wildcard filter", () => {
       const wildcardRelation = relation(relationComponent, "*");
       const otherRelation = relation(relationComponent, 1025 as EntityId);
-      const archetype = new Archetype([positionComponent, otherRelation], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, otherRelation], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [wildcardRelation] };
       expect(matchesFilter(archetype, filter)).toBe(false);
     });
@@ -96,7 +90,7 @@ describe("Query Filter Functions", () => {
     it("should return true when archetype does not contain any relations with the wildcard component", () => {
       const wildcardRelation = relation(relationComponent, "*");
       const otherComponent = 5 as EntityId<{ other: number }>;
-      const archetype = new Archetype([positionComponent, otherComponent], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, otherComponent], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [wildcardRelation] };
       expect(matchesFilter(archetype, filter)).toBe(true);
     });
@@ -104,7 +98,7 @@ describe("Query Filter Functions", () => {
     it("should return false when archetype contains wildcard relation matching negative filter", () => {
       const wildcardRelation = relation(relationComponent, "*");
       const matchingRelation = relation(relationComponent, 1026 as EntityId);
-      const archetype = new Archetype([positionComponent, matchingRelation], createDontFragmentRelations());
+      const archetype = new Archetype([positionComponent, matchingRelation], createSparseStore());
       const filter: QueryFilter = { negativeComponentTypes: [wildcardRelation] };
       expect(matchesFilter(archetype, filter)).toBe(false);
     });

package/src/__tests__/query/perf.test.ts

@@ -51,8 +51,8 @@ function performanceTest() {
   console.log(`Entity creation time: ${(endCreate - startCreate).toFixed(2)}ms`);
 
   // Create queries
-  const positionVelocityQuery = world.createQuery([positionComponent, velocityComponent]);
-  const healthQuery = world.createQuery([healthComponent]);
+  using positionVelocityQuery = world.createQuery([positionComponent, velocityComponent]);
+  using _healthQuery = world.createQuery([healthComponent]);
 
   // Test getEntitiesWithComponents performance
   console.log("\nTesting getEntitiesWithComponents performance...");
@@ -89,9 +89,7 @@ function performanceTest() {
   });
   console.log(`forEach iterated over ${forEachCount} entities`);
 
-  // Cleanup
-  positionVelocityQuery.dispose();
-  healthQuery.dispose();
+  // Cleanup handled by using declarations for positionVelocityQuery / healthQuery
 
   console.log("\nPerformance test completed!");
 }