archetype-ecs 1.2.0 → 1.3.2

package/README.md

@@ -4,7 +4,7 @@
   <br><br>
   <strong>archetype-ecs</strong>
   <br>
-  <sub>Tiny, fast ECS with TypedArray storage. Zero dependencies.</sub>
+  <sub>ECS with TypedArray storage. No dependencies.</sub>
   <br><br>
   <a href="https://www.npmjs.com/package/archetype-ecs"><img src="https://img.shields.io/npm/v/archetype-ecs.svg?style=flat-square&color=000" alt="npm" /></a>
   <img src="https://img.shields.io/badge/gzip-~5kb-000?style=flat-square" alt="size" />
@@ -13,16 +13,12 @@
 
 ---
 
-Entities grouped by component composition. Numeric fields in contiguous TypedArrays, strings in SoA arrays. Bitmask query matching. Zero-allocation hot paths.
+An Entity Component System for games and simulations in TypeScript. Entities with the same components are grouped into archetypes, and their fields are stored in TypedArrays — so iterating a million entities is a tight loop over contiguous memory, not a scatter of object lookups.
 
 ```
 npm i archetype-ecs
 ```
 
----
-
-### The full picture in 20 lines
-
 ```ts
 import { createEntityManager, component } from 'archetype-ecs'
 
@@ -50,18 +46,16 @@ em.forEach([Position, Velocity], (arch) => {
 })
 ```
 
-Define components, spawn entities, iterate with raw TypedArrays — no allocations, no cache misses, full type safety.
-
 ---
 
 ### Why archetype-ecs?
 
 <table>
-<tr><td><strong>Fastest iteration</strong></td><td>SoA TypedArrays give the fastest iteration of any JS ECS we've tested. 1.7 ms/frame over 1M entities — see <a href="#benchmarks">benchmarks</a>.</td></tr>
-<tr><td><strong>Compact memory</strong></td><td>Packed archetypes store 1M entities in 86 MB. Up to 2.4x less than sparse-array alternatives.</td></tr>
-<tr><td><strong>Zero-alloc hot path</strong></td><td><code>em.get</code>, <code>em.set</code>, and <code>forEach</code> never allocate. Your GC stays quiet.</td></tr>
-<tr><td><strong>Type-safe</strong></td><td>Full TypeScript generics. Field names autocomplete. Wrong fields don't compile.</td></tr>
-<tr><td><strong>Zero dependencies</strong></td><td>~5kb gzipped. No build step. Ships as ES modules.</td></tr>
+<tr><td><strong>Fast iteration</strong></td><td>1.7 ms/frame over 1M entities. Faster than bitecs, wolf-ecs, harmony-ecs — see <a href="#benchmarks">benchmarks</a>.</td></tr>
+<tr><td><strong>Low memory</strong></td><td>86 MB for 1M entities. Sparse-array ECS libraries use up to 2.4x more.</td></tr>
+<tr><td><strong>No allocations</strong></td><td><code>get</code>, <code>set</code>, and <code>forEach</code> don't allocate.</td></tr>
+<tr><td><strong>Typed</strong></td><td>TypeScript generics throughout. Field names autocomplete, wrong fields don't compile.</td></tr>
+<tr><td><strong>Systems</strong></td><td>Class-based systems with <code>@OnAdded</code> / <code>@OnRemoved</code> decorators. Functional API also available.</td></tr>
 </table>
 
 ---
