@adobe/ecs 0.1.0 → 0.2.0

package/src/guide/00-keys.ts

@@ -0,0 +1,35 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System, World } from "../index.js";
+
+// Each key a Symbol() bound at the module's top level.
+export const score = Symbol();
+export const bonus = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [score]: { type: number };
+    }
+    interface Resources {
+        [bonus]: { type: number; default: 5 };
+    }
+}
+
+const spawn = System.create(({ commands }) => {
+    commands.spawn([score])({ [score]: 10 });
+});
+
+// No generics: the declarations type row[score] and resources[bonus] as numbers.
+const award = System.create({ components: { with: [score] } }, (row, { resources }) => {
+    row[score] += resources[bonus];
+});
+
+const read = System.create({ observer: true, components: { with: [score] } }, row => {
+    console.log("score", row[score]);
+});
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(spawn);
+    await world.run(award);
+    await world.run(read);
+};

package/src/guide/00-setup.md

@@ -0,0 +1,24 @@
+# Setup
+
+Install `@adobe/ecs` and add its build plugin to Vite:
+
+```ts
+import { Compiler } from "@adobe/ecs/compiler";
+export default defineConfig({ plugins: [Compiler.plugin()] });
+```
+
+The plugin is part of the API, not an optimization. It reads each system's body to infer what the body reads and
+writes, compiles kernels, reads the schema of each value from its declared type, and gives every key and system an id.
+
+- A library builds with `Compiler.plugin({ library: true })`, so its build ships the registrations its declarations
+  give.
+- Kernels run on workers loaded as separate chunks, so the plugin sets Vite's `worker.format` to `"es"` unless the
+  config sets it.
+
+Components and resources are keys, each declared once with its type: [Keys and declarations](00-keys.md).
+
+**Systems** declare only what their body can't show: the entities they run over, their change filters and
+conditions, and their order. Write the body inline in `System.create`, indexing rows and resources by key, so the
+plugin can read it.
+
+Each chapter's example is a program whose `main` creates worlds, runs systems on them and logs what they did.

package/src/guide/01-resources.md

