iris-ecs 0.0.9 → 0.0.10

package/README.md

@@ -30,6 +30,14 @@ ECS is not a good fit for everything. Simple CRUD applications, form-heavy UIs,
 npm install iris-ecs
 ```
 
+## AI Skills
+
+Install the [iris-ecs skill](https://skills.sh) so AI coding agents (Claude Code, Cursor, etc.) understand the iris-ecs API:
+
+```bash
+npx skills add https://github.com/r04423/iris --skill iris-ecs
+```
+
 ## Quick Start
 
 ```typescript
@@ -40,43 +48,40 @@ import {
   defineSystem,
   defineTag,
   cacheQuery,
-  addComponent,
-  getComponentValue,
-  setComponentValue,
+  getComponentVectorView,
   queryEntities,
   addSystem,
   runOnce,
   Type,
 } from "iris-ecs";
 
-// Define components
-const Position = defineComponent("Position", { x: Type.f32(), y: Type.f32() });
-const Velocity = defineComponent("Velocity", { x: Type.f32(), y: Type.f32() });
+// Define components -- vector fields store x,y interleaved in one TypedArray
+const Position = defineComponent("Position", { value: Type.f32(2) });
+const Velocity = defineComponent("Velocity", { value: Type.f32(2) });
 const Player = defineTag("Player");
 
 // Create world and entities
 const world = createWorld();
 
-const player = createEntity(world);
-addComponent(world, player, Position, { x: 0, y: 0 });
-addComponent(world, player, Velocity, { x: 1, y: 0 });
-addComponent(world, player, Player);
+const player = createEntity(world, [
+  [Position, { value: [0, 0] }],
+  [Velocity, { value: [1, 0] }],
+  Player,
+]);
 
 // Define a system -- init runs once, tick runs every frame
 const movementSystem = defineSystem("movementSystem", (world) => {
   // Init: cache queries once
-  const movers = cacheQuery(world, Position, Velocity);
+  const movers = cacheQuery(world, [Position, Velocity]);
 
   return () => {
     // Tick: runs every frame
     queryEntities(world, movers, (e) => {
-      const px = getComponentValue(world, e, Position, "x");
-      const py = getComponentValue(world, e, Position, "y");
-      const vx = getComponentValue(world, e, Velocity, "x");
-      const vy = getComponentValue(world, e, Velocity, "y");
+      const pos = getComponentVectorView(world, e, Position, "value");
+      const vel = getComponentVectorView(world, e, Velocity, "value");
 
-      setComponentValue(world, e, Position, "x", px + vx);
-      setComponentValue(world, e, Position, "y", py + vy);
+      pos[0] += vel[0];
+      pos[1] += vel[1];
     });
   };
 });
