@relu-interactives/spatial-ecs 0.2.2

package/dist/docs/guide/accessing-components.md

@@ -0,0 +1,399 @@
+# Accessing Components
+
+Every entity in the ECS world carries a set of components — typed data containers that describe its appearance, physics, audio, animation, and more. From inside a `Behaviour` script you can read and mutate any component on the entity at runtime using `this.getComponent(ComponentClass)`.
+
+## The `getComponent` API
+
+```ts
+getComponent<T extends Component>(componentClass: ComponentClass<T>): T | null
+```
+
+Returns the component instance of the requested type attached to the **same entity** as the script, or `null` if the entity does not have that component. Always null-check the result — components are optional and may not be present on every object.
+
+The recommended pattern is to cache the reference in `onInit` so you avoid the lookup overhead every frame:
+
+```ts
+import { Behaviour } from "@relu-interactives/spatial-ecs";
+import { PhysicsComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class Example extends Behaviour {
+  private physics: PhysicsComponent | null = null;
+
+  onInit() {
+    this.physics = this.getComponent(PhysicsComponent);
+  }
+
+  onUpdate() {
+    if (!this.physics) return;
+    // use this.physics …
+  }
+}
+```
+
+> `this.transform` is a pre-cached `TransformComponent` already available on every `Behaviour` — no need to call `getComponent(TransformComponent)` manually.
+
+---
+
+## Component examples
+
+### TransformComponent
+
+Position, rotation (radians, Euler XYZ), and scale in local space. Available on every entity as `this.transform`.
+
+```ts
+import { Behaviour } from "@relu-interactives/spatial-ecs";
+import { TransformComponent } from "@relu-interactives/spatial-ecs/components";
+import * as THREE from "three";
+
+export default class MoveUp extends Behaviour {
+  onUpdate() {
+    // Mutate position directly — picked up by TransformSyncSystem each frame
+    this.transform.position.y += this.deltaTime;
+
+    // Or use the typed helpers for Vector3 / Euler / Quaternion inputs
+    this.transform.setPosition(new THREE.Vector3(0, 2, 0));
+    this.transform.setRotation(new THREE.Euler(0, Math.PI / 2, 0));
+    this.transform.setScale(new THREE.Vector3(2, 2, 2));
+  }
+}
+```
+
+---
+
+### PhysicsComponent
+
+Rigidbody simulation and collider. Exposes the live Rapier `rigidBody` and `collider` handles along with their authoring state (`rigidbody`, `collider`).
+
+```ts
+import { Behaviour, type FloatInput } from "@relu-interactives/spatial-ecs";
+import { PhysicsComponent } from "@relu-interactives/spatial-ecs/components";
+import { Vector3 } from "three";
+
+export default class Jumper extends Behaviour {
+  data = {
+    jumpForce: 8 as FloatInput,
+  };
+
+  private physics: PhysicsComponent | null = null;
+
+  onInit() {
+    this.physics = this.getComponent(PhysicsComponent);
+  }
+
+  onUpdate() {
+    if (!this.physics?.rigidBody) return;
+
+    // Apply an upward impulse every frame (combine with input checks in practice)
+    this.physics.rigidBody.addForce(
+      new Vector3(0, this.data.jumpForce, 0),
+      true, // wake the body if sleeping
+    );
+
+    // Change mass at runtime
+    this.physics.rigidbody.mass = 2;
+
+    // Lock rotation so the body can't tip over
+    this.physics.rigidbody.lockRotations = true;
+  }
+}
+```
+
+**Key fields:**
+
+| Field | Type | Description |
+|---|---|---|
+| `rigidBody` | `RapierRigidBody \| null` | Live physics body handle. `null` until simulation starts. |
+| `collider` | `RapierCollider \| null` | Live collider handle. |
+| `rigidbody` | `RigidbodyState` | Serialized authoring state (type, mass, damping, gravity scale, lock flags). |
+| `colliderState` | `ColliderState` | Serialized collider state (shape, size, offset, friction, restitution, sensor). |
+
+---
+
+### AudioComponent
+
+Plays a stereo or 3D positional audio clip.
+
+```ts
+import { Behaviour, type FloatInput } from "@relu-interactives/spatial-ecs";
+import { AudioComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class SoundController extends Behaviour {
+  data = {
+    volume: 1 as FloatInput,
+  };
+
+  private audio: AudioComponent | null = null;
+
+  onInit() {
+    this.audio = this.getComponent(AudioComponent);
+  }
+
+  onUpdate() {
+    if (!this.audio) return;
+
+    // Adjust volume at runtime
+    this.audio.options.volume = this.data.volume;
+
+    // Trigger playback
+    if (!this.audio.isPlaying) {
+      this.audio.play();
+    }
+  }
+}
+```
+
+**Key fields / methods:**
+
+| Member | Description |
+|---|---|
+| `path` | Source URL or `localasset://` path of the audio file. |
+| `options.volume` | Linear gain `[0, 1]`. |
+| `options.loop` | Whether the clip loops. |
+| `options.pitch` | Playback rate multiplier. |
+| `options.positional` | Enable 3D spatial audio. |
+| `isPlaying` | Runtime-only — `true` when actively playing. |
+| `play()` | Start or resume playback. |
+| `pause()` | Pause mid-playback (position is preserved). |
+| `stop()` | Stop and reset to the beginning. |
+
+---
+
+### AnimationComponent
+
+Clip catalog and state-machine playback. Use `switchState` to trigger named transitions.
+
+```ts
+import { Behaviour, type DropdownInput } from "@relu-interactives/spatial-ecs";
+import { AnimationComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class AnimationController extends Behaviour {
+  data = {
+    state: {
+      value: "idle",
+      options: [
+        { label: "Idle",   value: "idle" },
+        { label: "Walk",   value: "walk" },
+        { label: "Run",    value: "run" },
+      ],
+    } as DropdownInput,
+  };
+
+  private anim: AnimationComponent | null = null;
+
+  onInit() {
+    this.anim = this.getComponent(AnimationComponent);
+    if (this.anim) {
+      this.anim.switchState(this.data.state.value);
+    }
+  }
+
+  onUpdate() {
+    if (!this.anim) return;
+
+    // Slow down playback at runtime
+    this.anim.timeScale = 0.5;
+
+    // Switch to a different clip state
+    if (this.anim.activeStateName !== this.data.state.value) {
+      this.anim.switchState(this.data.state.value);
+    }
+  }
+}
+```
+
+**Key fields / methods:**
+
+| Member | Description |
+|---|---|
+| `activeStateName` | Name of the currently playing state. |
+| `timeScale` | Playback speed multiplier (`1` = real-time). |
+| `paused` | Pause all playback. |
+| `crossFadeDuration` | Default blend time when switching states (seconds). |
+| `switchState(name)` | Transition to a named state (cross-fades). |
+| `addState(entry)` | Register a new state at runtime. |
+| `clipCatalog` | Array of all loaded clips with metadata. |
+
+---
+
+### LightComponent
+
+Color, intensity, and type-specific light parameters. The live `light` property is the underlying three.js object.
+
+```ts
+import { Behaviour, type FloatInput, type ColorInput } from "@relu-interactives/spatial-ecs";
+import { LightComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class LightPulse extends Behaviour {
+  data = {
+    minIntensity: 0.5 as FloatInput,
+    maxIntensity: 3   as FloatInput,
+    speed:        2   as FloatInput,
+    color:        "#ffeeaa" as ColorInput,
+  };
+
+  private light: LightComponent | null = null;
+  private t = 0;
+
+  onInit() {
+    this.light = this.getComponent(LightComponent);
+    if (this.light) {
+      this.light.setValues({ color: this.data.color });
+    }
+  }
+
+  onUpdate() {
+    if (!this.light) return;
+    this.t += this.deltaTime * this.data.speed;
+
+    const intensity =
+      this.data.minIntensity +
+      (Math.sin(this.t) * 0.5 + 0.5) *
+        (this.data.maxIntensity - this.data.minIntensity);
+
+    // setValues patches only the fields you provide
+    this.light.setValues({ intensity });
+  }
+}
+```
+
+**Key fields / methods:**
+
+| Member | Description |
+|---|---|
+| `light` | Live `THREE.Light` instance placed in the scene. |
+| `type` | Three.js class name (`"DirectionalLight"`, `"PointLight"`, `"SpotLight"`, etc.). |
+| `values.color` | Hex color string. |
+| `values.intensity` | Brightness multiplier. |
+| `values.castShadow` | Whether the light casts shadows. |
+| `values.distance` | Max range for point/spot lights. |
+| `values.angle` | Cone half-angle in radians (SpotLight). |
+| `setValues(patch)` | Update any subset of `values` and sync to the live light. |
+
+---
+
+### MaterialComponent
+
+Per-slot PBR material state and texture maps.
+
+```ts
+import { Behaviour, type ColorInput, type FloatInput } from "@relu-interactives/spatial-ecs";
+import { MaterialComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class MaterialSwap extends Behaviour {
+  data = {
+    color:     "#ff4400" as ColorInput,
+    roughness: 0.3       as FloatInput,
+    metalness: 0.8       as FloatInput,
+  };
+
+  private mat: MaterialComponent | null = null;
+
+  onInit() {
+    this.mat = this.getComponent(MaterialComponent);
+  }
+
+  onUpdate() {
+    if (!this.mat) return;
+
+    // applyValues patches one or more fields on a slot (default slot index 0)
+    this.mat.applyValues(0, {
+      color:     this.data.color,
+      roughness: this.data.roughness,
+      metalness: this.data.metalness,
+    });
+  }
+}
+```
+
+**Key fields / methods:**
+
+| Member | Description |
+|---|---|
+| `values` | Array of `MaterialValueState` objects, one per mesh slot. |
+| `values[i].color` | Base color as `#rrggbb`. |
+| `values[i].roughness` | PBR roughness `[0, 1]`. |
+| `values[i].metalness` | PBR metalness `[0, 1]`. |
+| `values[i].opacity` | Surface opacity `[0, 1]`. Pair with `transparent: true`. |
+| `values[i].emissive` | Emissive color as `#rrggbb`. |
+| `values[i].emissiveIntensity` | Emissive multiplier. |
+| `values[i].wireframe` | Render as wireframe. |
+| `applyValues(slotIndex, patch)` | Patch fields and sync to the live three.js material. |
+
+---
+
+### VideoComponent
+
+Video-texture playback with optional green-screen keying.
+
+```ts
+import { Behaviour } from "@relu-interactives/spatial-ecs";
+import { VideoComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class VideoController extends Behaviour {
+  private video: VideoComponent | null = null;
+
+  onInit() {
+    this.video = this.getComponent(VideoComponent);
+  }
+
+  onUpdate() {
+    if (!this.video) return;
+
+    // Adjust volume while playing
+    this.video.options.volume = 0.5;
+
+    if (!this.video.isPlaying) {
+      this.video.play();
+    }
+  }
+}
+```
+
+**Key fields / methods:**
+
+| Member | Description |
+|---|---|
+| `path` | Source URL or `localasset://` path of the video file. |
+| `options.loop` | Loop playback. |
+| `options.volume` | Linear gain `[0, 1]`. |
+| `options.isGreenScreen` | Enable chroma-key compositing. |
+| `options.backgroundColor` | Color to key out. |
+| `videoElement` | Underlying `HTMLVideoElement`. `null` until built. |
+| `isPlaying` | Runtime-only — `true` when playing. |
+| `play()` | Start or resume playback. |
+| `pause()` | Pause mid-playback. |
+| `stop()` | Stop and reset. |
+
+---
+
+## Querying components on other entities
+
+`getComponent` only reaches the entity the script is attached to. To read components on another entity, use `this.world.getEntityByName(name)` for the simplest lookup:
+
+```ts
+import { Behaviour } from "@relu-interactives/spatial-ecs";
+import { LightComponent } from "@relu-interactives/spatial-ecs/components";
+
+export default class RemoteControl extends Behaviour {
+  onUpdate() {
+    // Find an entity by name, then read its LightComponent
+    const entity = this.world.getEntityByName("Sun");
+    if (!entity) return;
+
+    const light = this.world.getComponent(entity.id, LightComponent);
+    if (light) light.setValues({ intensity: 2 });
+  }
+}
+```
+
+You can also use `this.world.getEntityById(id)` when you already have the entity ID, or `this.world.getAllEntities()` to iterate over every entity in the scene.
+
+See [World API](./world-api) for the full set of entity and component query methods.
+
+---
+
+## See also
+
+- [Custom Behaviours](./authoring-a-behaviour) — script anatomy and lifecycle
+- [Inspector Data Binding](./inspector-data-binding) — exposing fields to the inspector
+- [World API](./world-api) — querying entities and components across the scene

