@codehz/ecs 0.7.2 → 0.7.4

package/examples/state-machine.ts

@@ -0,0 +1,273 @@
+import { pipeline } from "@codehz/pipeline";
+import { World, component, type Query } from "../src";
+
+// ── Component Type Definitions ───────────────────────────────────────────────
+
+type State = { current: "idle" | "patrol" | "flee"; timer: number };
+type Health = { value: number; maxValue: number };
+type Speed = { value: number };
+type Target = { x: number; y: number };
+type Position = { x: number; y: number };
+
+// Void component: presence of this marks an entity as AI-controlled
+type AIEnabled = void;
+
+// ── Component ID Registration ────────────────────────────────────────────────
+
+const State = component<State>({ name: "State" });
+const Health = component<Health>({ name: "Health" });
+const Speed = component<Speed>({ name: "Speed" });
+const Target = component<Target>({ name: "Target" });
+const Position = component<Position>({ name: "Position" });
+const AIEnabled = component<AIEnabled>({ name: "AIEnabled" });
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function distance(a: Position, b: Target): number {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+function randomTarget(): Target {
+  return {
+    x: Math.round((Math.random() * 20 - 10) * 100) / 100,
+    y: Math.round((Math.random() * 20 - 10) * 100) / 100,
+  };
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+function main() {
+  console.log("ECS State Machine & AI Demo - Lifecycle Hooks");
+  console.log("=============================================\n");
+
+  const world = new World();
+
+  // ── Queries (pre-cached for performance) ─────────────────────────────────
+
+  const aiQuery: Query = world.createQuery([State, Position, Speed, Target, AIEnabled]);
+  const healthQuery: Query = world.createQuery([Health]);
+
+  // ── Lifecycle Hooks ──────────────────────────────────────────────────────
+
+  // Log health changes
+  const unsubHealth = world.hook([Health], (type, entityId, health) => {
+    const marker = type === "init" ? "[INIT]" : type === "set" ? "[SET]" : "[REMOVE]";
+    console.log(`  ${marker} Health | entity=${entityId} | value=${health.value.toFixed(1)}/${health.maxValue}`);
+  });
+
+  // Log state transitions
+  const unsubState = world.hook([State], (type, entityId, state) => {
+    const marker = type === "init" ? "[INIT]" : type === "set" ? "[SET]" : "[REMOVE]";
+    console.log(`  ${marker} State  | entity=${entityId} | current=${state.current} | timer=${state.timer.toFixed(2)}`);
+  });
+
+  // ── Pass 1: AI State Machine ────────────────────────────────────────────
+
+  const aiStatePass = (env: { deltaTime: number }) => {
+    const dt = env.deltaTime;
+
+    aiQuery.forEach([State, Position, Speed, Target], (entity, state, position, speed, target) => {
+      switch (state.current) {
+        case "idle": {
+          state.timer -= dt;
+          if (state.timer <= 0) {
+            // Switch to patrol with a fresh random target
+            state.current = "patrol";
+            state.timer = 0;
+            const newTarget = randomTarget();
+            world.set(entity, Target, newTarget);
+            console.log(`  [AI] Entity ${entity}: idle → patrol | new target (${newTarget.x}, ${newTarget.y})`);
+          }
+          break;
+        }
+
+        case "patrol": {
+          const dist = distance(position, target);
+          const moveSpeed = speed.value * dt;
+
+          if (dist <= moveSpeed) {
+            // Arrived at target → switch back to idle
+            position.x = target.x;
+            position.y = target.y;
+            world.set(entity, Position, { x: position.x, y: position.y });
+            state.current = "idle";
+            state.timer = 1.0 + Math.random() * 2.0; // idle for 1–3 seconds
+            console.log(
+              `  [AI] Entity ${entity}: patrol → idle | arrived at (${target.x}, ${target.y}) | idle ${state.timer.toFixed(2)}s`,
+            );
+          } else {
+            // Move toward target
+            const dx = (target.x - position.x) / dist;
+            const dy = (target.y - position.y) / dist;
+            position.x += dx * moveSpeed;
+            position.y += dy * moveSpeed;
+            world.set(entity, Position, { x: position.x, y: position.y });
+          }
+          break;
+        }
+
+        case "flee": {
+          // Move away from target at 2x speed (panicked retreat)
+          const dist = distance(position, target);
+          const fleeSpeed = speed.value * 2.0 * dt;
+
+          if (dist > 0.001) {
+            const dx = (position.x - target.x) / dist;
+            const dy = (position.y - target.y) / dist;
+            position.x += dx * fleeSpeed;
+            position.y += dy * fleeSpeed;
+          } else {
+            // Exactly on target — pick arbitrary direction
+            position.x += fleeSpeed;
+          }
+          world.set(entity, Position, { x: position.x, y: position.y });
+
+          state.timer += dt;
+          // Flee for at least 3 seconds, then try going back to idle
+          if (state.timer >= 3.0) {
+            state.current = "idle";
+            state.timer = 1.0;
+            console.log(`  [AI] Entity ${entity}: flee → idle | recovered after ${state.timer.toFixed(2)}s`);
+          }
+          break;
+        }
+      }
+
+      // Commit state changes (timer always updates)
+      world.set(entity, State, { current: state.current, timer: state.timer });
+    });
+  };
+
+  // ── Pass 2: Health Check → Trigger Flee ─────────────────────────────────
+
+  const healthCheckPass = () => {
+    healthQuery.forEach([Health], (entity, health) => {
+      if (health.value < health.maxValue * 0.3) {
+        // Entity is low-health; switch to flee
+        const state = world.get(entity, State);
+        if (state && state.current !== "flee") {
+          console.log(`  [HealthCheck] Entity ${entity}: health ${health.value.toFixed(1)} < 30% → switching to flee`);
+          world.set(entity, State, { current: "flee", timer: 0 });
+        }
+      }
+    });
+  };
+
+  // ── Pass 3: Status Log ──────────────────────────────────────────────────
+
+  const statusLogPass = () => {
+    console.log("  --- Status ---");
+    aiQuery.forEach([State, Position, Health], (entity, state, position, health) => {
+      // Health is optional for AI entities (some may not have it)
+      const hp = health ? `${health.value.toFixed(1)}/${health.maxValue}` : "N/A";
+      console.log(
+        `  Entity ${entity}: state=${state.current} | pos=(${position.x.toFixed(2)}, ${position.y.toFixed(2)}) | hp=${hp}`,
+      );
+    });
+    console.log("");
+  };
+
+  // ── Pass 4: Sync ────────────────────────────────────────────────────────
+
+  const syncPass = () => {
+    world.sync();
+  };
+
+  // ── Build Pipeline ──────────────────────────────────────────────────────
+
+  const gameLoop = pipeline<{ deltaTime: number }>()
+    .addPass(aiStatePass)
+    .addPass(healthCheckPass)
+    .addPass(statusLogPass)
+    .addPass(syncPass)
+    .build();
+
+  // ── Setup Entities ──────────────────────────────────────────────────────
+
+  // Entity 1: Starts in "idle", healthy
+  const e1 = world
+    .spawn()
+    .with(State, { current: "idle", timer: 0.5 })
+    .with(Position, { x: 0, y: 0 })
+    .with(Speed, { value: 3.0 })
+    .with(Target, { x: 0, y: 0 })
+    .with(Health, { value: 100, maxValue: 100 })
+    .with(AIEnabled)
+    .build();
+
+  // Entity 2: Starts in "patrol", already moving toward a target
+  const e2 = world
+    .spawn()
+    .with(State, { current: "patrol", timer: 0 })
+    .with(Position, { x: 10, y: 0 })
+    .with(Speed, { value: 5.0 })
+    .with(Target, { x: 10, y: 10 })
+    .with(Health, { value: 40, maxValue: 100 }) // will drop below 30% soon
+    .with(AIEnabled)
+    .build();
+
+  // Entity 3: Starts in "idle", somewhat wounded
+  const e3 = world
+    .spawn()
+    .with(State, { current: "idle", timer: 1.0 })
+    .with(Position, { x: -5, y: 5 })
+    .with(Speed, { value: 2.0 })
+    .with(Target, { x: -5, y: 5 })
+    .with(Health, { value: 25, maxValue: 100 }) // already below 30%
+    .with(AIEnabled)
+    .build();
+
+  // Initial sync — applies all buffered commands and fires "init" hooks
+  console.log("--- Initial Sync (init hooks fire) ---\n");
+  world.sync();
+
+  // ── Run Frames ──────────────────────────────────────────────────────────
+
+  console.log("\n=== Frame 1 (dt=1.0) ===");
+  gameLoop({ deltaTime: 1.0 });
+
+  console.log("=== Frame 2 (dt=1.0) ===");
+  gameLoop({ deltaTime: 1.0 });
+
+  console.log("=== Frame 3 (dt=1.0) ===");
+  // Deplete entity 2's health to trigger flee
+  {
+    const h2 = world.get(e2, Health);
+    world.set(e2, Health, { value: h2.value - 20, maxValue: h2.maxValue });
+    const h3 = world.get(e3, Health);
+    world.set(e3, Health, { value: h3.value - 5, maxValue: h3.maxValue });
+  }
+  gameLoop({ deltaTime: 1.0 });
+
+  console.log("=== Frame 4 (dt=1.0) ===");
+  // Further deplete entity 1 to get it low too
+  {
+    const h1 = world.get(e1, Health);
+    world.set(e1, Health, { value: h1.value - 40, maxValue: h1.maxValue });
+  }
+  gameLoop({ deltaTime: 1.0 });
+
+  console.log("=== Frame 5 (dt=1.0) ===");
+  // Entity 1 now gets very low
+  {
+    const h1 = world.get(e1, Health);
+    world.set(e1, Health, { value: h1.value - 40, maxValue: h1.maxValue });
+  }
+  gameLoop({ deltaTime: 1.0 });
+
+  console.log("=== Frame 6 (dt=1.0) ===");
+  gameLoop({ deltaTime: 1.0 });
+
+  // ── Cleanup ─────────────────────────────────────────────────────────────
+
+  unsubHealth();
+  unsubState();
+
+  console.log("Demo completed!");
+}
+
+// ── Entry Point ──────────────────────────────────────────────────────────────
+
+main();

package/examples/tag-filtering.ts

@@ -0,0 +1,266 @@
+import { pipeline } from "@codehz/pipeline";
+import { World, component, type EntityId, type Query } from "../src";
+
+// =============================================================================
+// Component type definitions
+// =============================================================================
+type Position = { x: number; y: number };
+type Health = { value: number };
+type Damage = { value: number };
+type Team = { id: number }; // 1 = ally, 2 = enemy
+
+// =============================================================================
+// Component IDs — void components (tags) use component() with no type arg
+// =============================================================================
+const Position = component<Position>({ name: "Position" });
+const Health = component<Health>({ name: "Health" });
+const Damage = component<Damage>({ name: "Damage" });
+const Team = component<Team>({ name: "Team" });
+const Alive = component({ name: "Alive" }); // void tag — living entities
+const Stunned = component({ name: "Stunned" }); // void tag — CC'd entities
+const Invisible = component({ name: "Invisible" }); // void tag — stealthed entities
+
+// =============================================================================
+// World & pre-cached queries
+// =============================================================================
+const world = new World();
+
+// livingAllies: [Position, Health, Team] — allies that are alive but NOT stunned
+const livingAllies: Query = world.createQuery([Position, Health, Team], {
+  negativeComponentTypes: [Stunned],
+});
+
+// visibleEnemies: [Position, Team] — all enemies (for detection/rendering)
+const visibleEnemies: Query = world.createQuery([Position, Team]);
+
+// damageableAllies: [Position, Health, Team] — allies that can be healed
+const damageableAllies: Query = world.createQuery([Position, Health, Team]);
+
+// threats: [Position, Damage, Team] — enemies that deal damage
+const threats: Query = world.createQuery([Position, Damage, Team]);
+
+// ccTargets: [Position, Team] — valid CC targets (exclude stunned + invisible)
+const ccTargets: Query = world.createQuery([Position, Team], {
+  negativeComponentTypes: [Stunned, Invisible],
+});
+
+// =============================================================================
+// Helper: distance between two positions
+// =============================================================================
+function dist(a: Position, b: Position): number {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+// =============================================================================
+// Game loop built with @codehz/pipeline
+// =============================================================================
+const gameLoop = pipeline()
+  // ---------------------------------------------------------------------------
+  // DamagePass: threats find nearest livingAlly and deal damage
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    // Collect all living ally positions for target selection
+    const allyEntries: Array<{ entity: EntityId; pos: Position; hp: Health }> = [];
+    livingAllies.forEach([Position, Health, Team], (entity, pos, hp, team) => {
+      if (team.id === 1) {
+        allyEntries.push({ entity, pos, hp });
+      }
+    });
+
+    if (allyEntries.length === 0) return;
+
+    threats.forEach([Position, Damage, Team], (entity, pos, dmg, team) => {
+      if (team.id !== 2) return; // only enemies
+
+      // Find nearest ally
+      let nearest: (typeof allyEntries)[0] | null = null;
+      let nearestDist = Infinity;
+      for (const ally of allyEntries) {
+        const d = dist(pos, ally.pos);
+        if (d < nearestDist) {
+          nearestDist = d;
+          nearest = ally;
+        }
+      }
+
+      if (nearest) {
+        nearest.hp.value -= dmg.value;
+        console.log(
+          `[DamagePass] Enemy ${entity} hits Ally ${nearest.entity} ` +
+            `for ${dmg.value} damage (HP: ${nearest.hp.value})`,
+        );
+
+        // If health depleted, mark for cleanup: remove Alive, add Invisible
+        if (nearest.hp.value <= 0) {
+          nearest.hp.value = 0;
+          world.remove(nearest.entity, Alive);
+          world.set(nearest.entity, Invisible);
+          console.log(`[DamagePass] Ally ${nearest.entity} has fallen! (Alive removed, Invisible added)`);
+        }
+      }
+    });
+  })
+
+  // ---------------------------------------------------------------------------
+  // HealPass: heal all damageable allies for a small amount
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    damageableAllies.forEach([Position, Health, Team], (entity, _pos, hp, team) => {
+      if (team.id !== 1) return;
+      const healAmount = 5;
+      const oldHp = hp.value;
+      hp.value = Math.min(hp.value + healAmount, 100);
+      if (hp.value !== oldHp) {
+        console.log(`[HealPass] Ally ${entity} healed by ${healAmount} ` + `(HP: ${oldHp} -> ${hp.value})`);
+      }
+    });
+  })
+
+  // ---------------------------------------------------------------------------
+  // CCApplicationPass: apply Stunned to a random valid ccTarget (if any exist)
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    const targets: Array<{ entity: EntityId; team: Team }> = [];
+    ccTargets.forEach([Position, Team], (entity, _pos, team) => {
+      targets.push({ entity, team });
+    });
+
+    const target = targets[0];
+    if (target) {
+      // Pick the first valid target (deterministic for demo)
+      world.set(target.entity, Stunned);
+      console.log(`[CCApplicationPass] Stunned applied to Entity ${target.entity} ` + `(Team ${target.team.id})`);
+    } else {
+      console.log(`[CCApplicationPass] No valid CC targets available`);
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // CCExpiryPass: remove Stunned from all currently-stunned entities
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    // Use getEntities on a query that just checks for Stunned presence.
+    // We don't have a dedicated "stunnedOnly" query, so iterate via allTeams.
+    // Better: iterate all livingAllies + visibleEnemies and check has(Stunned).
+    const allEntities = world.createQuery([Position]);
+    const stunnedEntities: EntityId[] = [];
+    allEntities.forEach([Position], (entity) => {
+      if (world.has(entity, Stunned)) {
+        stunnedEntities.push(entity);
+      }
+    });
+    allEntities.dispose(); // one-shot query — release immediately
+
+    for (const entity of stunnedEntities) {
+      world.remove(entity, Stunned);
+      console.log(`[CCExpiryPass] Stunned expired on Entity ${entity}`);
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // CleanupPass: delete entities that are dead (no Alive tag)
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    const deadEntities: EntityId[] = [];
+    // Use a temporary query to find entities with Position (our marker for
+    // "active entity") that lack the Alive tag.
+    const allPosQuery = world.createQuery([Position]);
+    allPosQuery.forEach([Position], (entity) => {
+      if (!world.has(entity, Alive)) {
+        deadEntities.push(entity);
+      }
+    });
+    allPosQuery.dispose();
+
+    for (const entity of deadEntities) {
+      world.delete(entity);
+      console.log(`[CleanupPass] Deleted dead Entity ${entity}`);
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // StatusPass: log counts of each query result set
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    console.log(`[StatusPass] === Frame Summary ===`);
+    console.log(`  livingAllies:     ${livingAllies.getEntities().length}`);
+    console.log(`  visibleEnemies:   ${visibleEnemies.getEntities().length}`);
+    console.log(`  damageableAllies: ${damageableAllies.getEntities().length}`);
+    console.log(`  threats:          ${threats.getEntities().length}`);
+    console.log(`  ccTargets:        ${ccTargets.getEntities().length}`);
+    console.log(`[StatusPass] ========================`);
+  })
+
+  // ---------------------------------------------------------------------------
+  // SyncPass: materialise all deferred structural changes
+  // ---------------------------------------------------------------------------
+  .addPass(() => {
+    world.sync();
+  })
+  .build();
+
+// =============================================================================
+// Setup: create entities with different tag/team combinations
+// =============================================================================
+function setup() {
+  console.log("=== Tag Filtering Demo Setup ===\n");
+
+  // --- 2 ally soldiers (Team 1, Alive, Position, Health=100) ---
+  world.spawn().with(Position, { x: 0, y: 0 }).with(Health, { value: 100 }).with(Team, { id: 1 }).with(Alive).build();
+
+  world.spawn().with(Position, { x: 5, y: 5 }).with(Health, { value: 100 }).with(Team, { id: 1 }).with(Alive).build();
+
+  // --- 3 enemy soldiers (Team 2, Alive, Position, Health=80, Damage=10) ---
+  for (let i = 0; i < 3; i++) {
+    world
+      .spawn()
+      .with(Position, { x: 20 + i * 10, y: 20 + i * 5 })
+      .with(Health, { value: 80 })
+      .with(Damage, { value: 10 })
+      .with(Team, { id: 2 })
+      .with(Alive)
+      .build();
+  }
+
+  // --- 1 enemy mage (Team 2, Alive, Position, Health=50, Damage=25, Invisible) ---
+  world
+    .spawn()
+    .with(Position, { x: 50, y: 50 })
+    .with(Health, { value: 50 })
+    .with(Damage, { value: 25 })
+    .with(Team, { id: 2 })
+    .with(Alive)
+    .with(Invisible) // starts stealthed — excluded from ccTargets
+    .build();
+
+  // --- 1 pre-stunned ally (Team 1, Alive, Position, Health=60, Stunned) ---
+  world
+    .spawn()
+    .with(Position, { x: -10, y: -10 })
+    .with(Health, { value: 60 })
+    .with(Team, { id: 1 })
+    .with(Alive)
+    .with(Stunned) // starts CC'd — excluded from livingAllies until expiry
+    .build();
+
+  world.sync();
+  console.log("Setup complete. Starting simulation...\n");
+}
+
+// =============================================================================
+// Main entry point
+// =============================================================================
+function main() {
+  setup();
+
+  for (let frame = 1; frame <= 4; frame++) {
+    console.log(`\n--- Frame ${frame} ---`);
+    gameLoop({});
+  }
+
+  console.log("\n=== Demo completed! ===");
+}
+
+main();

package/package.json

@@ -1,23 +1,71 @@
 {
   "name": "@codehz/ecs",
-  "version": "0.7.2",
-  "repository": {
-    "url": "https://github.com/codehz/ecs"
-  },
+  "version": "0.7.4",
+  "license": "MIT",
+  "module": "src/index.ts",
   "type": "module",
-  "main": "./index.mjs",
-  "types": "./index.d.mts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./index.d.mts",
-      "import": "./index.mjs"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "perry": "./src/index.ts"
     },
     "./testing": {
-      "types": "./testing.d.mts",
-      "import": "./testing.mjs"
+      "types": "./dist/testing.d.mts",
+      "import": "./dist/testing.mjs",
+      "perry": "./src/testing/index.ts"
     }
   },