@@ -71,12 +65,12 @@ Define components, spawn entities, iterate with raw TypedArrays — no allocatio
 ```ts
 import { createEntityManager, component } from 'archetype-ecs'
 
-// Numeric — backed by TypedArrays for cache-friendly iteration
+// Numeric — stored as TypedArrays
 const Position = component('Position', 'f32', ['x', 'y'])
 const Velocity = component('Velocity', 'f32', ['vx', 'vy'])
 const Health   = component('Health', { hp: 'i32', maxHp: 'i32' })
 
-// Strings — backed by SoA arrays, same field access API
+// Strings — stored as arrays, same API
 const Name     = component('Name', 'string', ['name', 'title'])
 
 // Mixed — numeric and string fields in one component
@@ -90,7 +84,7 @@ const Enemy    = component('Enemy')
 
 ### Entities
 
-```js
+```ts
 const em = createEntityManager()
 
 // One at a time
@@ -100,7 +94,7 @@ em.addComponent(player, Velocity, { vx: 0, vy: 0 })
 em.addComponent(player, Health, { hp: 100, maxHp: 100 })
 em.addComponent(player, Name, { name: 'Hero', title: 'Sir' })
 
-// Or all at once — no archetype migration overhead
+// Or all at once
 for (let i = 0; i < 10_000; i++) {
   em.createEntityWith(
     Position, { x: Math.random() * 800, y: Math.random() * 600 },
@@ -116,8 +110,8 @@ em.destroyEntity(player)
 
 ### Read & write
 
-```js
-// Zero allocation — access any field directly
+```ts
+// Access a single field (doesn't allocate)
 em.get(player, Position.x)         // 0
 em.get(player, Name.name)          // 'Hero'
 em.set(player, Velocity.vx, 5)
@@ -127,16 +121,16 @@ em.getComponent(player, Position)  // { x: 0, y: 0 }
 em.getComponent(player, Name)      // { name: 'Hero', title: 'Sir' }
 ```
 
-### Systems — `forEach` vs `query`
+### Queries — `forEach` vs `query`
 
 Two ways to work with entities in bulk. Pick the right one for the job:
 
-#### `forEach` — zero-alloc bulk processing
+#### `forEach` — bulk processing
 
-Best for **systems that run every frame**. Gives you raw TypedArrays — no entity lookups, no object allocations, no cache misses.
+Iterates over matching archetypes. You get the backing TypedArrays directly.
 