package/dist/docs/guide/authoring-a-behaviour.md

@@ -0,0 +1,166 @@
+# Custom Behaviours
+
+A **Behaviour** is a user-authored TypeScript class that runs per-frame logic on a single entity. Behaviours are attached to entities through the `ScriptComponent`, and are dispatched each frame by the `ScriptBehaviourSystem`.
+
+## Anatomy of a script
+
+```ts
+import {
+  Behaviour,
+  type FloatInput,
+  type DropdownInput,
+} from "@relu-interactives/spatial-ecs";
+
+export default class Spinner extends Behaviour {
+  data = {
+    speed: 1 as FloatInput,
+    axis: {
+      value: "y",
+      options: [
+        { label: "X", value: "x" },
+        { label: "Y", value: "y" },
+        { label: "Z", value: "z" },
+      ],
+    } as DropdownInput,
+  };
+
+  init() {
+    // Called once before the first update().
+  }
+
+  onUpdate() {
+    // Called every frame while the script is enabled.
+    const axis = this.data.axis.value as "x" | "y" | "z";
+    this.transform.rotation[axis] += this.data.speed * this.deltaTime;
+  }
+
+  dispose() {
+    // Optional cleanup when the entity is destroyed
+    // or the script is detached.
+  }
+}
+```
+
+> [!IMPORTANT]
+> For the runtime to recognize the class make sure the **default export** of the class subclasses [`Behaviour`](/api/Behaviour/classes/Behaviour).
+
+## Available context
+
+When `init()` / `onUpdate()` runs, the following fields are populated:
+
+| Field | Description |
+| --- | --- |
+| `this.world` | The owning [`World`](/api/index/classes/World). |
+| `this.entityId` | Numeric entity id. |
+| `this.entity` | A [`WorldEntityView`](/api/types/type-aliases/WorldEntityView) for the entity (id + components). |
+| `this.transform` | Mutable [`TransformComponent`](/api/components/classes/TransformComponent) (position/rotation/scale). |
+| `this.threeRef` | The [`Object3DRef`](/api/components/classes/Object3DRef) wrapping the live three.js object. |
+| `this.data` | The `ScriptComponent.data` payload (your inspector fields). |
+| `this.deltaTime` | Seconds since last frame. |
+
+## Helper methods
+
+`Behaviour` exposes a small ergonomics surface so scripts rarely need to touch three.js directly:
+
+- World-space math: [`getWorldPosition`](/api/Behaviour/classes/Behaviour#getworldposition), [`getWorldDirection`](/api/Behaviour/classes/Behaviour#getworlddirection), [`directionTo`](/api/Behaviour/classes/Behaviour#directionto), [`distanceTo`](/api/Behaviour/classes/Behaviour#distanceto).
+- Smooth motion: [`lerpTo`](/api/Behaviour/classes/Behaviour#lerpto), [`slerpTo`](/api/Behaviour/classes/Behaviour#slerpto), [`lookAt`](/api/Behaviour/classes/Behaviour#lookat).
+- Component access: [`getComponents`](/api/Behaviour/classes/Behaviour#getcomponents), [`getComponent`](/api/Behaviour/classes/Behaviour#getcomponent).
+- Hierarchy: [`getEntity`](/api/Behaviour/classes/Behaviour#getentity), [`getParent`](/api/Behaviour/classes/Behaviour#getparent), [`getChildren`](/api/Behaviour/classes/Behaviour#getchildren).
+
+See the full [`Behaviour` API](/api/Behaviour/classes/Behaviour).
+
+## Lifecycle hooks
+
+| Hook | When |
+| --- | --- |
+| `init()` | Once, before the first `onUpdate()`. |
+| `onUpdate()` | Every frame while enabled. |
+| `dispose()` | When the script is detached or the entity destroyed. |
+| `onSelect()` / `onDeselect()` | Events fired when a user clicks or taps an object in the scene. |
+| `onTargetFound()` / `onTargetLost()` | Image-tracking target visibility changed. |
+
+`update(deltaTime)` is implemented by the base class, do not override it. Override `onUpdate()` instead.
+
+## Where to put scripts
+
+In a Relu Spatial project, scripts live under the project's `assets/` directory. The editor compiles them through esbuild and exposes them via the script registry.
+
+## Inspector data binding
+
+The `data` object is the bridge between the editor inspector and your script. Use typed input annotations — `FloatInput`, `ColorInput`, `DropdownInput`, etc. — to control which inspector control renders for each field:
+
+```ts
+import {
+  Behaviour,
+  type FloatInput,
+  type DropdownInput,
+} from "@relu-interactives/spatial-ecs";
+
+export default class Spinner extends Behaviour {
+  data = {
+    speed: 1 as FloatInput,
+    axis: {
+      value: "y",
+      options: [
+        { label: "X", value: "x" },
+        { label: "Y", value: "y" },
+        { label: "Z", value: "z" },
+      ],
+    } as DropdownInput,
+  };
+
+  onUpdate() {
+    const axis = this.data.axis.value as "x" | "y" | "z";
+    this.transform.rotation[axis] += this.data.speed * this.deltaTime;
+  }
+}
+```
+
+See [Inspector Data Binding](./inspector-data-binding) for the full reference of all input types (`TextInput`, `ColorInput`, `Vector2Input`, `Vector3Input`, `SliderInput`, `CheckboxInput`, `ToggleInput`, `AssetInput`, and more).
+
+See [Accessing Components](./accessing-components) to read and mutate built-in components such as `PhysicsComponent`, `AudioComponent`, `AnimationComponent`, `LightComponent`, and `MaterialComponent` from script.
+
+See [Reading Input](./reading-input) for the full keyboard and mouse input API, `KeyboardKeys` reference, and scripting examples.
+
+## Running scripts in the editor
+
+By default, `Behaviour` scripts only execute at preview or runtime. Setting **Execute in editor** to `true` on a script entry (via the inspector toggle) enables the full lifecycle (`init` → `onUpdate`) while the editor is open.
+
+This is useful for Three.js functionality the editor's object palette does not expose — custom shaders, procedural geometry, grass, post-processing passes, and similar.
+
+```ts
+import { Behaviour } from "@relu-interactives/spatial-ecs";
+import * as THREE from "three";
+
+export default class GrassPlane extends Behaviour {
+  private mesh: THREE.Mesh | null = null;
+
+  protected init() {
+    // Access the live Three.js scene directly.
+    const scene = this.world.getScene();
+
+    const geo = new THREE.PlaneGeometry(10, 10, 32, 32);
+    const mat = new THREE.MeshStandardMaterial({ color: 0x228b22 });
+    this.mesh = new THREE.Mesh(geo, mat);
+    scene.add(this.mesh);
+  }
+
+  protected dispose() {
+    if (this.mesh) {
+      this.world.getScene().remove(this.mesh);
+      this.mesh = null;
+    }
+  }
+}
+```
+
+> [!WARNING]
+> **Undo-history churn** — avoid writing to ECS components (e.g. `TransformComponent`) on every frame when `executeInEditor` is `true`. The editor's change-detection system records a new undo entry each time a component snapshot differs, which will flood the undo stack and cause performance degradation. Keep per-frame mutations in local Three.js state (objects, materials, uniforms) rather than in ECS component fields.
+
+Available world accessors in editor mode:
+
+| Accessor | Returns |
+| --- | --- |
+| `this.world.getScene()` | `THREE.Scene` |
+| `this.world.getCamera()` | `THREE.PerspectiveCamera` |
+| `this.world.getRenderer()` | `THREE.WebGLRenderer` |

package/dist/docs/guide/behaviour-lifecycle.md

@@ -0,0 +1,43 @@
+# Behaviour Lifecycle & Events
+
+`Behaviour` is dispatched by the `ScriptBehaviourSystem` each frame. Knowing the precise order of hooks helps you place state setup, simulation, and cleanup correctly.
+
+## Frame order
+
+```
+World.update(dt)
+  ├── ObjectManagementSystem        # parent reconciliation, entity lifecycle
+  ├── (geometry / material systems)
+  ├── (custom user systems)
+  ├── ScriptBehaviourSystem
+  │     ├── for each enabled script:
+  │     │     ├── if first run → init()
+  │     │     └── onUpdate()
+  ├── (sync systems)
+  ├── AnimationSystem
+  ├── TransformSyncSystem
+  └── RenderSystem
+```
+
+This ordering means:
+
+- `this.transform` mutations in `onUpdate()` are picked up the same frame by `TransformSyncSystem` and applied to the three.js object.
+- Animation runs *after* scripts, so animating a value will overwrite a script's mutation on the same property.
+
+## Hook reference
+
+| Hook | Override? | Frequency | Runs in editor? | Purpose |
+| --- | --- | --- | --- | --- |
+| `init()` | Yes (protected) | Once before first `onUpdate` | Only when `executeInEditor: true` | Default and validate `data`, cache references |
+| `onUpdate()` | Yes (protected) | Every frame | Only when `executeInEditor: true` | Per-frame logic |
+| `dispose()` | Yes | Once on detach/destroy | Only when `executeInEditor: true` | Release timers, listeners, resources |
+| `onSelect()` / `onDeselect()` | Optional | Editor selection toggles | Yes | UX-only hooks |
+| `onTargetFound()` / `onTargetLost()` | Optional | Image tracking | No | React to AR target visibility |
+
+Set `executeInEditor: true` on a script entry in the inspector to opt a script into the full lifecycle in editor mode. See [Running scripts in the editor](./authoring-a-behaviour#running-scripts-in-the-editor).
+
+<!-- ## Tips
+
+- **Do not** capture `this.threeRef.object` outside hooks; the underlying `Object3D` may be replaced during hot reload.
+- **Do** read `this.deltaTime` rather than computing your own delta, it respects engine pause / step.
+- Use `getComponent`/`getComponents` lazily inside `onUpdate` rather than caching, unless you also handle the entity destroyed/replaced case. -->

package/dist/docs/guide/component-catalog.md

@@ -0,0 +1,59 @@
+# Component Catalog
+
+Every entity in `@relu-interactives/spatial-ecs` is a bag of components. This catalog is a directory of every component shipped in the package, grouped by responsibility. Each entry below has a dedicated page with a screenshot of the editor inspector and a full property reference.
+
+![Component Catalog Image](/images/components-catalog.png)
+
+> [!TIP]
+> Browsing the API? The auto-generated TypeDoc reference for every component class lives under [API Reference → components](../api/components/).
+
+## Identity & hierarchy
+
+- [Name](./components/name) — human-readable label shown in the editor hierarchy.
+- [Entity Type](./components/entity-type) — tag identifying which factory created the entity.
+- [Parent](./components/parent-id) — parent entity reference; reconciled into the three.js scene graph each frame.
+
+## Transform & motion
+
+- [Transform](./components/transform) — position, rotation (radians), and scale.
+- [Object3D Reference](./components/object3d-ref) — wraps the live `THREE.Object3D` plus a visibility flag.
+
+## Rendering
+
+- [Mesh](./components/mesh) — primitive mesh `Object3D`.
+- [Mesh Geometry](./components/mesh-geometry) — editable parametric geometry (cube, sphere, plane, capsule, cylinder).
+- [Material](./components/material) — material catalog and texture maps.
+- [Image](./components/image) — 2D image rendered as a textured quad.
+- [Sprite](./components/sprite) — camera-facing billboard.
+- [Video](./components/video) — video texture with optional green-screen keying.
+- [Model](./components/model) — GLTF/GLB asset reference loaded asynchronously.
+
+## Lighting & atmosphere
+
+- [Light](./components/light) — directional, point, spot, ambient, hemisphere, or rect-area light.
+- [Environment](./scene/environment) — singleton skybox, fog, and gravity state.
+- [Postprocessing](./scene/postprocessing) — singleton postprocessing stack (bloom, DoF, vignette, tonemap, etc.).
+- [Camera](./components/camera) — perspective/orthographic camera with `3d`/`ar` runtime modes.
+
+## Audio
+
+- [Audio](./components/audio) — audio clip with positional/listener options.
+
+## Physics
+
+- [Physics](./components/physics) — combined Rapier rigid body (dynamic, fixed, kinematic) and collider (cuboid, ball, capsule, cylinder, trimesh) with per-axis motion locks and sensor support.
+
+## AR & image tracking
+
+- [Image Target](./components/image-target) — image-tracking metadata and compiled `.mind` reference.
+- [Image Target Anchor](./components/image-target-anchor) — entity anchored to a tracked image target.
+
+## Animation
+
+- [Animation](./components/animation) — clip catalog and `AnimationStateMachine`.
+
+## Scripts
+
+- [Script](./components/script) — authored behaviour scripts attached to an entity.
+
+