test: fix type errors in test files with precise type assertions

Replace generic `as any` assertions with more precise types:
- Use `createComponentId()` for ComponentId type creation
- Use `Number()` conversion for numeric value assertions
- Use `EntityId<any>` for array element deallocate operations
- Use proper return type assertions for method calls
- Remove unused variable declarations to clean up unused imports

Author: codehz

src/__tests__/command-buffer-limits.test.ts

@@ -55,7 +55,6 @@ describe("CommandBuffer iteration limit", () => {
   it("should execute all commands within iteration limit", () => {
     const world = new World();
     const Value = component<{ num: number }>();
-    const Tag = component<void>();
 
     const entity = world.new();
 

src/__tests__/component-registry.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { ComponentIdAllocator } from "../core/entity-manager";
-import { COMPONENT_ID_MAX } from "../core/entity-types";
+import { COMPONENT_ID_MAX, createComponentId } from "../core/entity-types";
 
 describe("ComponentIdAllocator", () => {
   it("should allocate component IDs sequentially", () => {
@@ -10,9 +10,9 @@ describe("ComponentIdAllocator", () => {
     const id2 = allocator.allocate();
     const id3 = allocator.allocate();
 
-    expect(id1).toBe(1);
-    expect(id2).toBe(2);
-    expect(id3).toBe(3);
+    expect(id1).toBe(createComponentId(1));
+    expect(id2).toBe(createComponentId(2));
+    expect(id3).toBe(createComponentId(3));
   });
 
   it("should throw when exceeding COMPONENT_ID_MAX", () => {
@@ -57,7 +57,7 @@ describe("ComponentIdAllocator", () => {
 
     for (let i = 1; i <= COMPONENT_ID_MAX; i++) {
       const id = allocator.allocate();
-      expect(id).toBe(i);
+      expect(id).toBe(createComponentId(i));
     }
 
     // Should be exhausted now

src/__tests__/entity-id-manager.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { EntityIdManager } from "../core/entity-manager";
+import type { EntityId } from "../testing";
 
 describe("EntityIdManager", () => {
   it("should allocate entity IDs sequentially", () => {
@@ -10,9 +11,9 @@ describe("EntityIdManager", () => {
     const id3 = manager.allocate();
 
     // Entity IDs start at 1024
-    expect(id1).toBe(1024);
-    expect(id2).toBe(1025);
-    expect(id3).toBe(1026);
+    expect(Number(id1 as unknown as number)).toBe(1024);
+    expect(Number(id2 as unknown as number)).toBe(1025);
+    expect(Number(id3 as unknown as number)).toBe(1026);
   });
 
   it("should reuse freed entity IDs (LIFO)", () => {
@@ -57,9 +58,9 @@ describe("EntityIdManager", () => {
     expect(manager.getFreelistSize()).toBe(0);
 
     // Free every third ID
-    const toReuse: number[] = [];
+    const toReuse = [];
     for (let i = 0; i < allocated.length; i += 3) {
-      manager.deallocate(allocated[i]!);
+      manager.deallocate(allocated[i]! as EntityId<any>);
       toReuse.push(allocated[i]!);
     }
 
@@ -104,17 +105,19 @@ describe("EntityIdManager", () => {
 
   it("should throw when deallocating invalid entity ID", () => {
     const manager = new EntityIdManager();
-    const id = manager.allocate();
+    manager.allocate();
 
     // Deallocating negative ID or ID that was never allocated
-    expect(() => manager.deallocate(0 as any)).toThrow(/valid entity|deallocate/i);
+    expect(() => manager.deallocate(0 as unknown as ReturnType<typeof manager.allocate>)).toThrow(
+      /valid entity|deallocate/i,
+    );
   });
 
   it("should serialize and deserialize state", () => {
     const manager = new EntityIdManager();
 
     const id1 = manager.allocate();
-    const id2 = manager.allocate();
+    manager.allocate();
 
     manager.deallocate(id1);
 
@@ -138,7 +141,7 @@ describe("EntityIdManager", () => {
 
     const id1 = manager.allocate();
     const id2 = manager.allocate();
-    const id3 = manager.allocate();
+    manager.allocate();
 
     manager.deallocate(id1);
     manager.deallocate(id2);
@@ -149,6 +152,6 @@ describe("EntityIdManager", () => {
 
     // Next allocation should be a new ID
     const newId = manager.allocate();
-    expect(newId).toBe(id3 + 1);
+    expect(Number(newId as unknown as number)).toBe(1027);
   });
 });

src/__tests__/serialization-bounds.test.ts

@@ -11,7 +11,7 @@ describe("Serialization edge cases", () => {
     expect(snapshot.version).toBeDefined();
 
     const newWorld = new World(snapshot);
-    expect(newWorld.exists(-1)).toBe(false);
+    expect(newWorld.exists(-1 as unknown as ReturnType<typeof world.new>)).toBe(false);
   });
 
   it("should serialize and deserialize single entity", () => {

src/__tests__/testing.test.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from "bun:test";
-import { component, relation, type EntityId } from "../core/entity";
+import { component, relation, type ComponentId } from "../core/entity";
 import { World } from "../core/world";
 import {
   AssertionError,
@@ -15,11 +15,11 @@ type Position = { x: number; y: number };
 type Velocity = { x: number; y: number };
 type Health = { current: number; max: number };
 
-let PositionId: EntityId<Position>;
-let VelocityId: EntityId<Velocity>;
-let HealthId: EntityId<Health>;
-let TagId: EntityId<void>;
-let ParentId: EntityId<{ offset: { x: number; y: number } }>;
+let PositionId: ComponentId<Position>;
+let VelocityId: ComponentId<Velocity>;
+let HealthId: ComponentId<Health>;
+let TagId: ComponentId<void>;
+let ParentId: ComponentId<{ offset: { x: number; y: number } }>;
 
 describe("testing module", () => {
   beforeEach(() => {

src/__tests__/wildcard-relation.test.ts

@@ -52,7 +52,7 @@ describe("Wildcard relation edge cases", () => {
 
     // Verify structure
     for (const [target, data] of results) {
-      expect(targets).toContain(target);
+      expect(targets).toContain(target as any);
       expect(data.strength).toBeGreaterThanOrEqual(0);
       expect(data.strength).toBeLessThan(100);
     }

src/__tests__/world-component-management.test.ts

@@ -1,13 +1,13 @@
 import { beforeEach, describe, expect, it } from "bun:test";
-import { component, createEntityId, relation, type EntityId } from "../core/entity";
+import { component, createEntityId, relation, type ComponentId, type EntityId } from "../core/entity";
 import { World } from "../core/world";
 
 describe("World - Component Management", () => {
   type Position = { x: number; y: number };
   type Velocity = { x: number; y: number };
 
-  let positionComponent: EntityId<Position>;
-  let velocityComponent: EntityId<Velocity>;
+  let positionComponent: ComponentId<Position>;
+  let velocityComponent: ComponentId<Velocity>;
 
   beforeEach(() => {
     positionComponent = component<Position>();