-```js
-function movementSystem(dt) {
+```ts
+function movementSystem(dt: number) {
   em.forEach([Position, Velocity], (arch) => {
     const px = arch.field(Position.x)  // Float32Array
     const py = arch.field(Position.y)
@@ -152,9 +146,9 @@ function movementSystem(dt) {
 
 #### `query` — when you need entity IDs
 
-Best for **event-driven logic** where you need to store, pass around, or target specific entity IDs.
+Returns entity IDs for when you need to target specific entities.
 
-```js
+```ts
 // Find the closest enemy to the player
 const enemies = em.query([Position, Enemy])
 let closest = -1, minDist = Infinity
@@ -182,11 +176,69 @@ const total = em.count([Position])
 | **Use for** | Movement, physics, rendering | Damage events, UI, spawning |
 | **Runs** | Every frame | On demand |
 | **Allocates** | Nothing | `number[]` of entity IDs |
-| **Access** | Raw TypedArrays by field | `get` / `set` by entity ID |
+| **Access** | TypedArrays by field | `get` / `set` by entity ID |
+
+### Systems
+
+Class-based systems with decorators for component lifecycle hooks:
+
+```ts
+import { System, OnAdded, OnRemoved, createSystems, type EntityId } from 'archetype-ecs'
+
+class MovementSystem extends System {
+  tick() {
+    this.forEach([Position, Velocity], (arch) => {
+      const px = arch.field(Position.x)
+      const py = arch.field(Position.y)
+      const vx = arch.field(Velocity.vx)
+      const vy = arch.field(Velocity.vy)
+      for (let i = 0; i < arch.count; i++) {
+        px[i] += vx[i]
+        py[i] += vy[i]
+      }
+    })
+  }
+}
+
+class DeathSystem extends System {
+  @OnAdded(Health)
+  onSpawn(id: EntityId) {
+    console.log(`Entity ${id} spawned with ${this.em.get(id, Health.hp)} HP`)
+  }
+
+  @OnRemoved(Health)
+  onDeath(id: EntityId) {
+    this.em.addComponent(id, Dead)
+  }
+}
+
+const em = createEntityManager()
+const pipeline = createSystems(em, [MovementSystem, DeathSystem])
+
+// Game loop
+em.flushHooks()
+pipeline()
+```
+
+`@OnAdded(Health, Position)` fires when an entity has **all** specified components. `@OnRemoved(Health)` fires when any specified component is removed. Hooks are buffered and deduplicated — they fire during `pipeline()` (or `sys.run()`), after `flushHooks()` collects the pending changes.
+
+A functional API is also available:
+
+```ts
+import { createSystem } from 'archetype-ecs'
+
+const deathSystem = createSystem(em, (sys) => {
+  sys.onAdded(Health, (id) => console.log(`${id} spawned`))
+  sys.onRemoved(Health, (id) => console.log(`${id} died`))
+})
+
+em.flushHooks()
+deathSystem()
+```
 
 ### Serialize
 
-```js
+```ts
 const symbolToName = new Map([
   [Position._sym, 'Position'],
   [Velocity._sym, 'Velocity'],
@@ -200,41 +252,25 @@ const json = JSON.stringify(snapshot)
 em.deserialize(JSON.parse(json), { Position, Velocity, Health })
 ```
 
-Strip components, skip entities, or plug in custom serializers — see the API section below.
+Supports stripping components, skipping entities, and custom serializers.
 
 ---
 
 ## TypeScript
 
-Every component carries its type. Field names autocomplete, wrong fields and shapes are compile errors.
+Component types are inferred from their definition. Field names autocomplete, wrong fields are compile errors.
 
 ```ts
-// Schema is inferred — Position becomes ComponentDef<{ x: number; y: number }>
+// Schema is inferred — Position becomes ComponentDef<'x' | 'y'>
 const Position = component('Position', 'f32', ['x', 'y'])
 
-Position.x                // autocompletes to .x and .y
-Position.z                // Property 'z' does not exist
+Position.x                // FieldRef — autocompletes to .x and .y
+Position.z                // compile error: Property 'z' does not exist
 
-em.get(id, Position.x)    // number | undefined
-em.set(id, Position.z, 5) // Property 'z' does not exist
+em.get(id, Position.x)    // zero-alloc field access
+em.set(id, Position.x, 5) // zero-alloc field write
 
-em.addComponent(id, Position, { x: 1, y: 2 })  // ok
-em.addComponent(id, Position, { x: 1 })         // Property 'y' is missing
-
-em.getComponent(id, Position)  // { x: number; y: number } | undefined
-```
-
-String fields are fully typed too:
-
-```ts
-const Name = component('Name', 'string', ['name', 'title'])
-
-em.get(id, Name.name)    // string | undefined
-em.set(id, Name.name, 'Hero')    // ok
-em.set(id, Name.name, 42)        // number not assignable to string
-
-em.addComponent(id, Name, { name: 'Hero', title: 'Sir' })  // ok
-em.addComponent(id, Name, { foo: 'bar' })                   // type error
+arch.field(Position.x)    // Float32Array — direct TypedArray access
 ```
 
 ---
@@ -249,7 +285,7 @@ Tag component — no data, used as a marker for queries.
 
 Schema component with uniform field type.
 
-```js
+```ts
 const Position = component('Position', 'f32', ['x', 'y'])
 const Name     = component('Name', 'string', ['name', 'title'])
 ```
@@ -258,7 +294,7 @@ const Name     = component('Name', 'string', ['name', 'title'])
 
 Schema component with mixed field types.
 
-```js
+```ts
 const Item = component('Item', { name: 'string', weight: 'f32', armor: 'u8' })
 ```
 
@@ -269,27 +305,51 @@ Returns an entity manager with the following methods:
 | Method | Description |
 |---|---|
 | `createEntity()` | Create an empty entity |
-| `createEntityWith(Comp, data, ...)` | Create entity with components — no migration cost |
+| `createEntityWith(Comp, data, ...)` | Create entity with components in one call |
 | `destroyEntity(id)` | Remove entity and all its components |
 | `addComponent(id, Comp, data)` | Add a component to an existing entity |
 | `removeComponent(id, Comp)` | Remove a component |
 | `hasComponent(id, Comp)` | Check if entity has a component |
 | `getComponent(id, Comp)` | Get component data as object *(allocates)* |
-| `get(id, Comp.field)` | Read a single field *(zero-alloc)* |
-| `set(id, Comp.field, value)` | Write a single field *(zero-alloc)* |
+| `get(id, Comp.field)` | Read a single field |
+| `set(id, Comp.field, value)` | Write a single field |
 | `query(include, exclude?)` | Get matching entity IDs |
 | `count(include, exclude?)` | Count matching entities |
-| `forEach(include, callback, exclude?)` | Iterate archetypes with raw TypedArray access |
+| `forEach(include, callback, exclude?)` | Iterate archetypes with TypedArray access |
+| `onAdd(Comp, callback)` | Register callback for component additions *(deferred)* |
+| `onRemove(Comp, callback)` | Register callback for component removals *(deferred)* |
+| `flushHooks()` | Collect pending add/remove events for registered hooks |
 | `serialize(symbolToName, strip?, skip?, opts?)` | Serialize world to JSON-friendly object |
 | `deserialize(data, nameToSymbol, opts?)` | Restore world from serialized data |
 
+### `System`
+
+Base class for decorator-based systems.
+
+| | Description |
+|---|---|
+| `@OnAdded(...Comps)` | Decorator — method fires when entity gains **all** specified components |
+| `@OnRemoved(...Comps)` | Decorator — method fires when **any** specified component is removed |
+| `tick()` | Override — called every `run()` after hook callbacks |
+| `forEach(types, callback, exclude?)` | Shorthand for `this.em.forEach(...)` |
+| `run()` | Fire buffered hook callbacks, then `tick()` |
+| `dispose()` | Unsubscribe all hooks |
+
+### `createSystem(em, constructor)`
+
+Functional alternative to class-based systems. The constructor receives a context with `onAdded`, `onRemoved`, and `forEach`, and optionally returns a tick function.
+
+### `createSystems(em, entries)`
+
+Creates a pipeline from an array of class-based (`System` subclasses) and/or functional system constructors. Returns a callable that runs all systems in order, with a `dispose()` method.
+
 ---
 
 ## Benchmarks
 
 1M entities, Position += Velocity, 5 runs (median), Node.js:
 
-| | archetype-ecs | bitecs | wolf-ecs | harmony-ecs | miniplex |
+| | archetype-ecs | [bitecs](https://github.com/NateTheGreatt/bitECS) | [wolf-ecs](https://github.com/EnderShadow8/wolf-ecs) | [harmony-ecs](https://github.com/3mcd/harmony-ecs) | [miniplex](https://github.com/hmans/miniplex) |
 |---|---:|---:|---:|---:|---:|
 | **Iteration** (ms/frame) | **1.7** | 2.2 | 2.2 | 1.8 | 32.5 |
 | **Entity creation** (ms) | 401 | 366 | **106** | 248 | 265 |
@@ -297,7 +357,7 @@ Returns an entity manager with the following methods:
 
 Each library runs the same test — iterate 1M entities over 500 frames:
 
-```js
+```ts
 // archetype-ecs
 em.forEach([Position, Velocity], (arch) => {
   const px = arch.field(Position.x)   // Float32Array, dense
@@ -311,7 +371,7 @@ em.forEach([Position, Velocity], (arch) => {
 })
 ```
 
-archetype-ecs has the fastest iteration — the metric that matters most for game loops. Harmony-ecs and wolf-ecs are close behind; miniplex pays for object-based storage with ~20x slower iteration.
+archetype-ecs is fastest at iteration. Harmony-ecs and wolf-ecs are close; miniplex is ~20x slower due to object-based storage.
 
 Run them yourself:
 
@@ -323,7 +383,7 @@ npm run bench
 
 ## Feature comparison
 
-How archetype-ecs stacks up against other JS ECS libraries:
+Compared against other JS ECS libraries:
 
 ### Unique to archetype-ecs
 
@@ -333,6 +393,7 @@ How archetype-ecs stacks up against other JS ECS libraries:
 | Mixed string + numeric components | ✓ | — | — | — | — |
 | `forEach` with dense TypedArray field access | ✓ | — | — | — | — |
 | Field descriptors for both per-entity and bulk access | ✓ | — | — | — | — |
+| TC39 decorator system (`@OnAdded` / `@OnRemoved`) | ✓ | — | — | — | — |
 | Built-in profiler | ✓ | — | — | — | — |
 
 ### Full comparison
@@ -345,12 +406,14 @@ How archetype-ecs stacks up against other JS ECS libraries:
 | TypeScript type inference | ✓ | — | ✓ | ✓ | ✓✓ |
 | Batch entity creation | ✓ | — | — | ✓ | ✓ |
 | Zero-alloc per-entity access | ✓ | ✓ | ✓ | ✓ | — |
+| System framework (class + functional) | ✓ | — | — | — | — |
+| Component lifecycle hooks | ✓ | — | — | — | ✓ |
 | Relations / hierarchies | — | ✓ | — | — | — |
 | React integration | — | — | — | — | ✓ |
 
 ✓✓ = notably stronger implementation in that library.
 
-archetype-ecs is the only library that combines fastest iteration, string SoA storage, serialization, type safety, and a built-in profiler.
+archetype-ecs is the only one that combines fast iteration, string storage, serialization, decorator-based systems, and type safety.
 
 ---
 

package/bench/allocations-1m.js

@@ -4,7 +4,7 @@
 import {
   createWorld, addEntity, addComponent, removeEntity, query
 } from 'bitecs';
-import { createEntityManager, component } from '../src/index.js';
+import { createEntityManager, component } from '../dist/index.js';
 
 const COUNT = 1_000_000;
 const RUNS = 5;

package/bench/multi-ecs-bench.js

@@ -2,7 +2,7 @@
 // Tests: iteration (Position += Velocity), entity creation, memory usage
 // Run with: node --expose-gc bench/multi-ecs-bench.js
 
-import { createEntityManager, component } from '../src/index.js';
+import { createEntityManager, component } from '../dist/index.js';
 
 const COUNT = 1_000_000;
 const FRAMES = 500;

package/bench/typed-vs-bitecs-1m.js

@@ -3,7 +3,7 @@
 import {
   createWorld, addEntity, addComponent, query
 } from 'bitecs';
-import { createEntityManager, component } from '../src/index.js';
+import { createEntityManager, component } from '../dist/index.js';
 
 const COUNT = 1_000_000;
 const FRAMES = 500;

package/bench/typed-vs-untyped.js

@@ -1,38 +1,34 @@
-// Benchmark: typed (SoA TypedArrays) vs untyped (object arrays) components
+// Benchmark: forEach+field (bulk TypedArray) vs query+get/set (per-entity) vs query+getComponent (allocating)
 
-import { createEntityManager, component } from '../src/index.js';
+import { createEntityManager, component } from '../dist/index.js';
 
 const COUNT = 1_000_000;
 const FRAMES = 200;
 
-// --- Typed: creation ---
-function benchTypedCreate() {
-  const Pos = component('TP', 'f32', ['x', 'y']);
-  const Vel = component('TV', 'f32', ['vx', 'vy']);
+// --- forEach + field() — bulk dense TypedArray access ---
+function benchForEachField() {
+  const Pos = component('FP', 'f32', ['x', 'y']);
+  const Vel = component('FV', 'f32', ['vx', 'vy']);
   const em = createEntityManager();
 
-  const t0 = performance.now();
   for (let i = 0; i < COUNT; i++) {
     em.createEntityWith(Pos, { x: i, y: i }, Vel, { vx: 1, vy: 1 });
   }
-  return { em, Pos, Vel, time: performance.now() - t0 };
-}
-
-// --- Untyped: creation ---
-function benchUntypedCreate() {
-  const Pos = component('UP');
-  const Vel = component('UV');
-  const em = createEntityManager();
 
-  const t0 = performance.now();
-  for (let i = 0; i < COUNT; i++) {
-    em.createEntityWith(Pos, { x: i, y: i }, Vel, { vx: 1, vy: 1 });
+  // Warmup
+  for (let f = 0; f < 5; f++) {
+    em.forEach([Pos, Vel], (arch) => {
+      const px = arch.field(Pos.x);
+      const py = arch.field(Pos.y);
+      const vx = arch.field(Vel.vx);
+      const vy = arch.field(Vel.vy);
+      for (let i = 0; i < arch.count; i++) {
+        px[i] += vx[i];
+        py[i] += vy[i];
+      }
+    });
   }
-  return { em, Pos, Vel, time: performance.now() - t0 };
-}
 
-// --- Typed: iteration with forEach + field() ---
-function benchTypedIterate(em, Pos, Vel) {
   const t0 = performance.now();
   for (let f = 0; f < FRAMES; f++) {
     em.forEach([Pos, Vel], (arch) => {
@@ -49,19 +45,61 @@ function benchTypedIterate(em, Pos, Vel) {
   return (performance.now() - t0) / FRAMES;
 }
 
-// --- Untyped: iteration with forEach (object access) ---
-function benchUntypedIterate(em, Pos, Vel) {
+// --- query + get/set — per-entity field access (zero-alloc per field) ---
+function benchQueryGetSet() {
+  const Pos = component('GP', 'f32', ['x', 'y']);
+  const Vel = component('GV', 'f32', ['vx', 'vy']);
+  const em = createEntityManager();
+
+  for (let i = 0; i < COUNT; i++) {
+    em.createEntityWith(Pos, { x: i, y: i }, Vel, { vx: 1, vy: 1 });
+  }
+
+  const ids = em.query([Pos, Vel]);
+
+  // Warmup
+  for (let f = 0; f < 5; f++) {
+    for (let i = 0; i < ids.length; i++) {
+      em.set(ids[i], Pos.x, em.get(ids[i], Pos.x) + em.get(ids[i], Vel.vx));
+      em.set(ids[i], Pos.y, em.get(ids[i], Pos.y) + em.get(ids[i], Vel.vy));
+    }
+  }
+
   const t0 = performance.now();
   for (let f = 0; f < FRAMES; f++) {
-    const ids = em.query([Pos, Vel]);
+    for (let i = 0; i < ids.length; i++) {
+      em.set(ids[i], Pos.x, em.get(ids[i], Pos.x) + em.get(ids[i], Vel.vx));
+      em.set(ids[i], Pos.y, em.get(ids[i], Pos.y) + em.get(ids[i], Vel.vy));
+    }
+  }
+  return (performance.now() - t0) / FRAMES;
+}
+
+// --- query + getComponent — per-entity object allocation ---
+function benchQueryGetComponent() {
+  const Pos = component('CP', 'f32', ['x', 'y']);
+  const Vel = component('CV', 'f32', ['vx', 'vy']);
+  const em = createEntityManager();
+
+  for (let i = 0; i < COUNT; i++) {
+    em.createEntityWith(Pos, { x: i, y: i }, Vel, { vx: 1, vy: 1 });
+  }
+
+  const ids = em.query([Pos, Vel]);
+
+  // Only 20 frames for this one — it's very slow at 1M
+  const frames = 20;
+
+  const t0 = performance.now();
+  for (let f = 0; f < frames; f++) {
     for (let i = 0; i < ids.length; i++) {
       const pos = em.getComponent(ids[i], Pos);
       const vel = em.getComponent(ids[i], Vel);
-      pos.x += vel.vx;
-      pos.y += vel.vy;
+      em.set(ids[i], Pos.x, pos.x + vel.vx);
+      em.set(ids[i], Pos.y, pos.y + vel.vy);
     }
   }
-  return (performance.now() - t0) / FRAMES;
+  return (performance.now() - t0) / frames;
 }
 
 // --- String SoA: creation + access ---
@@ -102,65 +140,27 @@ function benchStringSoA() {
   return { createTime, forEachTime, getTime, count, count2 };
 }
 
-// --- String untyped: creation + access ---
-function benchStringUntyped() {
-  const Name = component('SUn');
-  const em = createEntityManager();
-
-  const t0 = performance.now();
-  for (let i = 0; i < COUNT; i++) {
-    em.createEntityWith(Name, { name: `entity_${i}`, tag: 'npc' });
-  }
-  const createTime = performance.now() - t0;
-
-  // getComponent access
-  const ids = em.query([Name]);
-  const t1 = performance.now();
-  let count = 0;
-  for (let f = 0; f < 50; f++) {
-    for (let i = 0; i < ids.length; i++) {
-      const n = em.getComponent(ids[i], Name);
-      if (n.name.length > 5) count++;
-    }
-  }
-  const accessTime = (performance.now() - t1) / 50;
-
-  return { createTime, accessTime, count };
-}
-
 // --- Run ---
-console.log(`\n=== Typed vs Untyped: ${(COUNT / 1e6).toFixed(0)}M entities ===\n`);
-
-// Warmup
-benchTypedCreate();
-benchUntypedCreate();
+console.log(`\n=== Access patterns: ${(COUNT / 1e6).toFixed(0)}M entities ===\n`);
 
-// Creation
-const typed = benchTypedCreate();
-const untyped = benchUntypedCreate();
+console.log(`Iteration (${FRAMES} frames, Position += Velocity):`);
+const forEachField = benchForEachField();
+console.log(`  forEach + field():            ${forEachField.toFixed(2)} ms/frame`);
 
-console.log(`Creation (${(COUNT / 1e6).toFixed(0)}M entities, createEntityWith):`);
-console.log(`  typed:    ${typed.time.toFixed(0)} ms`);
-console.log(`  untyped:  ${untyped.time.toFixed(0)} ms`);
-console.log(`  ratio:    ${(untyped.time / typed.time).toFixed(2)}x`);
+const queryGetSet = benchQueryGetSet();
+console.log(`  query + get/set:              ${queryGetSet.toFixed(2)} ms/frame`);
 
-// Iteration
-const typedIter = benchTypedIterate(typed.em, typed.Pos, typed.Vel);
-const untypedIter = benchUntypedIterate(untyped.em, untyped.Pos, untyped.Vel);
+const queryGetComp = benchQueryGetComponent();
+console.log(`  query + getComponent:         ${queryGetComp.toFixed(2)} ms/frame`);
 
-console.log(`\nIteration (${FRAMES} frames, Position += Velocity):`);
-console.log(`  typed (forEach+field):        ${typedIter.toFixed(2)} ms/frame`);
-console.log(`  untyped (query+getComponent): ${untypedIter.toFixed(2)} ms/frame`);
-console.log(`  ratio:    ${(untypedIter / typedIter).toFixed(1)}x slower`);
+console.log(`\n  forEach vs get/set:           ${(queryGetSet / forEachField).toFixed(1)}x faster`);
+console.log(`  forEach vs getComponent:      ${(queryGetComp / forEachField).toFixed(1)}x faster`);
 
 // String components
 console.log(`\nString component (${(COUNT / 1e6).toFixed(0)}M entities, { name, tag }):`);
-const strSoA = benchStringSoA();
-const strUn = benchStringUntyped();
-console.log(`  SoA create:                   ${strSoA.createTime.toFixed(0)} ms`);
-console.log(`  untyped create:               ${strUn.createTime.toFixed(0)} ms`);
-console.log(`  SoA forEach(field):           ${strSoA.forEachTime.toFixed(1)} ms/frame`);
-console.log(`  SoA get():                    ${strSoA.getTime.toFixed(1)} ms/frame`);
-console.log(`  untyped getComponent():       ${strUn.accessTime.toFixed(1)} ms/frame`);
-console.log(`  forEach vs getComponent:      ${(strUn.accessTime / strSoA.forEachTime).toFixed(1)}x faster`);
+const str = benchStringSoA();
+console.log(`  create:                       ${str.createTime.toFixed(0)} ms`);
+console.log(`  forEach(field):               ${str.forEachTime.toFixed(1)} ms/frame`);
+console.log(`  get() per entity:             ${str.getTime.toFixed(1)} ms/frame`);
+console.log(`  forEach vs get:               ${(str.getTime / str.forEachTime).toFixed(1)}x faster`);
 console.log();