+  "files": [
+    "dist",
+    "examples",
+    "src",
+    "LICENSE",
+    "README.md",
+    "README.en.md"
+  ],
+  "devDependencies": {
+    "@codehz/pipeline": "^0.3.0",
+    "@types/bun": "1.3.2",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-prettier": "^5.5.4",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "prettier": "^3.6.2",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "tsdown": "^0.16.6"
+  },
+  "repository": {
+    "url": "https://github.com/codehz/ecs"
+  },
+  "scripts": {
+    "test": "bun test",
+    "demo": "bun run examples/simple.ts",
+    "release": "bun run scripts/build.ts",
+    "prepare": "husky",
+    "lint": "eslint --ext .ts,.tsx,.js --quiet",
+    "lint:fix": "eslint --ext .ts,.tsx,.js --fix",
+    "format": "prettier --write ."
+  },
   "peerDependencies": {
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{json,md}": [
+      "prettier --write"
+    ]
+  },
+  "perry": {
+    "compilePackages": [
+      "@codehz/pipeline"
+    ]
   }
-}
+}

package/src/__tests__/commands/buffer-limits.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "bun:test";
+import { component } from "../../entity";
+import { World } from "../../world/world";
+
+describe("CommandBuffer iteration limit", () => {
+  it("should throw when exceeding MAX_ITERATIONS", () => {
+    const world = new World();
+    const Counter = component<{ value: number }>();
+
+    // Create a hook that recursively increments a counter
+    world.hook([Counter], {
+      on_set: (entityId, data) => {
+        // Keep triggering new set commands beyond the iteration limit
+        if (data.value < 200) {
+          world.set(entityId, Counter, { value: data.value + 1 });
+        }
+      },
+    });
+
+    const entity = world.new();
+    world.set(entity, Counter, { value: 0 });
+
+    // Executing should exceed iteration limit and throw
+    expect(() => world.sync()).toThrow(/maximum.*iterations|exceeded/i);
+  });
+
+  it("should handle multiple entities with cascading commands", () => {
+    const world = new World();
+    const Increment = component<{ count: number }>();
+
+    let hookCalls = 0;
+    world.hook([Increment], {
+      on_set: (entityId, data) => {
+        hookCalls++;
+        // Only trigger new commands on first few calls to avoid exceeding limit
+        // We have 2 entities, each initial set + cascading calls
+        if (hookCalls < 25) {
+          world.set(entityId, Increment, { count: data.count + 1 });
+        }
+      },
+    });
+
+    const entity1 = world.new();
+    const entity2 = world.new();
+
+    world.set(entity1, Increment, { count: 0 });
+    world.set(entity2, Increment, { count: 0 });
+
+    // This should complete without reaching the iteration limit (100)
+    world.sync();
+    expect(hookCalls).toBeGreaterThan(0);
+    expect(hookCalls).toBeLessThan(100);
+  });
+
+  it("should execute all commands within iteration limit", () => {
+    const world = new World();
+    const Value = component<{ num: number }>();
+
+    const entity = world.new();
+
+    // Queue multiple commands before sync
+    for (let i = 0; i < 50; i++) {
+      world.set(entity, Value, { num: i });
+    }
+
+    // Should complete without throwing
+    world.sync();
+
+    // Final value should be the last one set
+    expect(world.get(entity, Value)).toEqual({ num: 49 });
+  });
+});