@@ -85,7 +90,7 @@ const movementSystem = defineSystem("movementSystem", (world) => {
 addSystem(world, movementSystem);
 await runOnce(world);
 
-// Position is now { x: 1, y: 0 }
+// Position is now [1, 0]
 ```
 
 ## Core Concepts
@@ -108,6 +113,12 @@ const world = createWorld();
 const player = createEntity(world);
 const enemy = createEntity(world);
 
+// Create with initial components
+const npc = createEntity(world, [
+  [Position, { value: [10, 20] }],
+  Enemy,
+]);
+
 destroyEntity(world, enemy);
 isEntityAlive(world, enemy); // false
 isEntityAlive(world, player); // true
@@ -116,7 +127,7 @@ isEntityAlive(world, player); // true
 resetWorld(world);
 ```
 
-Create entities with `createEntity()`, destroy them with `destroyEntity()`. Use `isEntityAlive()` to check if an entity reference is still valid. Call `resetWorld()` to clear all entities and state while preserving definitions -- useful for level reloads or testing.
+Create entities with `createEntity()`, optionally passing an array of component entries to attach in one call. Destroy them with `destroyEntity()`. Use `isEntityAlive()` to check if an entity reference is still valid. Call `resetWorld()` to clear all entities and state while preserving definitions -- useful for level reloads or testing.
 
 ⚠️ **Entity IDs are recycled.** After destroying an entity, its ID may be reused for a new entity. Never store entity IDs long-term without checking `isEntityAlive()` first -- your old reference might now point to a different entity.
 
@@ -138,7 +149,7 @@ getName(world, player);              // "player-1"
 lookupByName(world, "player-1");     // player entity
 
 // Validate components during lookup -- returns entity only if it has both
-lookupByName(world, "player-1", Position, Health);
+lookupByName(world, "player-1", [Position, Health]);
 
 removeName(world, player);
 lookupByName(world, "player-1");     // undefined
@@ -177,18 +188,26 @@ import {
   defineComponent,
   Type,
   addComponent,
+  addComponents,
   getComponentValue,
   setComponentValue,
+  getComponentVectorValue,
+  setComponentVectorValue,
+  getComponentVectorView,
 } from "iris-ecs";
 
-const Position = defineComponent("Position", { x: Type.f32(), y: Type.f32() });
+const Position = defineComponent("Position", { value: Type.f32(2) });
 const Health = defineComponent("Health", { current: Type.i32(), max: Type.i32() });
 
-addComponent(world, entity, Position, { x: 0, y: 0 });
+addComponent(world, entity, Position, { value: [0, 0] });
 addComponent(world, entity, Health, { current: 100, max: 100 });
 
-const x = getComponentValue(world, entity, Position, "x");  // 0
-setComponentValue(world, entity, Position, "x", 10);
+// Scalar fields use getComponentValue / setComponentValue
+const hp = getComponentValue(world, entity, Health, "current");  // 100
+setComponentValue(world, entity, Health, "current", 80);
+
+// Vector fields use dedicated access functions
+const pos = getComponentVectorView(world, entity, Position, "value");  // Float32Array [0, 0]
 ```
 
 #### Schema Types
@@ -207,6 +226,8 @@ The `Type` namespace provides storage-optimized types:
 | `Type.string()` | Array | Text data |
 | `Type.object<T>()` | Array | Complex nested objects |
 
+All numeric type factories accept an optional size parameter (2-16) to create **vector fields** -- see [Vector Fields](#vector-fields) below.
+
 Numeric types use TypedArrays for cache-friendly memory layout. Use the smallest type that fits your data.
 
 #### Adding Components is Idempotent
@@ -214,14 +235,82 @@ Numeric types use TypedArrays for cache-friendly memory layout. Use the smallest
 Adding a component that already exists does nothing -- the existing data is preserved.
 
 ```typescript
-addComponent(world, entity, Position, { x: 0, y: 0 });
-addComponent(world, entity, Position, { x: 99, y: 99 });  // ignored
+addComponent(world, entity, Health, { current: 100, max: 100 });
+addComponent(world, entity, Health, { current: 50, max: 50 });  // ignored
 
-getComponentValue(world, entity, Position, "x");  // still 0
+getComponentValue(world, entity, Health, "current");  // still 100
 ```
 
 💡 **Tip:** Use `hasComponent()` to check first if you need conditional addition, or `setComponentValue()` to update existing data.
 
+#### Batch Adding Components
+
+Use `addComponents()` to attach multiple components in one call:
+
+```typescript
+addComponents(world, entity, [
+  [Position, { value: [0, 0] }],
+  [Velocity, { value: [1, 0] }],
+  Player,
+]);
+```
+
+Each entry is either a standalone ID (tag, entity, schema-less pair) or a `[component, data]` tuple for data components.
+
+#### Vector Fields
+
+When component fields represent logically grouped numbers (positions, colors, directions), use **vector fields** to store them interleaved in a single TypedArray column. Pass a size (2-16) to any numeric type factory:
+
+```typescript
+import {
+  defineComponent,
+  addComponent,
+  getComponentVectorValue,
+  setComponentVectorValue,
+  getComponentVectorView,
+  Type,
+} from "iris-ecs";
+
+const Position = defineComponent("Position", { value: Type.f32(2) });
+const Color = defineComponent("Color", { value: Type.u32(4) });
+
+const entity = createEntity(world);
+addComponent(world, entity, Position, { value: [10, 20] });
+addComponent(world, entity, Color, { value: [255, 128, 0, 255] });
+```
+
+Vector fields use dedicated access functions instead of the scalar `getComponentValue` / `setComponentValue`:
+
+```typescript
+// Copy-based read -- returns a tuple (e.g., [number, number])
+const pos = getComponentVectorValue(world, entity, Position, "value");
+
+// Copy-based write
+setComponentVectorValue(world, entity, Position, "value", [30, 40]);
+
+// Zero-copy view -- returns a TypedArray subarray backed by the column buffer
+const view = getComponentVectorView(world, entity, Position, "value");
+view[0] += 1.0; // direct mutation, no copy
+```
+
+The zero-copy view shares the underlying buffer -- mutations are immediate. Views are invalidated if the archetype resizes (when new entities are added and capacity grows). Use views within a system tick; do not cache across frames.
+
+Components can mix scalar and vector fields:
+
+```typescript
+const Particle = defineComponent("Particle", {
+  position: Type.f32(3),
+  mass: Type.f32(),
+});
+
+addComponent(world, entity, Particle, { position: [0, 0, 0], mass: 1.0 });
+
+const mass = getComponentValue(world, entity, Particle, "mass");            // number
+const pos = getComponentVectorValue(world, entity, Particle, "position");   // [number, number, number]
+```
+
+TypeScript enforces the scalar/vector boundary at the type level -- `getComponentValue` rejects vector fields, and `getComponentVectorValue` rejects scalar fields.
+
 ### Resources
 
 A **Resource** is a global singleton -- world-level data that isn't attached to any specific entity. Define resources using regular components and store them with `addResource()`.
@@ -261,6 +350,32 @@ queryEntities(world, [Time], (entity) => {
 
 Use resources for frame timing, configuration, asset registry, input state, physics settings, or any global data that systems need but doesn't belong to a specific entity.
 
+Resources with vector fields use dedicated access functions, mirroring the component vector API:
+
+```typescript
+import {
+  defineComponent,
+  addResource,
+  getResourceVectorValue,
+  setResourceVectorValue,
+  getResourceVectorView,
+  Type,
+} from "iris-ecs";
+
+const Gravity = defineComponent("Gravity", { value: Type.f64(3) });
+addResource(world, Gravity, { value: [0, -9.81, 0] });
+
+// Copy-based read
+const g = getResourceVectorValue(world, Gravity, "value"); // [number, number, number]
+
+// Copy-based write
+setResourceVectorValue(world, Gravity, "value", [0, -20, 0]);
+
+// Zero-copy view
+const view = getResourceVectorView(world, Gravity, "value"); // Float64Array
+view[1] = -15; // direct mutation
+```
+
 ### Relations
 
 A **Relation** describes a directed connection between two entities. Combine a relation with a target using `pair()` to create a pair -- pairs are added to entities like components.
@@ -358,22 +473,24 @@ An **Archetype** groups entities that share the same component set. All entities
 
 ```
 Archetype [Position, Velocity]
-┌─────────┬─────────┬─────────┐
-│ Entity  │ Pos.x/y │ Vel.x/y │
-├─────────┼─────────┼─────────┤
-│ bullet1 │  10, 5  │  1, 0   │
-│ bullet2 │  15, 8  │  1, 0   │
-└─────────┴─────────┴─────────┘
+┌─────────┬──────────────────┬──────────────────┐
+│ Entity  │ Position (vec2)  │ Velocity (vec2)  │
+├─────────┼──────────────────┼──────────────────┤
+│ bullet1 │  [10, 5]         │  [1, 0]          │
+│ bullet2 │  [15, 8]         │  [1, 0]          │
+└─────────┴──────────────────┴──────────────────┘
 
 Archetype [Position, Velocity, Health]
-┌─────────┬─────────┬─────────┬─────────┐
-│ Entity  │ Pos.x/y │ Vel.x/y │ Health  │
-├─────────┼─────────┼─────────┼─────────┤
-│ player  │   0, 0  │   1, 0  │   100   │
-│ enemy   │  50, 20 │  -1, 0  │    50   │
-└─────────┴─────────┴─────────┴─────────┘
+┌─────────┬──────────────────┬──────────────────┬─────────┐
+│ Entity  │ Position (vec2)  │ Velocity (vec2)  │ Health  │
+├─────────┼──────────────────┼──────────────────┼─────────┤
+│ player  │  [0, 0]          │  [1, 0]          │   100   │
+│ enemy   │  [50, 20]        │  [-1, 0]         │    50   │
+└─────────┴──────────────────┴──────────────────┴─────────┘
 ```
 
+Vector fields like Position store all elements interleaved in a single TypedArray column: `[x0, y0, x1, y1, ...]`. This keeps each entity's vector contiguous in memory for cache-friendly access.
+
 Within an archetype, component data is stored in **columns** (TypedArrays for numeric types). When a query iterates entities with `Position` and `Velocity`, it walks through archetypes that contain both components. This columnar layout keeps data contiguous rather than scattered across objects, reducing memory overhead and enabling efficient iteration.
 
 Adding or removing a component moves an entity to a different archetype. This is more expensive than reading or writing component values, so prefer stable component sets for entities that update frequently.
@@ -389,7 +506,7 @@ import { queryEntities, queryFirstEntity, cacheQuery, not } from "iris-ecs";
 
 // Iterate all entities with Position and Velocity
 queryEntities(world, [Position, Velocity], (entity) => {
-  const x = getComponentValue(world, entity, Position, "x");
+  const pos = getComponentVectorView(world, entity, Position, "value")!;
   // ...
 });
 
@@ -401,7 +518,7 @@ Inline terms (arrays) work anywhere, but in systems it's advised to pre-build qu
 
 ```typescript
 const mySystem = defineSystem("mySystem", (world) => {
-  const movers = cacheQuery(world, Position, Velocity);
+  const movers = cacheQuery(world, [Position, Velocity]);
 
   return () => {
     queryEntities(world, movers, (entity) => {
@@ -433,6 +550,50 @@ queryEntities(world, [Position, Velocity, not(Frozen), not(Disabled)], (entity)
 
 Queries match archetypes where all required components are present and no excluded components exist. Matched archetypes are cached and auto-update when archetypes are created or destroyed.
 
+#### Column Iteration
+
+For performance-critical systems, `queryColumns()` provides direct access to the underlying TypedArray columns instead of iterating entity-by-entity. The callback receives the entity array and a columns tuple for each matching archetype. Each element in the tuple corresponds to a data-bearing component in query term order:
+
+```typescript
+import { queryColumns, cacheQuery, not } from "iris-ecs";
+
+queryColumns(world, [Player, Position, Velocity, not(Dead)], (entities, [pos, vel]) => {
+  // pos.value and vel.value are raw TypedArrays (e.g. Float32Array)
+  // entities.length tells you how many entities are in this archetype
+  for (let i = 0; i < entities.length; i++) {
+    const offset = i * 2; // vec2 stride
+    pos.value[offset] += vel.value[offset];
+    pos.value[offset + 1] += vel.value[offset + 1];
+  }
+});
+```
+
+Tags and data-less pairs are omitted from the columns tuple -- only data-bearing components and relation pairs appear as elements. The element order matches the order of data-bearing terms in the query.
+
+Pre-cached queries work the same way:
+
+```typescript
+const movementSystem = defineSystem("movementSystem", (world) => {
+  const movers = cacheQuery(world, [Position, Enemy, Velocity, not(Frozen)]);
+
+  return () => {
+    queryColumns(world, movers, (entities, [pos, vel]) => {
+      for (let i = 0; i < entities.length; i++) {
+        const offset = i * 2;
+        pos.value[offset] += vel.value[offset];
+        pos.value[offset + 1] += vel.value[offset + 1];
+      }
+    });
+  };
+});
+```
+
+Return `false` from the callback to stop iteration early (same as `queryEntities`).
+
+`queryColumns` does not support `added()` or `changed()` modifiers -- use `queryEntities` for change detection.
+
+💡 **Tip:** Use `queryColumns` when you need to process large numbers of entities with tight loops over TypedArray data. Use `queryEntities` for entity-level logic, change detection, or when you need per-entity API calls like `getComponentValue`.
+
 ### Systems
 
 A **System** is a function that operates on the world. Systems query entities, read and write components, emit events, and implement game logic.
@@ -449,24 +610,24 @@ import {
   run,
   stop,
   queryEntities,
-  getComponentValue,
-  setComponentValue,
+  getComponentVectorView,
   getResourceValue,
 } from "iris-ecs";
 
 const movementSystem = defineSystem("movementSystem", (world) => {
   // Init: cache queries and action getters once
-  const movers = cacheQuery(world, Position, Velocity);
+  const movers = cacheQuery(world, [Position, Velocity]);
 
   return () => {
     // Tick: runs every frame
     const dt = getResourceValue(world, Time, "delta") ?? 0;
 
     queryEntities(world, movers, (e) => {
-      const x = getComponentValue(world, e, Position, "x");
-      const vx = getComponentValue(world, e, Velocity, "x");
+      const pos = getComponentVectorView(world, e, Position, "value");
+      const vel = getComponentVectorView(world, e, Velocity, "value");
 
-      setComponentValue(world, e, Position, "x", x + vx * dt);
+      pos[0] += vel[0] * dt;
+      pos[1] += vel[1] * dt;
     });
   };
 });
@@ -484,8 +645,8 @@ For simple systems that don't need one-time setup, plain functions also work, an
 
 ```typescript
 function debugSystem(world) {
-  queryEntities(world, [Position], (e) => {
-    console.log(getComponentValue(world, e, Position, "x"));
+  queryEntities(world, [Health], (e) => {
+    console.log(getComponentValue(world, e, Health, "current"));
   });
 }
 
@@ -517,6 +678,34 @@ Without constraints, systems run in registration order. Use arrays for multiple
 
 `defineSystem` factory can be registered multiple times with different names via the `name` option: `addSystem(world, movementSystem, { name: "lateMovement" })`.
 
+#### System Sets
+
+**System sets** are named groups for ordering entire groups of systems relative to each other. Instead of wiring individual `before`/`after` between every physics and render system, declare the group-level constraint once:
+
+```typescript
+import { defineSystemSet, addSystemSet, addSystem } from "iris-ecs";
+
+const PhysicsSystems = defineSystemSet("PhysicsSystems");
+const RenderSystems = defineSystemSet("RenderSystems");
+
+addSystemSet(world, PhysicsSystems, { before: RenderSystems });
+addSystemSet(world, RenderSystems);
+
+addSystem(world, applyGravity, { set: PhysicsSystems });
+addSystem(world, detectCollisions, { set: PhysicsSystems, after: applyGravity });
+addSystem(world, drawSprites, { set: RenderSystems });
+addSystem(world, drawParticles, { set: RenderSystems });
+// All physics systems run before all render systems
+```
+
+Systems within a set still respect their own `before`/`after` constraints. A system can also order itself relative to a set without joining it:
+
+```typescript
+addSystem(world, debugOverlay, { after: PhysicsSystems, before: RenderSystems });
+```
+
+A system uses either `schedule` or `set`, not both -- the set inherits its schedule from `addSystemSet`.
+
 #### Schedules
 
 Systems are grouped into **schedules** -- named execution phases. The default pipeline runs these schedules every frame:
@@ -600,20 +789,20 @@ addSystem(world, loadAssetsSystem, { schedule: Startup });
 **Actions** bundle reusable operations with a world captured in closure. Define actions once, then call them without repeatedly passing the world.
 
 ```typescript
-import { defineActions, createEntity, addComponent } from "iris-ecs";
+import { defineActions, createEntity } from "iris-ecs";
 
 const spawnActions = defineActions((world) => ({
   player(x: number, y: number) {
-    const entity = createEntity(world);
-    addComponent(world, entity, Position, { x, y });
-    addComponent(world, entity, Player);
-    return entity;
+    return createEntity(world, [
+      [Position, { value: [x, y] }],
+      Player,
+    ]);
   },
   enemy(x: number, y: number) {
-    const entity = createEntity(world);
-    addComponent(world, entity, Position, { x, y });
-    addComponent(world, entity, Enemy);
-    return entity;
+    return createEntity(world, [
+      [Position, { value: [x, y] }],
+      Enemy,
+    ]);
   },
 }));
 
@@ -729,7 +918,7 @@ import {
 } from "iris-ecs";
 
 const physicsSetupSystem = defineSystem("physicsSetupSystem", (world) => {
-  const newBodies = cacheQuery(world, added(Position));
+  const newBodies = cacheQuery(world, [added(Position)]);
 
   return () => {
     // Entities where Position was added since this system's last run
@@ -740,7 +929,7 @@ const physicsSetupSystem = defineSystem("physicsSetupSystem", (world) => {
 });
 
 const healthBarSystem = defineSystem("healthBarSystem", (world) => {
-  const damaged = cacheQuery(world, changed(Health));
+  const damaged = cacheQuery(world, [changed(Health)]);
 
   return () => {
     // Entities where Health was modified (added OR value changed)
@@ -752,7 +941,7 @@ const healthBarSystem = defineSystem("healthBarSystem", (world) => {
 
 const minimapSystem = defineSystem("minimapSystem", (world) => {
   // Combine change detection with regular filters
-  const movedPlayers = cacheQuery(world, Player, changed(Position), not(Dead));
+  const movedPlayers = cacheQuery(world, [Player, changed(Position), not(Dead)]);
 
   return () => {
     queryEntities(world, movedPlayers, (e) => {

package/dist/archetype.d.ts

@@ -1,5 +1,5 @@
 import type { EntityId } from "./encoding.js";
-import type { SchemaRecord } from "./schema.js";
+import type { Schema, SchemaRecord, TypedArrayInstance } from "./schema.js";
 import type { World } from "./world.js";
 /**
  * Column storage type.
@@ -15,6 +15,16 @@ export type Column = Int8Array | Int16Array | Int32Array | Uint32Array | Float32
 export type FieldColumns = {
     [fieldName: string]: Column;
 };
+/**
+ * Map a schema record to its column types.
+ *
+ * Each field maps to the runtime array type used for storage.
+ *
+ * @internal
+ */
+export type FieldColumnsOf<S extends SchemaRecord> = {
+    [K in keyof S]: S[K] extends Schema<number> ? TypedArrayInstance : S[K] extends Schema<number[]> ? TypedArrayInstance : S[K] extends Schema<boolean> ? boolean[] : S[K] extends Schema<string> ? string[] : unknown[];
+};
 /**
  * Component tick storage for change detection.
  *
@@ -40,6 +50,13 @@ export type Archetype = {
     capacity: number;
     ticks: Map<EntityId, ComponentTicks>;
 };
+/**
+ * Derives the stride of a column from its length and the archetype capacity.
+ * Scalar columns return 1, vector columns return their stride (e.g., 2 for vec2).
+ *
+ * @internal
+ */
+export declare function getColumnStride(column: Column, capacity: number): number;
 /**
  * Hashes a sorted array of type IDs into a unique archetype key.
  *

package/dist/archetype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archetype.d.ts","sourceRoot":"","sources":["../src/archetype.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"archetype.d.ts","sourceRoot":"","sources":["../src/archetype.ts"],"names":[],"mappings":"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"}