@adobe/ecs 0.2.0 → 0.2.3

package/dist/interface/system/tables.d.ts

@@ -0,0 +1,20 @@
+import type { Component } from '../component/component.js';
+import type { Resource } from '../resource/resource.js';
+import type { Table } from '../world/table/table.js';
+/**
+ * What a readonly system's `tables` reads: of every archetype matching `with` and `not` that holds any of
+ * `components`, a table of those it holds; and, with `resources`, each resource's value.
+ */
+export type TablesDeclaration = {
+    readonly components: readonly Component.Key[];
+    readonly with?: readonly Component.Key[];
+    readonly not?: readonly Component.Key[];
+    readonly resources?: readonly Resource.Key[];
+};
+/** A readonly system's `tables`: a table of each archetype its declaration reads, and the values of the resources it reads. */
+export type Tables = {
+    readonly archetypes: readonly Table[];
+    readonly resources: {
+        readonly [K in Resource.Key]?: Resource<K>;
+    };
+};

package/dist/interface/system/tables.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tables.js.map

package/dist/interface/system/tables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.js","sourceRoot":"","sources":["../../../src/interface/system/tables.ts"],"names":[],"mappings":""}

package/dist/interface/system/values-of.d.ts

@@ -1,6 +1,6 @@
 import type { Component } from '../component/component.js';
 /** Components a spawn or add may leave out: a tag, whose value is `true`, and one whose type allows `null`, its start. */
-type Omissible<K extends Component.Key> = Component.Value<K> extends true ? K : null extends Component.Value<K> ? K : never;
+type Omissible<K extends Component.Key> = Component<K> extends true ? K : null extends Component<K> ? K : never;
 /**
  * The values a spawn or add of the components `C` takes, keyed by component and exact against `C`, but those `Given`
  * already: a tag needs no value, a component whose type allows `null` may be left out to start at `null`, and every
@@ -8,10 +8,10 @@ type Omissible<K extends Component.Key> = Component.Value<K> extends true ? K :
  * tuple takes any of its components' values.
  */
 export type ValuesOf<C extends readonly Component.Key[], Given extends PropertyKey = never> = number extends C["length"] ? {
-    readonly [K in Exclude<C[number], Given>]?: Component.Value<K>;
+    readonly [K in Exclude<C[number], Given>]?: Component<K>;
 } : {
-    readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? never : K]: Component.Value<K>;
+    readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? never : K]: Component<K>;
 } & {
-    readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? K : never]?: Component.Value<K>;
+    readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? K : never]?: Component<K>;
 };
 export {};

package/dist/interface/system/values.d.ts

