@adobe/ecs 0.1.0 → 0.2.1

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));
+};

package/src/guide/09-rules.md

@@ -0,0 +1,12 @@
+# Rules
+
+A *rule* derives components from others: entities matching it have what it derives, only while they match.
+`Rule.create` declares one at module scope, with a match like a system's and the components it derives.
+
+- A derived component is [declared](09-rules.ts#L15-L16) with `derived: true`. Only rules add and remove it; it
+  starts at its default.
+- [Several rules](09-rules.ts#L20-L21) may derive one component, which an entity has while any of them matches.
+- Rules build on what others derive: [`layer`](09-rules.ts#L22) follows from `drawn`.
+
+Rules apply at each sync point. When [`hide`](09-rules.ts#L29-L31) adds `hidden` to the sprite, it stops matching,
+so it loses `drawn`, and with it `layer`.

package/src/guide/09-rules.out

@@ -0,0 +1,2 @@
+drawn: mesh 1 on layer 1, sprite 2 on layer 1
+drawn: mesh 1 on layer 1

package/src/guide/09-rules.ts

@@ -0,0 +1,50 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Rule, System, World } from "../index.js";
+
+const mesh = Symbol();
+const sprite = Symbol();
+const hidden = Symbol();
+const drawn = Symbol();
+const layer = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [mesh]: { type: number };
+        [sprite]: { type: number };
+        [hidden]: { type: true };
+        [drawn]: { type: true; derived: true };
+        [layer]: { type: number; derived: true; default: 1 };
+    }
+}
+
+Rule.create({ components: { with: [mesh], not: [hidden] }, derive: [drawn] });
+Rule.create({ components: { with: [sprite], not: [hidden] }, derive: [drawn] });
+Rule.create({ components: { with: [drawn] }, derive: [layer] });
+
+const spawn = System.create(({ commands }) => {
+    commands.spawn([mesh])({ [mesh]: 1 });
+    commands.spawn([sprite])({ [sprite]: 2 });
+    commands.spawn([mesh, hidden])({ [mesh]: 3 });
+});
+const hide = System.create({ components: { with: [sprite] } }, (row, { commands }) => {
+    commands.add(row.entity, hidden);
+});
+
+const drawing: string[] = [];
+const read = System.create({ observer: true, components: { with: [layer, drawn], optional: [mesh, sprite] } }, row => {
+    drawing.push(`${row[mesh] === undefined ? `sprite ${row[sprite]}` : `mesh ${row[mesh]}`} on layer ${row[layer]}`);
+});
+/** Logs what's drawn, in order. */
+const logDrawn = async (world: World): Promise<void> => {
+    drawing.length = 0;
+    await world.run(read);
+    console.log("drawn:", drawing.sort().join(", "));
+};
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(spawn);
+    await logDrawn(world);
+    await world.run(hide);
+    await logDrawn(world);
+};

package/src/guide/10-finalizers.md

@@ -0,0 +1,13 @@
+# Finalizers and change sets
+
+A *finalizer* runs for each entity that stops matching it, whatever the cause: a despawn, a removed component, an
+owner's despawn or the world's disposal. It reads the entity's values from before, so it can release what they name
+outside the world, such as GPU buffers and DOM nodes. [This one](10-finalizers.ts#L15-L17) closes handles: the
+despawned entity's and the one whose `handle` was removed.
+
+`world.dispose()` runs every finalizer for the entities it still matches, so [the last handle](10-finalizers.ts#L46-L47)
+closes too.
+
+A *change set* is each sync point's structural changes to the components a `Finalizer.changes` watches, grouped by how
+entities changed. [`changes.previous` and `changes.next`](10-finalizers.ts#L32-L36) give a component's value before
+and after, `null` where the entity didn't have it: what saving and undo need.

package/src/guide/10-finalizers.out

@@ -0,0 +1,4 @@
+changed: null → 7, null → 8, null → 9
+changed: 7 → null, 8 → null
+open [ 9 ]
+open []

package/src/guide/10-finalizers.ts

@@ -0,0 +1,48 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Finalizer, System, World } from "../index.js";
+
+const handle = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [handle]: { type: number };
+    }
+}
+
+/** What handles name outside the world, as GPU buffers and DOM nodes are. */
+const open = new Set<number>();
+
+Finalizer.create({ components: { with: [handle] } }, row => {
+    open.delete(row[handle]);
+});
+
+const spawn = System.create(({ commands }) => {
+    for (const id of [7, 8, 9]) {
+        open.add(id);
+        commands.spawn([handle])({ [handle]: id });
+    }
+});
+const destroy = System.create({ components: { with: [handle] } }, (row, { commands }) => {
+    if (row[handle] === 7) commands.despawn(row.entity);
+    else if (row[handle] === 8) commands.remove(row.entity, handle);
+});
+
+const saved: string[] = [];
+
+Finalizer.changes({ watch: [handle] }, changes => {
+    for (const group of changes.groups) {
+        for (const entity of group.entities) saved.push(`${changes.previous(entity, handle)} → ${changes.next(entity, handle)}`);
+    }
+});
+
+export const main = async (): Promise<void> => {
+    const world = World.create();
+    await world.run(spawn);
+    console.log("changed:", saved.sort().join(", "));
+    saved.length = 0;
+    await world.run(destroy);
+    console.log("changed:", saved.sort().join(", "));
+    console.log("open", [...open]);
+    await world.dispose();
+    console.log("open", [...open]);
+};

package/src/guide/11-traits.md