@@ -0,0 +1,22 @@
+# Resources
+
+A *resource* is a value a world holds once: a setting, a clock, a handle to an audio context, [declared](01-resources.ts#L14-L23)
+in `Resources`.
+
+A world starts each resource at the first of these that applies:
+
+1. the value given to `World.create`, as [the moon](01-resources.ts#L30) gives `gravity`;
+2. its `default` trait, a literal;
+3. its type's namespace's `default`, as [`Height`](01-resources.ts#L11-L12) gives; every world shares that value, so
+   it's read-only;
+4. a reduction's identity ([Reductions](15-reductions.md)), `null` for a nullable type, the zero value (`0`, `false`,
+   `""`, item by item), or an empty `ReadonlyMap` or `ReadonlySet` of each world's own.
+
+Data, such as numbers, strings, tuples, structs, maps and sets, is held as a value: a system replaces it whole. A value
+that isn't data, such as an `AudioContext`, is stored as it is; a change inside it is seen only once the resource is
+written back. An `Entity` resource with no entity holds `Entity.none`, which is `0` rather than `null`, so it stays data
+every thread can read.
+
+A system reads resources by key. With `observer: true` it only reads, and runs after the world's changes apply.
+[`run`](01-resources.ts#L31-L32) runs a system once, and resolves to what the body returns, for a system without
+components.

package/src/guide/01-resources.out

@@ -0,0 +1,2 @@
+[ -9.8, -Infinity, Map(0) {}, null, 0 ]
+[ -1.6, -Infinity, Map(0) {}, null, 0 ]

package/src/guide/01-resources.ts

@@ -0,0 +1,33 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity, System, World, type F32 } from "../index.js";
+
+export const gravity = Symbol();
+export const floor = Symbol();
+export const names = Symbol();
+export const audio = Symbol();
+export const focused = Symbol();
+
+// A type whose namespace gives the value it starts at.
+export type Height = F32;
+export const Height = { default: -Infinity } as const;
+
+declare module "@adobe/ecs" {
+    interface Resources {
+        [gravity]: { type: number; default: -9.8 };
+        [floor]: { type: Height };
+        [names]: { type: ReadonlyMap<string, number> };
+        // Not data: stored as it is.
+        [audio]: { type: AudioContext | null };
+        [focused]: { type: Entity };
+    }
+}
+
+const read = System.create({ observer: true }, ({ resources }) =>
+    [resources[gravity], resources[floor], resources[names], resources[audio], resources[focused]]);
+
+export const main = async (): Promise<void> => {
+    await using earth = World.create();
+    await using moon = World.create({ [gravity]: -1.6 });
+    console.log(await earth.run(read));
+    console.log(await moon.run(read));
+};

package/src/guide/02-entities.md

@@ -0,0 +1,19 @@
+# Entities, components and archetypes
+
+An *entity* is an id. A *component* is a key whose values entities hold, [declared](02-entities.ts#L8-L15) in
+`Components` as a resource is. A component of `type: true` is a *tag*: an entity has it or doesn't, with no value.
+
+An *archetype* is a list of components declared `as const` at module scope, such as
+[`Particle`](02-entities.ts#L17). The build indexes it, and it goes wherever a list of components does. The world
+stores entities with the same set of components together.
+
+Systems change which entities exist through `commands`:
+
+- `commands.spawn(components)(values)` [spawns an entity](02-entities.ts#L19-L22) with those components. A
+  component left out of the values, such as the tag, starts at its default.
+- `commands.add` and `commands.remove` add and remove components; `commands.despawn` removes the entity. Here
+  [`defeat`](02-entities.ts#L24-L26) removes the tag, so the entity stops being a foe.
+
+A system with `components: { with: [...] }` runs once per entity that has every listed component, its *row*, which
+holds those values. `with: [...Particle]` spreads an archetype into a list. Since `defeat` removed the tag,
+[the last read](02-entities.ts#L42) finds no foe and logs nothing.

package/src/guide/02-entities.out

@@ -0,0 +1,2 @@
+a foe at [ 0, 10, 0 ]
+a particle moving at [ 1, 0, 0 ]

package/src/guide/02-entities.ts

@@ -0,0 +1,43 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System, Vec3, World } from "../index.js";
+
+export const position = Symbol();
+export const velocity = Symbol();
+export const enemy = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [position]: { type: Vec3 };
+        [velocity]: { type: Vec3 };
+        // A tag: present or not.
+        [enemy]: { type: true };
+    }
+}
+
+export const Particle = [position, velocity] as const;
+
+export const spawn = System.create(({ commands }) => {
+    commands.spawn([position, enemy])({ [position]: [0, 10, 0] });
+    commands.spawn(Particle)({ [position]: [0, 0, 0], [velocity]: [1, 0, 0] });
+});
+
+export const defeat = System.create({ components: { with: [enemy] } }, (row, { commands }) => {
+    commands.remove(row.entity, enemy);
+});
+
+const readFoes = System.create({ observer: true, components: { with: [position, enemy] } }, row => {
+    console.log("a foe at", row[position]);
+});
+const readParticles = System.create({ observer: true, components: { with: [...Particle] } }, row => {
+    console.log("a particle moving at", row[velocity]);
+});
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(spawn);
+    await world.run(readFoes);
+    await world.run(readParticles);
+    await world.run(defeat);
+    // No foe is left: logs nothing.
+    await world.run(readFoes);
+};

package/src/guide/03-systems.md

@@ -0,0 +1,22 @@
+# Systems
+
+A *system* is a declaration and a body, made by `System.create`. The declaration says which entities it runs over;
+the build infers from the body what it reads and writes, which orders it against other systems and lets the world run
+it in parallel.
+
+- **Row systems** run once per matching entity. [`move`](03-systems.ts#L28-L33) runs over entities with every
+  component in `with` and none in `not`, so the `frozen` one stays put. Values are replaced whole, never edited in
+  place.
+- **Systems without components**, such as [`count`](03-systems.ts#L35-L37), run once per run.
+- **Observer systems**, `observer: true`, only read. They see what the runs before them left. Run one to read the
+  world, or add one to react to it.
+- **Optional components**, `optional: [velocity]`, are in the row where the entity has them and `undefined` where it
+  doesn't. They never narrow which entities a system runs on; [`readSpeeds`](03-systems.ts#L44-L47) still reads the
+  entity without a velocity. Only commands add and remove them.
+
+A run resolves to what a system without components returns, so [`frameCount`](03-systems.ts#L49) reads a resource
+back.
+
+**Failure.** A system whose body throws fails, and its run rejects with an `Error` naming each failed system by its
+binding and id. The others' work still applies: [`countThenFail`](03-systems.ts#L54) still counts a frame, as the last
+line shows.

package/src/guide/03-systems.out

@@ -0,0 +1,5 @@
+at [ 0, 1, 5 ]
+moving [ 'at 2', 'at 2', 'still' ]
+frames 1
+Error: System "fail" (@adobe/ecs@0.2.0/src/guide/03-systems.ts#fail) failed: broken
+frames 2

package/src/guide/03-systems.ts

@@ -0,0 +1,68 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System, Vec3, World } from "../index.js";
+
+const position = Symbol();
+const velocity = Symbol();
+const frozen = Symbol();
+const delta = Symbol();
+const frames = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [position]: { type: Vec3 };
+        [velocity]: { type: Vec3 };
+        [frozen]: { type: true };
+    }
+    interface Resources {
+        [delta]: { type: number; default: 0.5 };
+        [frames]: { type: number };
+    }
+}
+
+const spawn = System.create(({ commands }) => {
+    commands.spawn([position, velocity])({ [position]: [0, 0, 0], [velocity]: [2, 0, 0] });
+    commands.spawn([position, velocity, frozen])({ [position]: [0, 0, 0], [velocity]: [2, 0, 0] });
+    commands.spawn([position])({ [position]: [5, 0, 0] });
+});
+
+const move = System.create({
+    components: { with: [velocity, position], not: [frozen] },
+}, (row, { resources }) => {
+    // Values are replaced whole, never edited in place.
+    row[position] = Vec3.add(row[position], Vec3.scale(row[velocity], resources[delta]));
+});
+
+const count = System.create({}, ({ resources }) => {
+    resources[frames] += 1;
+});
+
+const places: number[] = [];
+const read = System.create({ observer: true, components: { with: [position] } }, row => {
+    places.push(row[position][0]);
+});
+
+const speeds: string[] = [];
+const readSpeeds = System.create({ observer: true, components: { with: [position], optional: [velocity] } }, row => {
+    speeds.push(row[velocity] === undefined ? "still" : `at ${row[velocity][0]}`);
+});
+
+const frameCount = System.create({ observer: true }, ({ resources }) => resources[frames]);
+
+const fail = System.create(() => {
+    throw new Error("broken");
+});
+const countThenFail = System.create([count, fail]);
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(spawn);
+    await world.run(move);
+    await world.run(read);
+    console.log("at", places.sort((a, b) => a - b));
+    await world.run(readSpeeds);
+    console.log("moving", speeds.sort());
+    await world.run(count);
+    console.log("frames", await world.run(frameCount));
+    await world.run(countThenFail).catch((error: unknown) => console.log(String(error)));
+    console.log("frames", await world.run(frameCount));
+};

package/src/guide/04-ticks.md

@@ -0,0 +1,18 @@
+# Ticks and cadence
+
+A *tick* is one beat of a world's loop, which runs every system added to it. `world.add(system)` runs a system on
+every tick from then on, and [`world.remove`](04-ticks.ts#L41) takes it off.
+
+- `clock` is a resource the world writes on each tick: `delta` is the milliseconds since the last one, `now` the time
+  and `tick` the count. [`advance`](04-ticks.ts#L14-L16) accumulates `delta`.
+- `cadence` says when ticks happen: once per animation frame by default, or, with `{ kind: "fixed", step }`, every
+  `step` milliseconds, each with that `delta`.
+- A world ticks only after a run arrives, unless `always` is set, as for [the first world](04-ticks.ts#L36).
+
+An observer with `resources: { changed: [elapsed] }` runs after each tick that changed `elapsed`:
+[`watch`](04-ticks.ts#L18-L21) resolves once 30 ms have passed. Once `advance` is removed, `elapsed` stays put.
+
+**Asking for a tick.** A system that needs another tick contributes a time to the `wake` reduction:
+`reduce[wake](time)` makes the first tick at or after that time run. [`step`](04-ticks.ts#L25-L28) does it twice, so
+the second world, without `always`, ticks three times for one run. Work that one tick's commands start and a later
+tick finishes asks for its next tick this way.

package/src/guide/04-ticks.out

@@ -0,0 +1,3 @@
+elapsed 30 ms, each tick 10
+stopped true
+steps 3

package/src/guide/04-ticks.ts

@@ -0,0 +1,53 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { always, cadence, clock, System, wake, World } from "../index.js";
+
+const elapsed = Symbol();
+const steps = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Resources {
+        [elapsed]: { type: number };
+        [steps]: { type: number };
+    }
+}
+
+const advance = System.create({}, ({ resources }) => {
+    resources[elapsed] += resources[clock].delta;
+});
+
+let reached: (elapsed: number) => void = () => {};
+const watch = System.create({ observer: true, resources: { changed: [elapsed] } }, ({ resources }) => {
+    if (resources[elapsed] >= 30) reached(resources[elapsed]);
+});
+
+const readTime = System.create({ observer: true }, ({ resources }) => ({ elapsed: resources[elapsed], delta: resources[clock].delta }));
+
+const step = System.create({}, ({ resources, reduce }) => {
+    resources[steps] += 1;
+    if (resources[steps] < 3) reduce[wake](resources[clock].now);
+});
+
+let finished: (steps: number) => void = () => {};
+const watchSteps = System.create({ observer: true, resources: { changed: [steps] } }, ({ resources }) => {
+    if (resources[steps] === 3) finished(resources[steps]);
+});
+
+export const main = async (): Promise<void> => {
+    await using world = World.create({ [cadence]: { kind: "fixed", step: 10 }, [always]: true });
+    const ticked = new Promise<number>(resolve => { reached = resolve; });
+    world.add(advance);
+    world.add(watch);
+    console.log("elapsed", await ticked, "ms, each tick", (await world.run(readTime)).delta);
+    world.remove(advance);
+    const stopped = (await world.run(readTime)).elapsed;
+    await new Promise(resolve => setTimeout(resolve, 50));
+    console.log("stopped", (await world.run(readTime)).elapsed === stopped);
+
+    await using stepping = World.create({ [cadence]: { kind: "fixed", step: 10 } });
+    const done = new Promise<number>(resolve => { finished = resolve; });
+    stepping.add(step);
+    stepping.add(watchSteps);
+    // One run arriving ticks once; step's wakes tick twice more.
+    await stepping.run(System.create(() => {}));
+    console.log("steps", await done);
+};

package/src/guide/05-scheduling.md

@@ -0,0 +1,14 @@
+# Scheduling and composites
+
+`after`, `before` and `during` order a system against others, listing the systems themselves:
+[`heal`](05-scheduling.ts#L18-L20) runs `after: [hit]`.
+
+A *composite* is a list of systems, `System.create([heal, hit])`, run as one system. Its members run in the order
+their constraints give, not the order they're listed, so [`frame`](05-scheduling.ts#L21) hits before it heals.
+Members with no order between them may run in parallel; two that write what the other reads or writes must be
+ordered, or the composite is rejected. `System.create({ systems, after, ... })` declares a composite with constraints
+of its own.
+
+A *phase* is a system that does nothing, such as [`update` and `render`](05-scheduling.ts#L28-L29). A system
+`during: [update]` runs after what `update` follows and before what follows `update`. Phases let systems written apart
+agree on an order without naming each other: in [`phased`](05-scheduling.ts#L36), `poison` runs before `report`.

package/src/guide/05-scheduling.out

@@ -0,0 +1,2 @@
+health 10
+health as it renders 9

package/src/guide/05-scheduling.ts

@@ -0,0 +1,46 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System, World } from "../index.js";
+
+const health = Symbol();
+const damage = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [health]: { type: number };
+        [damage]: { type: number };
+    }
+}
+
+const spawn = System.create(({ commands }) => { commands.spawn([health, damage])({ [health]: 10, [damage]: 4 }); });
+const hit = System.create({ components: { with: [damage, health] } }, row => {
+    row[health] -= row[damage];
+});
+const heal = System.create({ components: { with: [health] }, after: [hit] }, row => {
+    row[health] = Math.min(row[health] * 2, 10);
+});
+const frame = System.create([heal, hit]);
+
+const read = System.create({ observer: true, components: { with: [health] } }, row => {
+    console.log("health", row[health]);
+});
+
+// Phases: systems that do nothing.
+const update = System.create(() => {});
+const render = System.create({ after: [update] }, () => {});
+const poison = System.create({ components: { with: [health] }, during: [update] }, row => {
+    row[health] -= 1;
+});
+const report = System.create({ components: { with: [health] }, during: [render] }, row => {
+    console.log("health as it renders", row[health]);
+});
+const phased = System.create([report, poison, update, render]);
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(spawn);
+    // hit, 10 - 4 = 6, then heal, min(12, 10).
+    await world.run(frame);
+    await world.run(read);
+    // poison, then report.
+    await world.run(phased);
+};

package/src/guide/06-sync-points.md

@@ -0,0 +1,14 @@
+# Sync points
+
+A run ends at a *sync point*, where its commands apply.
+
+- **Values** written to rows and resources apply at once.
+- **Commands** wait for the sync point, then apply in the order issued. `commands.spawn` returns the new entity at
+  once, so [later commands can name it](06-sync-points.ts#L16-L21): `commands.add` sets the hero's health to 5. An
+  entity spawned and removed with `commands.despawn` before the sync point never exists.
+
+A composite is one run with one sync point. In [`frame`](06-sync-points.ts#L25), `count` runs `after: [spawn]` but
+before the spawned entities exist, so it counts none; run alone, after the sync point, it counts the hero.
+
+An observer added to a world runs after the sync point of every run and tick, reading what it left:
+[`watch`](06-sync-points.ts#L39-L41) logs the hero after the run that spawned it.

package/src/guide/06-sync-points.out

@@ -0,0 +1,3 @@
+counted 0
+counted 1
+health 5

package/src/guide/06-sync-points.ts

@@ -0,0 +1,42 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System, World } from "../index.js";
+
+const health = Symbol();
+const seen = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [health]: { type: number };
+    }
+    interface Resources {
+        [seen]: { type: number };
+    }
+}
+
+const spawn = System.create(({ commands }) => {
+    const hero = commands.spawn([health])({ [health]: 3 });
+    commands.add(hero, health, 5);
+    // Never exists.
+    commands.despawn(commands.spawn([health])({ [health]: 1 }));
+});
+const count = System.create({ components: { with: [health] }, after: [spawn] }, (row, { resources }) => {
+    resources[seen] += 1;
+});
+const frame = System.create([spawn, count]);
+
+const watch = System.create({ observer: true, components: { with: [health] } }, row => {
+    console.log("health", row[health]);
+});
+const readSeen = System.create({ observer: true }, ({ resources }) => resources[seen]);
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(frame);
+    console.log("counted", await world.run(readSeen));
+    await world.run(count);
+    console.log("counted", await world.run(readSeen));
+
+    await using watched = World.create();
+    watched.add(watch);
+    await watched.run(spawn);
+};

package/src/guide/07-change-filters.md

@@ -0,0 +1,14 @@
+# Change filters and conditions
+
+A *change filter* skips work that has nothing new to do.
+
+- **A resource** in `resources: { changed: [level] }` passes the system's first run and each run after the resource
+  changed. [`load`](07-change-filters.ts#L26-L29) spawns once, with no run-once flag: the second run is skipped.
+- **A component** in `components: { changed: [score] }` passes only rows whose value may have changed since this
+  system last ran. [`show`](07-change-filters.ts#L30-L33) shows every score on its first run, then only the boss's,
+  which [`bump`](07-change-filters.ts#L34-L36) wrote. `added` passes rows whose components were added since then.
+
+A *condition* runs a system only while resources hold. With `resources: { is: [map], not: [paused] }`,
+[`step`](07-change-filters.ts#L43-L45) runs only while `map` is neither `null` nor `false` and `paused` is. In the
+body, `is` narrows the type: `resources[map]` isn't `null`. A system without components that a filter or a condition
+skips resolves to `undefined`.

package/src/guide/07-change-filters.out

@@ -0,0 +1,6 @@
+loaded 2
+showing 0
+showing 0
+showing 10
+steps 0
+steps 4

package/src/guide/07-change-filters.ts

@@ -0,0 +1,70 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System, World } from "../index.js";
+
+const score = Symbol();
+const shown = Symbol();
+const boss = Symbol();
+const level = Symbol();
+const paused = Symbol();
+const map = Symbol();
+const steps = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [score]: { type: number };
+        [shown]: { type: number };
+        [boss]: { type: true };
+    }
+    interface Resources {
+        [level]: { type: number; default: 1 };
+        [paused]: { type: boolean };
+        [map]: { type: { readonly width: number } | null };
+        [steps]: { type: number };
+    }
+}
+
+const load = System.create({ resources: { changed: [level] } }, ({ resources, commands }) => {
+    commands.spawn([score, shown, boss])({ [score]: 0, [shown]: -1 });
+    for (let i = 0; i < resources[level]; i++) commands.spawn([score, shown])({ [score]: 0, [shown]: -1 });
+});
+const show = System.create({ components: { with: [score, shown], changed: [score] } }, row => {
+    row[shown] = row[score];
+    console.log("showing", row[score]);
+});
+const bump = System.create({ components: { with: [score, boss] } }, row => {
+    row[score] += 10;
+});
+
+let loaded = 0;
+const countLoaded = System.create({ observer: true, components: { with: [shown] } }, () => {
+    loaded += 1;
+});
+
+const step = System.create({ resources: { is: [map], not: [paused] } }, ({ resources }) => {
+    resources[steps] += resources[map].width;
+});
+const pause = System.create({}, ({ resources }) => { resources[paused] = true; });
+const open = System.create({}, ({ resources }) => { resources[map] = { width: 4 }; });
+const readSteps = System.create({ observer: true }, ({ resources }) => resources[steps]);
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    // Loads once: level hasn't changed since.
+    await world.run(load);
+    await world.run(load);
+    await world.run(countLoaded);
+    console.log("loaded", loaded);
+    // Shows every score, then only the boss's.
+    await world.run(show);
+    await world.run(bump);
+    await world.run(show);
+
+    // Without a map, step doesn't run; with one it does, until paused.
+    await world.run(step);
+    console.log("steps", await world.run(readSteps));
+    await world.run(open);
+    await world.run(step);
+    await world.run(pause);
+    await world.run(step);
+    console.log("steps", await world.run(readSteps));
+};

package/src/guide/08-input.md

@@ -0,0 +1,12 @@
+# Input
+
+A system's *input* is the body's parameter after its context: an object of named fields, which each run passes, as in
+`world.run(hit, { amount: 3 })`. The build reads its schema from the parameter's type, so its fields are data.
+
+- A system with input is run, not added: a tick has no input to give it.
+- A composite's input has every field its members declare.
+- A run resolves to what a system without components returns, so [`spawn`](08-input.ts#L13-L17) hands back the
+  entity it spawned.
+
+`target: "entity"` names an input field holding an entity. [`heal`](08-input.ts#L25-L30) then runs on that entity's
+row alone, or on none once the entity is gone, so only the player heals.

package/src/guide/08-input.out

@@ -0,0 +1 @@
+healths [ 7, 8 ]

package/src/guide/08-input.ts

@@ -0,0 +1,45 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity, System, World } from "../index.js";
+
+const health = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [health]: { type: number };
+    }
+}
+
+// Spawns two, and returns the first.
+const spawn = System.create(({ commands }) => {
+    const player = commands.spawn([health])({ [health]: 10 });
+    commands.spawn([health])({ [health]: 10 });
+    return player;
+});
+
+const hit = System.create({
+    components: { with: [health] },
+}, (row, _context, input: { readonly amount: number }) => {
+    row[health] -= input.amount;
+});
+
+const heal = System.create({
+    components: { with: [health] },
+    target: "entity",
+}, (row, _context, input: { readonly entity: Entity; readonly amount: number }) => {
+    row[health] += input.amount;
+});
+
+const healths: number[] = [];
+const read = System.create({ observer: true, components: { with: [health] } }, row => {
+    healths.push(row[health]);
+});
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    const player = await world.run(spawn);
+    await world.run(hit, { amount: 3 });
+    // Only the player heals.
+    await world.run(heal, { entity: player, amount: 1 });
+    await world.run(read);
+    console.log("healths", healths.sort((a, b) => a - b));
+};