@@ -5,10 +5,10 @@ import type { Resource } from '../resource/resource.js';
 import type { Comparison } from '../world/filter.js';
 import type { Listed, Property } from './property.js';
 export type ComponentValues = {
-    readonly [K in Component.Key]: Component.Value<K>;
+    readonly [K in Component.Key]: Component<K>;
 };
 export type ResourceValues = {
-    readonly [K in Resource.Key]: Resource.Value<K>;
+    readonly [K in Resource.Key]: Resource<K>;
 };
 /** `Read` values are read-only, `Write` values writable. */
 export type Values<Read, Write, Keys extends PropertyKey, Types> = {
@@ -24,7 +24,7 @@ export type KeyOf<D> = D extends {
 export type HeldBy<D> = KeyOf<D>[number] | Listed<Property<D, "components">, "with">;
 /** The key's values, in key order. */
 type KeyValues<K extends readonly Component.Key[]> = {
-    readonly [I in keyof K]: Component.Value<K[I] & Component.Key>;
+    readonly [I in keyof K]: Component<K[I] & Component.Key>;
 };
 /** A prefix of the key, possibly empty, whose last part may be a comparison. */
 type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...infer Rest] ? readonly [] | readonly [First | Comparison<First>] | readonly [First, ...Prefix<Rest>] : readonly [];
@@ -32,7 +32,7 @@ type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...
 type IndexRow<D> = {
     readonly entity: Entity;
 } & {
-    readonly [K in HeldBy<D> & Component.Key]: Component.Value<K>;
+    readonly [K in HeldBy<D> & Component.Key]: Component<K>;
 };
 /**
  * The rows a lookup found, in the index's order: by entity for a hash index, by key and then entity for a sorted one.
@@ -65,7 +65,7 @@ type IndexLookup<D> = D extends {
 type EntityRow<L> = {
     readonly [K in (Listed<L, "with"> & Component.Key) | (Exclude<Listed<L, "optional">, Listed<L, "with">> & Component.Key) | (L extends {
         readonly changed: readonly Component.Key[];
-    } ? "changed" : never)]: K extends Component.Key ? K extends Listed<L, "with"> ? Component.Value<K> : Component.Value<K> | undefined : boolean;
+    } ? "changed" : never)]: K extends Component.Key ? K extends Listed<L, "with"> ? Component<K> : Component<K> | undefined : boolean;
 };
 export type LookupFunction<L> = L extends {
     readonly index: Index<infer D>;

package/dist/interface/trait/types.d.ts

@@ -7,7 +7,7 @@ import type { Reduction } from '../resource/reduction.js';
 import type { IsComparable, IsString, IsStruct } from '../schema/is-struct.js';
 import type { Thread } from '../thread/thread.js';
 /** The value type of the component or resource `N`. */
-type ValueOf<N> = N extends Component.Key ? Component.Value<N> : N extends Resource.Key ? Resource.Value<N> : never;
+type ValueOf<N> = N extends Component.Key ? Component<N> : N extends Resource.Key ? Resource<N> : never;
 /**
  * Whether each component's and resource's value is a struct, `"string"` for a string, computed once so a check is a
  * lookup. Its keys are remapped (`as K`) so a generic key's lookup stays one: resolved as `IsStruct` of a generic value,
@@ -44,12 +44,12 @@ export interface Traits<N extends Component.Key | Resource.Key> {
         readonly derived: true;
     } | {
         readonly shared: true;
-    } ? never : [Component.Value<N>] extends [Entity] ? "owner" | "weak" : never : never;
+    } ? never : [Component<N>] extends [Entity] ? "owner" | "weak" : never : never;
     /**
      * On a resource, the operator systems reduce into it with: each run that a contributor runs in starts it at the
      * operator's identity and leaves it holding the fold of every contribution. Booleans fold bitwise.
      */
-    readonly reduce: N extends Resource.Key ? [Resource.Value<N>] extends [boolean] ? "&" | "|" | "^" : Structs[N] extends true ? Reduction : never : never;
+    readonly reduce: N extends Resource.Key ? [Resource<N>] extends [boolean] ? "&" | "|" | "^" : Structs[N] extends true ? Reduction : never : never;
     /**
      * The logical thread an object lives on, `"world"` without it. Not on a struct or a string, which live in shared
      * memory. A DOM `Node` lives on `"main"`, and says so.
@@ -69,6 +69,6 @@ export interface Traits<N extends Component.Key | Resource.Key> {
         readonly derived: true;
     } | {
         readonly reference: unknown;
-    } ? never : IsComparable<Component.Value<N>> extends true ? true : never : never;
+    } ? never : IsComparable<Component<N>> extends true ? true : never : never;
 }
 export {};

package/dist/interface/world/create.d.ts

@@ -4,15 +4,11 @@ import type { InvalidDeclarations } from './declarations.js';
 import type { World } from './world.js';
 /** Values resources start at in place of their defaults: any but those only the world writes. */
 export type InitialResources = {
-    readonly [K in Exclude<Resource.Key, WorldWritten>]?: Resource.Value<K>;
+    readonly [K in Exclude<Resource.Key, WorldWritten>]?: Resource<K>;
 };
 /**
- * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
- * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
- * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
- * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
- * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
- * compile, once, naming each such key, its members and what's wrong with them.
+ * The type of `World.create`.
+ * @inline
  */
 export type Create = (this: [InvalidDeclarations] extends [never] ? unknown : {
     readonly "declarations don't hold": {

package/dist/interface/world/declarations.d.ts

@@ -30,8 +30,8 @@ type Reported<K, Members extends PropertyKey> = [Members] extends [never] ? neve
  * `World.create` reports these.
  */
 export type InvalidDeclarations = {
-    readonly [K in Component.Key]: Reported<K, Invalid<K, Components[K], Component.Value<K>>>;
+    readonly [K in Component.Key]: Reported<K, Invalid<K, Components[K], Component<K>>>;
 }[Component.Key] | {
-    readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource.Value<K>>>;
+    readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource<K>>>;
 }[Resource.Key];
 export {};

package/dist/interface/world/index.d.ts

@@ -1 +1 @@
-export {};
+export type { Table } from './table/table.js';

package/dist/interface/world/join.d.ts

@@ -1,16 +1,8 @@
 import type { Thread } from '../thread/thread.js';
 import type { World } from './world.js';
 /**
- * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
- * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
- * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
- * observer systems, which run here after the world's sync points. Add them before awaiting anything else, so the
- * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
- * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
- * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
- * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
- * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
- * as without cross-origin isolation.
+ * The type of `World.join`.
+ * @inline
  */
 export type Join = (port: Parameters<World["share"]>[0], options?: {
     readonly threads?: readonly Exclude<Thread, "world">[];

package/dist/interface/world/table/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * One component's values in a table, copies taken as a readonly system reads `tables`:
+ * - `bytes`: a struct's or number's, `stride` bytes per row in the world's layout for it, which is a function of the
+ *   component's schema alone;
+ * - `values`: a string's or an object's, one per row;
+ * - `value`: one value every row holds, for a shared component or one whose schema is a constant.
+ */
+export type Column = {
+    readonly kind: "bytes";
+    readonly bytes: Uint8Array;
+    readonly stride: number;
+} | {
+    readonly kind: "values";
+    readonly values: readonly unknown[];
+} | {
+    readonly kind: "value";
+    readonly value: unknown;
+};
+/**
+ * What `commands.spawnTables` spawned: each table's new entities in its row order, `Entity.none` for a row it didn't
+ * spawn, and how many rows it didn't, those owned by an entity outside the tables.
+ */
+export type Spawned = {
+    readonly entities: readonly Float64Array[];
+    readonly dropped: number;
+};

package/dist/interface/world/table/index.js

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/interface/world/table/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/interface/world/table/index.ts"],"names":[],"mappings":"AAAA,uDAAuD"}

package/dist/interface/world/table/table.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from '../../component/component.js';
+import type { Column } from './index.js';
+/** The rows of one archetype: their entities in row order, and a column for each component asked for that it holds. */
+export type Table = {
+    readonly count: number;
+    readonly entities: Float64Array;
+    readonly columns: {
+        readonly [K in Component.Key]?: Column;
+    };
+};
+export type * as Table from './index.js';

package/dist/interface/world/table/table.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=table.js.map

package/dist/interface/world/table/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../../src/interface/world/table/table.ts"],"names":[],"mappings":""}

package/dist/interface/world/world.d.ts

@@ -1,23 +1,23 @@
 import type { Input } from '../system/input.js';
 import type { System } from '../system/system.js';
 /**
- * A world. Systems read and change it; observer systems read it after each run's and tick's sync point. Every member's
+ * A world. Systems read and change it; readonly systems read it after each run's and tick's sync point. Every member's
  * type is named from the package root, so declarations a consumer emits for its results name no internal module.
  */
 export type World = {
     /**
      * The one way to change state. Runs are sequential in call order; physically, any that don't conflict overlap. Each
-     * runs a system or composite, ending in a sync point, then observer systems, the run's and those added, and
+     * runs a system or composite, ending in a sync point, then readonly systems, the run's and those added, and
      * resolves to what a per-run body returns: a system without components resolves to its body's value, or
      * `undefined` when its body was skipped, and any other system or composite to nothing. So a one-off read is a run
-     * of an observer system returning what it read; one that runs on a joined thread, as it reads objects there, runs
-     * there before the run resolves, to its value as structured clone. A run of observer systems alone runs them once
+     * of a readonly system returning what it read; one that runs on a joined thread, as it reads objects there, runs
+     * there before the run resolves, to its value as structured clone. A run of readonly systems alone runs them once
      * after an empty sync point, and doesn't wake the loop.
      *
      * When a system or finalizer of the run fails, later tiers are skipped, the sync point still applies what was done,
-     * and once its observer systems ran the run rejects with an `Error` naming each failure, its system's label and id,
+     * and once its readonly systems ran the run rejects with an `Error` naming each failure, its system's label and id,
      * message and cause. It rejects too when the run can't happen or finish: registration fails, the world is disposed,
-     * its GPU device is lost, or its sync point can't apply a command's value. What fails after it, an observer system
+     * its GPU device is lost, or its sync point can't apply a command's value. What fails after it, a readonly system
      * added or GPU work, is reported out of band, as ticks' failures are (see `add`).
      */
     run<I, R>(system: System<I, R>, ...input: Input<NoInfer<I>>): Promise<R>;
@@ -25,9 +25,9 @@ export type World = {
      * Adds a system to every tick, from the next one on, ordered with those already added by its constraints, as a
      * composite's members are. A tick runs on a beat of the `cadence` resource where `always` is set, `wake` is due or
      * a run arrived since the last tick, and only while some system is added. Throws for a system with no ordering path
-     * to one already added that conflicts with it. An observer system runs after every run's and tick's sync point
+     * to one already added that conflicts with it. A readonly system runs after every run's and tick's sync point
      * instead. It never conflicts and doesn't count as an added system for ticking. On a joined thread `add` takes only
-     * observer systems, whose keys need ids: each runs on that thread after the world's sync points, once for the
+     * readonly systems, whose keys need ids: each runs on that thread after the world's sync points, once for the
      * newest when the thread fell behind, reading structs and the objects of the threads it fills as of one sync point.
      *
      * What added systems throw, and what fails in ticks, is reported out of band on the world's thread, as an `Error`
@@ -41,14 +41,14 @@ export type World = {
      * released. A system added both alone and within an added composite stays until both are removed; constraints
      * naming a removed system are ignored. Removing a value that isn't added does nothing. Throws, removing nothing,
      * when the systems left would conflict with no ordering path between them, as `add` does. On a joined thread it
-     * takes only observer systems.
+     * takes only readonly systems.
      */
     remove(system: System<void>): void;
     /**
      * Lets another thread join this world through `port`, one end of a channel to it, of the browser or node: a
      * `MessagePort`, a `Worker`, or a worker's own scope, `self` or node's `parentPort`. That thread joins through the
      * other end, claiming the logical threads it fills. Resolves once it has joined: the threads it claims are its own,
-     * and the observer systems it added as its join resolved, before awaiting anything else, are added, so a run
+     * and the readonly systems it added as its join resolved, before awaiting anything else, are added, so a run
      * started afterwards runs on it and reaches them; one it adds later reaches the runs after its add arrived.
      * Rejects with an `Error` saying why it didn't join: the world refused its claim, as of a thread claimed twice, the
      * world was disposed, the port is shared already, or that thread ended first, as the platform reports it: a

package/dist/world.d.ts

@@ -0,0 +1,27 @@
+import type { Create } from './interface/world/create.js';
+import type { Join } from './interface/world/join.js';
+export type { Table } from './interface/world/table/table.js';
+/**
+ * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
+ * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
+ * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
+ * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
+ * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
+ * compile, once, naming each such key, its members and what's wrong with them.
+ * @function
+ */
+export declare const create: Create;
+/**
+ * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
+ * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
+ * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
+ * readonly systems, which run here after the world's sync points. Add them before awaiting anything else, so the
+ * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
+ * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
+ * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
+ * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
+ * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
+ * as without cross-origin isolation.
+ * @function
+ */
+export declare const join: Join;

package/dist/world.js

@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { create as createWorld, join as joinWorld } from './implementation/index.js';
+/**
+ * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
+ * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
+ * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
+ * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
+ * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
+ * compile, once, naming each such key, its members and what's wrong with them.
+ * @function
+ */
+export const create = createWorld;
+/**
+ * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
+ * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
+ * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
+ * readonly systems, which run here after the world's sync points. Add them before awaiting anything else, so the
+ * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
+ * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
+ * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
+ * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
+ * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
+ * as without cross-origin isolation.
+ * @function
+ */
+export const join = joinWorld;
+//# sourceMappingURL=world.js.map

package/dist/world.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.js","sourceRoot":"","sources":["../src/world.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,MAAM,IAAI,WAAW,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAMrF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,MAAM,GAAW,WAAW,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,IAAI,GAAS,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/ecs",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Adobe ECS",
   "license": "MIT",
   "type": "module",

package/src/exports.test.ts

@@ -50,7 +50,7 @@ export const world: World = World.create({ [workers]: 0 });
 // Another thread joins it through the other end of a channel the world shares.
 declare const port: MessagePort;
 export const joined: Promise<World> = World.join(port, { threads: ["main"] });
-export const read = System.create({ observer: true, components: { with: [position] }, lookup: { at: { with: [position] } } }, () => {});
+export const read = System.create({ readonly: true, components: { with: [position] }, lookup: { at: { with: [position] } } }, () => {});
 export const added = world.add(read);
 `;
 
@@ -152,7 +152,7 @@ const customTrait = creating(`
 export const instanced = Symbol();
 export const foo = Symbol();
 declare module "@adobe/ecs" {
-    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never }
+    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never }
     interface Components { [foo]: { type: string; [instanced]: true } }
 }`);
 
@@ -182,7 +182,7 @@ const severalTraits = creating(`
 export const instanced = Symbol();
 export const name = Symbol();
 declare module "@adobe/ecs" {
-    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never }
+    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never }
     interface Components { [name]: { type: string; [instanced]: true; thread: "main" } }
 }`);
 

package/src/guide/00-keys.ts

@@ -23,7 +23,7 @@ const award = System.create({ components: { with: [score] } }, (row, { resources
     row[score] += resources[bonus];
 });
 
-const read = System.create({ observer: true, components: { with: [score] } }, row => {
+const read = System.create({ readonly: true, components: { with: [score] } }, row => {
     console.log("score", row[score]);
 });
 

package/src/guide/01-resources.md

@@ -17,6 +17,6 @@ that isn't data, such as an `AudioContext`, is stored as it is; a change inside
 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.
+A system reads resources by key. With `readonly: 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.ts

@@ -22,7 +22,7 @@ declare module "@adobe/ecs" {
     }
 }
 
-const read = System.create({ observer: true }, ({ resources }) =>
+const read = System.create({ readonly: true }, ({ resources }) =>
     [resources[gravity], resources[floor], resources[names], resources[audio], resources[focused]]);
 
 export const main = async (): Promise<void> => {

package/src/guide/02-entities.ts

@@ -25,10 +25,10 @@ export const defeat = System.create({ components: { with: [enemy] } }, (row, { c
     commands.remove(row.entity, enemy);
 });
 
-const readFoes = System.create({ observer: true, components: { with: [position, enemy] } }, row => {
+const readFoes = System.create({ readonly: true, components: { with: [position, enemy] } }, row => {
     console.log("a foe at", row[position]);
 });
-const readParticles = System.create({ observer: true, components: { with: [...Particle] } }, row => {
+const readParticles = System.create({ readonly: true, components: { with: [...Particle] } }, row => {
     console.log("a particle moving at", row[velocity]);
 });
 

package/src/guide/03-systems.md

@@ -8,8 +8,8 @@ it in parallel.
   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.
+- **Readonly systems**, `readonly: true`, only read. Run one to read the world, as [`read`](03-systems.ts#L40-L42)
+  does, or add one to react to it. [Sync points](06-sync-points.md) says when and where they run.
 - **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.

package/src/guide/03-systems.out

@@ -1,5 +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
+Error: System "fail" (@adobe/ecs@0.2.3/src/guide/03-systems.ts#fail) failed: broken
 frames 2

package/src/guide/03-systems.ts

@@ -37,16 +37,16 @@ const count = System.create({}, ({ resources }) => {
 });
 
 const places: number[] = [];
-const read = System.create({ observer: true, components: { with: [position] } }, row => {
+const read = System.create({ readonly: 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 => {
+const readSpeeds = System.create({ readonly: 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 frameCount = System.create({ readonly: true }, ({ resources }) => resources[frames]);
 
 const fail = System.create(() => {
     throw new Error("broken");

package/src/guide/04-ticks.md

@@ -9,7 +9,7 @@ every tick from then on, and [`world.remove`](04-ticks.ts#L41) takes it off.
   `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`:
+A readonly system 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:

package/src/guide/04-ticks.ts

@@ -16,11 +16,11 @@ const advance = System.create({}, ({ resources }) => {
 });
 
 let reached: (elapsed: number) => void = () => {};
-const watch = System.create({ observer: true, resources: { changed: [elapsed] } }, ({ resources }) => {
+const watch = System.create({ readonly: 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 readTime = System.create({ readonly: true }, ({ resources }) => ({ elapsed: resources[elapsed], delta: resources[clock].delta }));
 
 const step = System.create({}, ({ resources, reduce }) => {
     resources[steps] += 1;
@@ -28,7 +28,7 @@ const step = System.create({}, ({ resources, reduce }) => {
 });
 
 let finished: (steps: number) => void = () => {};
-const watchSteps = System.create({ observer: true, resources: { changed: [steps] } }, ({ resources }) => {
+const watchSteps = System.create({ readonly: true, resources: { changed: [steps] } }, ({ resources }) => {
     if (resources[steps] === 3) finished(resources[steps]);
 });
 

package/src/guide/05-scheduling.ts

@@ -20,7 +20,7 @@ const heal = System.create({ components: { with: [health] }, after: [hit] }, row
 });
 const frame = System.create([heal, hit]);
 
-const read = System.create({ observer: true, components: { with: [health] } }, row => {
+const read = System.create({ readonly: true, components: { with: [health] } }, row => {
     console.log("health", row[health]);
 });
 

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

@@ -10,5 +10,12 @@ A run ends at a *sync point*, where its commands apply.
 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.
+**Readonly systems.** `readonly: true` places a system after the sync point, so it reads what the commands did. Added
+to a world, [`watch`](06-sync-points.ts#L27-L29) runs after the sync point of every run and tick, and logs the hero
+after the run that spawned it; `count`, which isn't readonly, runs before the sync point, in its tier.
+
+- **Where:** a readonly system runs on the thread that added or ran it, so a [joined thread](19-threads.md) adds only
+  readonly systems.
+- **Order:** none. It can't declare `before`, `after` or `during`.
+- **Limits:** it can't write, use `commands` or `reduce`, or take input. Its row and resources are read-only, so each
+  is a type error.

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

@@ -24,10 +24,10 @@ const count = System.create({ components: { with: [health] }, after: [spawn] },
 });
 const frame = System.create([spawn, count]);
 
-const watch = System.create({ observer: true, components: { with: [health] } }, row => {
+const watch = System.create({ readonly: true, components: { with: [health] } }, row => {
     console.log("health", row[health]);
 });
-const readSeen = System.create({ observer: true }, ({ resources }) => resources[seen]);
+const readSeen = System.create({ readonly: true }, ({ resources }) => resources[seen]);
 
 export const main = async (): Promise<void> => {
     await using world = World.create();

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

@@ -36,7 +36,7 @@ const bump = System.create({ components: { with: [score, boss] } }, row => {
 });
 
 let loaded = 0;
-const countLoaded = System.create({ observer: true, components: { with: [shown] } }, () => {
+const countLoaded = System.create({ readonly: true, components: { with: [shown] } }, () => {
     loaded += 1;
 });
 
@@ -45,7 +45,7 @@ const step = System.create({ resources: { is: [map], not: [paused] } }, ({ resou
 });
 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]);
+const readSteps = System.create({ readonly: true }, ({ resources }) => resources[steps]);
 
 export const main = async (): Promise<void> => {
     await using world = World.create();

package/src/guide/08-input.ts

@@ -30,7 +30,7 @@ const heal = System.create({
 });
 
 const healths: number[] = [];
-const read = System.create({ observer: true, components: { with: [health] } }, row => {
+const read = System.create({ readonly: true, components: { with: [health] } }, row => {
     healths.push(row[health]);
 });
 

package/src/guide/09-rules.ts

@@ -31,7 +31,7 @@ const hide = System.create({ components: { with: [sprite] } }, (row, { commands
 });
 
 const drawing: string[] = [];
-const read = System.create({ observer: true, components: { with: [layer, drawn], optional: [mesh, sprite] } }, row => {
+const read = System.create({ readonly: 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. */

package/src/guide/11-traits.ts

@@ -33,9 +33,9 @@ const destroy = System.create({ components: { with: [ship] } }, (row, { commands
 });
 
 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 countOutlined = System.create({ readonly: true, components: { with: [outline] } }, () => { counts.outlined += 1; });
+const countTargeting = System.create({ readonly: true, components: { with: [target] } }, () => { counts.targeting += 1; });
+const countAll = System.create({ readonly: true, components: {} }, () => { counts.entities += 1; });
 const count = System.create([countOutlined, countTargeting, countAll]);
 
 export const main = async (): Promise<void> => {