@@ -0,0 +1,16 @@
+# Traits, within and references
+
+A declaration's fields are its *traits*. Besides `type` and `default`, these change what the world does with a
+component:
+
+- `reference: "owner"`: an `Entity` the holder belongs to. The holder is despawned with it.
+- `reference: "weak"`: an `Entity` the holder points at. The component is removed when that entity despawns.
+- `within: typeof selected`: the component is removed with `selected`.
+
+[Here](11-traits.ts#L10-L21), deselecting the mothership removes its outline; destroying it despawns the entity it
+owns and leaves the one targeting it without `target`. A row can't assign a reference; `commands.add` replaces it.
+
+**Traits of your own** are members of `interface Traits<N>`, typed as the value each allows on key `N`, or `never`
+where it doesn't apply. [`instanced`](11-traits.type-test.ts#L5-L10) applies only to components whose values are
+lists of numbers. `Component.With<typeof instanced>` is the type of every key declared with it, so
+[passing another](11-traits.type-test.ts#L21-L25) is a type error.

package/src/guide/11-traits.out

@@ -0,0 +1,2 @@
+{ outlined: 0, targeting: 1, entities: 3 }
+{ outlined: 0, targeting: 0, entities: 1 }

package/src/guide/11-traits.ts

@@ -0,0 +1,51 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity, System, World } from "../index.js";
+
+const ship = Symbol();
+const parent = Symbol();
+const target = Symbol();
+const selected = Symbol();
+const outline = Symbol();
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [ship]: { type: true };
+        // Despawned with the entity it points to.
+        [parent]: { type: Entity; reference: "owner" };
+        // Removed when the entity it points to despawns.
+        [target]: { type: Entity; reference: "weak" };
+        [selected]: { type: true };
+        // Removed with selected.
+        [outline]: { type: number; within: typeof selected };
+    }
+}
+
+const spawn = System.create(({ commands }) => {
+    const mothership = commands.spawn([ship, selected, outline])({ [outline]: 2 });
+    commands.spawn([parent])({ [parent]: mothership });
+    commands.spawn([target])({ [target]: mothership });
+});
+const deselect = System.create({ components: { with: [selected] } }, (row, { commands }) => {
+    commands.remove(row.entity, selected);
+});
+const destroy = System.create({ components: { with: [ship] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+
+const counts = { outlined: 0, targeting: 0, entities: 0 };
+const countOutlined = System.create({ observer: true, components: { with: [outline] } }, () => { counts.outlined += 1; });
+const countTargeting = System.create({ observer: true, components: { with: [target] } }, () => { counts.targeting += 1; });
+const countAll = System.create({ observer: true, components: {} }, () => { counts.entities += 1; });
+const count = System.create([countOutlined, countTargeting, countAll]);
+
+export const main = async (): Promise<void> => {
+    await using world = World.create();
+    await world.run(spawn);
+    await world.run(deselect);
+    await world.run(count);
+    console.log(counts);
+    counts.outlined = counts.targeting = counts.entities = 0;
+    await world.run(destroy);
+    await world.run(count);
+    console.log(counts);
+};

package/src/guide/11-traits.type-test.ts

@@ -1,27 +1,25 @@
-import { Component, Trait } from "../index.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Component } from "../index.js";
 
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
-const check = <_T extends true>() => { };
-
-// A trait of your own is a member of Traits<N>: the value it allows on key N, or never where it doesn't apply.
-export const instanced = Symbol("instanced");
+// A trait of your own: true for components whose values are lists of numbers, never for others.
+export const instanced = Symbol();
 declare module "@adobe/ecs" {
     interface Traits<N> {
-        readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never;
+        readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never;
     }
 }
-Trait.register(instanced);
 
-const transform = Symbol("transform");
-const name = Symbol("name");
+const transform = Symbol();
+const name = Symbol();
 declare module "@adobe/ecs" {
     interface Components {
         [transform]: { type: readonly [number, number, number]; [instanced]: true };
         [name]: { type: string };
     }
 }
-Component.register(transform, { type: { type: "array", items: { type: "number" }, minItems: 3, maxItems: 3 }, [instanced]: true });
-Component.register(name, { type: { type: "string" } });
 
-// Types select components by trait.
-check<Equal<Extract<Component.With<typeof instanced>, typeof transform | typeof name>, typeof transform>>();
+const instance = (key: Component.With<typeof instanced>): Component.Key => key;
+instance(transform);
+// @ts-expect-error: name isn't instanced. Without this line, TypeScript reports:
+// Argument of type 'typeof name' is not assignable to parameter of type 'typeof transform'.
+instance(name);

package/src/guide/12-lookups.md

@@ -0,0 +1,14 @@
+# Lookups
+
+A *lookup* reads another entity from a system. It's named in the declaration, `lookup: { enemy: { with, not } }`, and
+called from the body, `lookup.enemy(entity)`. It's read-only, and it doesn't change which entities the system runs on.
+
+- [The call](12-lookups.ts#L18-L24) gives the entity's row, or `null` when the entity lacks a component in `with` or
+  has one in `not`. So the tracker of the frozen statue aims at 0.
+- The row holds only what `with` lists.
+- With `changed: [health]`, the row's `changed` says whether those components may have changed since the system last
+  ran: [`watch`](12-lookups.ts#L26-L34) sees `true` on its first run and `false` on the next.
+
+A system can't look up components it writes, since a lookup reads other rows while the run writes them.
+
+To find entities by value rather than by id, look up through an [index](13-indexes.md).

package/src/guide/12-lookups.out

@@ -0,0 +1,3 @@
+aims [ 0, 40 ]
+changed [ true, true ]
+changed [ false, false ]