@adobe/ecs 0.2.0 → 0.2.3

package/src/interface/system/values.ts

@@ -6,8 +6,8 @@ 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> };
-export type ResourceValues = { readonly [K in Resource.Key]: Resource.Value<K> };
+export type ComponentValues = { readonly [K in Component.Key]: Component<K> };
+export type ResourceValues = { readonly [K in Resource.Key]: Resource<K> };
 
 /** `Read` values are read-only, `Write` values writable. */
 export type Values<Read, Write, Keys extends PropertyKey, Types> =
@@ -21,7 +21,7 @@ export type KeyOf<D> = D extends { readonly key: infer K extends readonly Compon
 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> };
+type KeyValues<K extends readonly 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]
@@ -29,7 +29,7 @@ type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...
     : readonly [];
 
 /** A row an index lookup gives: its entity and the values of what every entity the index holds has, read-only. */
-type IndexRow<D> = { readonly entity: Entity } & { readonly [K in HeldBy<D> & Component.Key]: Component.Value<K> };
+type IndexRow<D> = { readonly entity: Entity } & { 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> =
 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)]:
         // Its `optional` components are their values where the entity has them, `undefined` where it doesn't.
-        K extends Component.Key ? K extends Listed<L, "with"> ? Component.Value<K> : Component.Value<K> | undefined : boolean
+        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/src/interface/thread/thread.type-test.ts

@@ -55,7 +55,7 @@ declare module '@adobe/ecs' {
     }
 }
 
-check<Equal<Component.Value<typeof path>, readonly number[]>>();
+check<Equal<Component<typeof path>, readonly number[]>>();
 check<Equal<ThreadOf<{ readonly thread: "main" }, string>, never>>();
 check<Equal<ThreadOf<{ readonly thread: "main" }, "edit" | "view">, never>>();
 check<Equal<ThreadOf<{ readonly thread: "main" }, readonly string[]>, "main">>();

package/src/interface/trait/trait.type-test.ts

@@ -16,7 +16,7 @@ const gpuOnly = Symbol("traitTest/gpuOnly");
 const nonPersistent = Symbol("traitTest/nonPersistent");
 declare module '@adobe/ecs' {
     export interface Traits<N> {
-        readonly [gpuOnly]: N extends Component.Key ? (IsStruct<Component.Value<N>> extends true ? true : never) : never;
+        readonly [gpuOnly]: N extends Component.Key ? (IsStruct<Component<N>> extends true ? true : never) : never;
         readonly [nonPersistent]: N extends Component.Key ? (Components[N] extends { readonly derived: true } ? never : true) : true;
     }
 }
@@ -53,15 +53,15 @@ declare module '@adobe/ecs' {
 
 // Types filter components by their traits and value types.
 type Ours = typeof parent | typeof follows | typeof slot | typeof ready | typeof score | typeof link | typeof pair | typeof cache;
-check<Equal<Component.Value<typeof parent>, Entity>>();
-check<Equal<Component.Value<typeof link>, { readonly to: Entity; readonly weight: number }>>();
+check<Equal<Component<typeof parent>, Entity>>();
+check<Equal<Component<typeof link>, { readonly to: Entity; readonly weight: number }>>();
 check<Equal<Extract<Component.With<"reference">, Ours>, typeof parent | typeof follows>>();
 check<Equal<Extract<Component.With<"reference", "owner">, Ours>, typeof parent>>();
 check<Equal<Extract<Derived, Ours>, typeof slot>>();
 check<Equal<Extract<Component.With<typeof gpuOnly>, Ours>, typeof pair>>();
 type Persisted = Exclude<Essential, Component.With<typeof nonPersistent>>;
 check<Equal<Extract<Persisted, Ours>, Exclude<Ours, typeof slot | typeof cache>>>();
-check<Equal<Resource.Value<typeof time>, number>>();
+check<Equal<Resource<typeof time>, number>>();
 
 // Commands add and remove only essential components.
 export const issue = (commands: Commands, entity: Entity): void => {

package/src/interface/trait/types.ts

@@ -9,7 +9,7 @@ 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
@@ -39,14 +39,14 @@ export interface Traits<N extends Component.Key | Resource.Key> {
      * component. Not on a derived component, whose target only a command could set.
      */
     readonly reference: N extends Component.Key
-        ? Components[N] extends { readonly derived: true } | { readonly shared: true } ? never : [Component.Value<N>] extends [Entity] ? "owner" | "weak" : never
+        ? Components[N] extends { readonly derived: true } | { readonly shared: true } ? 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
+        ? [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
@@ -64,6 +64,6 @@ export interface Traits<N extends Component.Key | Resource.Key> {
      * reference, and it has no thread: every thread reads it.
      */
     readonly shared: N extends Component.Key
-        ? Components[N] extends { readonly derived: true } | { readonly reference: unknown } ? never : IsComparable<Component.Value<N>> extends true ? true : never
+        ? Components[N] extends { readonly derived: true } | { readonly reference: unknown } ? never : IsComparable<Component<N>> extends true ? true : never
         : never;
 }

package/src/interface/world/create.ts

@@ -5,15 +5,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> };
+export type InitialResources = { 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 = (
     // Unknown while every declaration holds; else what a call's `this` can't be, so the call reports it, printed whole.

package/src/interface/world/declarations.ts

@@ -30,5 +30,5 @@ 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>>> }[Component.Key]
-    | { readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource.Value<K>>> }[Resource.Key];
+    | { 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<K>>> }[Resource.Key];

package/src/interface/world/index.ts

@@ -1,3 +1,3 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-// The `World` namespace's members: none, since a consumer declares nothing more with it.
-export {};
+// The `World` namespace's types.
+export type { Table } from './table/table.js';

package/src/interface/world/join.ts

@@ -3,15 +3,7 @@ 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">[] }) => Promise<World>;

package/src/interface/world/loop.type-test.ts

@@ -25,14 +25,14 @@ world.remove(move);
 void removed;
 
 // Built-in resources.
-check<Equal<Resource.Value<typeof gpuDevice>, GPUDevice | null>>();
-check<Equal<Resource.Value<typeof workers>, number | null>>();
+check<Equal<Resource<typeof gpuDevice>, GPUDevice | null>>();
+check<Equal<Resource<typeof workers>, number | null>>();
 // null is the platform's choice of pool size.
 export const platformPool: World = create({ [workers]: null });
-check<Equal<Resource.Value<typeof always>, boolean>>();
-check<Equal<Resource.Value<typeof wake>, number>>();
-check<Equal<Resource.Value<typeof clock>, { readonly now: number; readonly delta: number; readonly tick: number }>>();
-check<Equal<Resource.Value<typeof cadence>, { readonly kind: "frame" } | { readonly kind: "fixed"; readonly step: number; readonly maxSteps?: number }>>();
+check<Equal<Resource<typeof always>, boolean>>();
+check<Equal<Resource<typeof wake>, number>>();
+check<Equal<Resource<typeof clock>, { readonly now: number; readonly delta: number; readonly tick: number }>>();
+check<Equal<Resource<typeof cadence>, { readonly kind: "frame" } | { readonly kind: "fixed"; readonly step: number; readonly maxSteps?: number }>>();
 // Built-in resources are symbols, so worlds start them at other values through their imported keys.
 check<Equal<[typeof gpuDevice, typeof workers, typeof cadence, typeof always, typeof wake, typeof clock] extends readonly symbol[] ? true : false, true>>();
 // @ts-expect-error a resource key is its imported symbol, never its description

package/src/interface/world/run.type-test.ts

@@ -19,7 +19,7 @@ declare module '@adobe/ecs' {
 }
 
 // A run resolves to its per-run body's value: a one-off read is an observer system returning it.
-const count = System.create({ observer: true }, ({ resources }) => resources[frames]);
+const count = System.create({ readonly: true }, ({ resources }) => resources[frames]);
 check<Equal<typeof count, System<undefined, number>>>();
 const counted: Promise<number> = world.run(count);
 // @ts-expect-error a run of it resolves to a number
@@ -32,7 +32,7 @@ const scaled = System.create({}, ({ resources }, input: { readonly by: number })
 const scaledValue: Promise<{ scaled: number }> = world.run(scaled, { by: 2 });
 
 // A body that may be skipped, as one whose conditions or resource change filters can fail, may give undefined.
-const changedFrames = System.create({ observer: true, resources: { changed: [frames] } }, ({ resources }) => resources[frames]);
+const changedFrames = System.create({ readonly: true, resources: { changed: [frames] } }, ({ resources }) => resources[frames]);
 check<Equal<typeof changedFrames, System<undefined, number | undefined>>>();
 const whileDevice = System.create({ resources: { is: [gpuDevice] } }, () => "drawn");
 const drawn: Promise<string | undefined> = world.run(whileDevice);
@@ -68,7 +68,7 @@ void [counted, notText, nextValue, scaledValue, drawn, rows, composite, input, n
 // @ts-expect-error a body returns no promise
 System.create(() => Promise.resolve(1));
 // @ts-expect-error a body returns no promise
-System.create({ observer: true }, () => Promise.resolve(1));
+System.create({ readonly: true }, () => Promise.resolve(1));
 // @ts-expect-error a body returns no promise, a row system's neither
 System.create({ components: { with: [position] } }, () => Promise.resolve());
 // @ts-expect-error a body returns no promise, a render system's neither

package/src/interface/world/table/index.ts

@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * 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/src/interface/world/table/table.ts

@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+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/src/interface/world/world.ts

@@ -3,23 +3,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>;
@@ -27,9 +27,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`
@@ -43,14 +43,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/src/observe/entity.ts

@@ -129,14 +129,14 @@ const createShape = (state: WorldState, byShape: Map<string, EntityShape>, id: s
     let finders: Finders | null = null;
     let source: object | null = null;
     const system = optional.length === 0
-        ? System.create(labelled({ observer: true, lookup: { presence: { with: required, changed: required }, values: { with: required }, members: { index: membersOf(required), changed: required } } }, name, { lookup: { values: required } }), ({ lookup }) => {
+        ? System.create(labelled({ readonly: true, lookup: { presence: { with: required, changed: required }, values: { with: required }, members: { index: membersOf(required), changed: required } } }, name, { lookup: { values: required } }), ({ lookup }) => {
             if (source !== lookup || finders === null) {
                 source = lookup;
                 finders = { presence: lookup.presence, values: lookup.values, optional: noOptional };
             }
             pass(lookup.members().changed, finders);
         })
-        : System.create(labelled({ observer: true, lookup: optionalLookups(required, optional) }, name, { lookup: optionalReads(required, optional) }), ({ lookup }) => {
+        : System.create(labelled({ readonly: true, lookup: optionalLookups(required, optional) }, name, { lookup: optionalReads(required, optional) }), ({ lookup }) => {
             if (source !== lookup || finders === null) {
                 source = lookup;
                 finders = { presence: lookup.presence, values: lookup.values, optional: (index, entity) => lookup[index](entity) };

package/src/observe/members.ts

@@ -5,7 +5,7 @@ import type { Observe } from './observe.js';
 import { observeCount, observeSelect } from './select.js';
 import type { Query } from './query.js';
 import { observeResource } from './resource.js';
-import type { ReadonlyResourceValue, ReadonlyValue } from './values.js';
+import type { ReadonlyResourceType, ReadonlyType } from './values.js';
 
 export { toPromise } from './to-promise.js';
 export type { Query } from './query.js';
@@ -14,7 +14,7 @@ export type { Query } from './query.js';
  * A resource's value, then a new one after each run or tick that changed it: one whose sync point stamped it, even with
  * the same value, a reduced resource when its fold differs.
  */
-export const resource = <R extends Resource.Key>(world: World, resource: R): Observe<ReadonlyResourceValue<R>> =>
+export const resource = <R extends Resource.Key>(world: World, resource: R): Observe<ReadonlyResourceType<R>> =>
     observeResource(world, resource);
 
 /**
@@ -27,7 +27,7 @@ export const entity = <const R extends readonly Component.Key[] = [], const O ex
     world: World,
     entity: Entity,
     components: { readonly required?: R; readonly optional?: O },
-): Observe<({ readonly [K in keyof Pick<Components, R[number]>]: ReadonlyValue<K> } & { readonly [K in keyof Pick<Components, O[number]>]?: ReadonlyValue<K> }) | null> =>
+): Observe<({ readonly [K in keyof Pick<Components, R[number]>]: ReadonlyType<K> } & { readonly [K in keyof Pick<Components, O[number]>]?: ReadonlyType<K> }) | null> =>
     observeEntity(world, entity, components);
 
 /**

package/src/observe/query.ts

@@ -10,7 +10,7 @@ type Comparison<T> = {
     readonly ">="?: T;
 };
 
-type ValuesOf<C extends readonly Component.Key[]> = { readonly [K in C[number]]: Component.Value<K> };
+type ValuesOf<C extends readonly Component.Key[]> = { readonly [K in C[number]]: Component<K> };
 
 /**
  * Entities that have every component in `required`, every entity but the resource entity without it, and none in

package/src/observe/resource.ts

@@ -31,14 +31,14 @@ const createShape = (state: WorldState, byKey: Map<Resource.Key, ResourceShape>,
     const label = `Observe.resource(${key.description ?? "?"})`;
     // On a joined thread, first values come once a run of this system resolved, never in its pass: none to skip.
     const { joined } = state;
-    const notifier = System.create(labelled({ observer: true, resources: { changed: [key] } }, label, { resources: [key] }), ({ resources }) => {
+    const notifier = System.create(labelled({ readonly: true, resources: { changed: [key] } }, label, { resources: [key] }), ({ resources }) => {
         passed(state);
         entry.value = resources[key];
         entry.valid = true;
         if (entry.stopped > 0) sweepSubscribers(entry);
         throwFailed(give(entry, 0, true, state.pass, joined ? -1 : state.pass, none));
     });
-    const reader = System.create(labelled({ observer: true }, label, { resources: [key] }), ({ resources }) => {
+    const reader = System.create(labelled({ readonly: true }, label, { resources: [key] }), ({ resources }) => {
         const through = shape.called.shift() ?? 0;
         entry.value = resources[key];
         entry.valid = true;

package/src/observe/select.ts

@@ -161,7 +161,7 @@ const rangeOf = (condition: unknown): Range => {
     return bounds.length === 0 ? unbounded : { range, bounds, exact };
 };
 
-type Value = Component.Value<Component.Key>;
+type Value = Component<Component.Key>;
 
 /** A value or comparison a sorted index on one key part looks up by. */
 type Bound = Value | { readonly "<="?: Value; readonly ">="?: Value; readonly "=="?: Value };
@@ -403,16 +403,16 @@ const createShape = (state: WorldState, byShape: Map<string, QueryShape>, id: st
     };
 
     const tracker = ordered !== null
-        ? System.create(labelled({ observer: true, lookup: { list: { index: ordered, changed: reads } } }, name, { lookup: { list: reads } }), ({ lookup }) => {
+        ? System.create(labelled({ readonly: true, lookup: { list: { index: ordered, changed: reads } } }, name, { lookup: { list: reads } }), ({ lookup }) => {
             track(lookup.list(), null, fromSorted);
         })
         : byRange !== null
-            ? System.create(labelled({ observer: true, lookup: { list: { index: byRange, changed: reads } } }, name, { lookup: { list: reads } }), ({ lookup }) => {
+            ? System.create(labelled({ readonly: true, lookup: { list: { index: byRange, changed: reads } } }, name, { lookup: { list: reads } }), ({ lookup }) => {
                 // A range is of a `where` condition on the index's key, which the query's type checked against its
                 // values.
                 track(null, entry => ownRange(entry, range => lookup.list(range as Parameters<typeof lookup.list>[0]), () => lookup.list()), fromSorted);
             })
-            : System.create(labelled({ observer: true, lookup: { list: { index: keylessOf(has, not), changed: reads } } }, name, { lookup: { list: reads } }), ({ lookup }) => {
+            : System.create(labelled({ readonly: true, lookup: { list: { index: keylessOf(has, not), changed: reads } } }, name, { lookup: { list: reads } }), ({ lookup }) => {
                 track(lookup.list(), null, fromKeyless);
             });
 
@@ -466,7 +466,7 @@ const createShape = (state: WorldState, byShape: Map<string, QueryShape>, id: st
         for (const entry of scan.entries) entry.gather.start();
         accept = acceptOf(scan.entries);
     };
-    const scanner = System.create(labelled({ observer: true, components: { with: [...reads, ...required.filter(key => !reads.includes(key))], not } }, name, { components: reads }), row => {
+    const scanner = System.create(labelled({ readonly: true, components: { with: [...reads, ...required.filter(key => !reads.includes(key))], not } }, name, { components: reads }), row => {
         if (accept === null) start();
         if (direct === 0) {
             accept?.(row);

package/src/observe/values.ts

@@ -4,7 +4,7 @@ import type { Component, Resource } from '../interface/index.js';
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
 /** Component `K`'s value as observers give it: read-only, with branded primitives such as `Entity` as they are. */
-export type ReadonlyValue<K extends Component.Key> = Component.Value<K> extends Primitive ? Component.Value<K> : Readonly<Component.Value<K>>;
+export type ReadonlyType<K extends Component.Key> = Component<K> extends Primitive ? Component<K> : Readonly<Component<K>>;
 
 /** Resource `K`'s value as observers give it. */
-export type ReadonlyResourceValue<K extends Resource.Key> = Resource.Value<K> extends Primitive ? Resource.Value<K> : Readonly<Resource.Value<K>>;
+export type ReadonlyResourceType<K extends Resource.Key> = Resource<K> extends Primitive ? Resource<K> : Readonly<Resource<K>>;

package/src/observe/world-state.ts

@@ -116,7 +116,7 @@ const ignore = (): void => {
 };
 
 /** Runs nothing: a run of it resolves while its world lives. */
-const alive = System.create(labelled({ observer: true }, "Observe/alive"), () => {});
+const alive = System.create(labelled({ readonly: true }, "Observe/alive"), () => {});
 
 /**
  * What a rejected run of the factories' own does: nothing for a disposed world, whose first values never come, and for
@@ -232,7 +232,7 @@ export const stateOf = (world: World): WorldState => {
         deliveries: [],
         idle: [],
         rejected: rejectedOf(world),
-        deliver: System.create(labelled({ observer: true }, "Observe/deliver"), () => {
+        deliver: System.create(labelled({ readonly: true }, "Observe/deliver"), () => {
             const delivery = created.deliveries.shift();
             if (delivery === undefined) return;
             created.delivered = delivery.batch;
@@ -243,7 +243,7 @@ export const stateOf = (world: World): WorldState => {
     states.set(world, created);
     if (joined) return created;
     // Added before any shape's system, so in each pass it counts the pass before they run.
-    world.add(System.create(labelled({ observer: true }, "Observe/maintain"), () => {
+    world.add(System.create(labelled({ readonly: true }, "Observe/maintain"), () => {
         created.pass++;
         if (created.idle.length > 0) sweepShapes(created);
     }));

package/src/perftest/benchmarks.ts

@@ -505,7 +505,7 @@ export const benchmarks: readonly Benchmark[] = [
         run: async () => {
             const { world, roots } = await filteredForest();
             const found: { child: Entity | null } = { child: null };
-            await world.run(System.create({ observer: true, components: { with: [hierarchyParent] } }, row => {
+            await world.run(System.create({ readonly: true, components: { with: [hierarchyParent] } }, row => {
                 if (found.child === null && row[hierarchyParent] === roots[0]) found.child = row.entity;
             }));
             const { child } = found;

package/src/perftest/indexes.ts

@@ -307,13 +307,13 @@ const seedFlags = System.create({}, ({ commands }) => {
     for (let i = 0; i < flagged; i++) commands.spawn([flag])({ [flag]: i % 2 === 0 });
 });
 /** A run of observer systems alone, which passes every one added. */
-const pass = System.create({ observer: true }, () => {});
+const pass = System.create({ readonly: true }, () => {});
 /** A count of each bucket, written only when the index's entries changed: by `changed: true`, or by its lists' `changed`. */
 const countsWhenChanged = (filtered: boolean): System => filtered
-    ? System.create({ observer: true, lookup: { byFlag: { index: byFlag, changed: true } } }, ({ lookup }) => {
+    ? System.create({ readonly: true, lookup: { byFlag: { index: byFlag, changed: true } } }, ({ lookup }) => {
         found += lookup.byFlag(false).length + lookup.byFlag(true).length;
     })
-    : System.create({ observer: true, lookup: { byFlag: { index: byFlag } } }, ({ lookup }) => {
+    : System.create({ readonly: true, lookup: { byFlag: { index: byFlag } } }, ({ lookup }) => {
         const off = lookup.byFlag(false);
         const on = lookup.byFlag(true);
         if (!off.changed && !on.changed) return;

package/src/perftest/loop.ts

@@ -12,7 +12,7 @@ export const loopTicks = 10_000;
 export const observerIdles = 100;
 
 /** Observer systems no entity matches, each run after every tick. */
-const idleObserver = Array.from({ length: observerIdles }, (_, i) => System.create({ observer: true, components: { with: [unused] } }, () => {}));
+const idleObserver = Array.from({ length: observerIdles }, (_, i) => System.create({ readonly: true, components: { with: [unused] } }, () => {}));
 
 /**
  * The fastest of `stretches` stretches of `loopTicks` ticks with nothing changed, after one to warm up: a world with

package/src/perftest/observer.ts

@@ -14,14 +14,14 @@ import type { World } from "../interface/world/world.js";
  * first call only starts the stretch that warms up.
  */
 export const eachTick = (world: World, notify: () => void): (() => void) => {
-    const counter = System.create({ observer: true, resources: { changed: [clock] } }, () => { notify(); });
+    const counter = System.create({ readonly: true, resources: { changed: [clock] } }, () => { notify(); });
     world.add(counter);
     return () => world.remove(counter);
 };
 
 /** The clock as an observer run last read it. */
 const read = { tick: 0, now: 0 };
-const readClock = System.create({ observer: true }, ({ resources }) => {
+const readClock = System.create({ readonly: true }, ({ resources }) => {
     read.tick = resources[clock].tick;
     read.now = resources[clock].now;
 });
@@ -36,7 +36,7 @@ export const ticksAfter = async (world: World, count: number): Promise<void> =>
     let { tick, now } = read;
     let seen = 0;
     await new Promise<void>(resolve => {
-        const counter = System.create({ observer: true }, ({ resources }) => {
+        const counter = System.create({ readonly: true }, ({ resources }) => {
             const current = resources[clock];
             if (current.tick === tick && current.now === now) return;
             tick = current.tick;
@@ -52,7 +52,7 @@ export const ticksAfter = async (world: World, count: number): Promise<void> =>
 /** The entities with every component of `has` and none of `not`, in storage order, read by an observer run. */
 export const entitiesWith = async (world: World, has: readonly Component.Key[], not: readonly Component.Key[] = []): Promise<Entity[]> => {
     const found: Entity[] = [];
-    await world.run(System.create({ observer: true, components: { with: [...has], not } }, row => { found.push(row.entity); }));
+    await world.run(System.create({ readonly: true, components: { with: [...has], not } }, row => { found.push(row.entity); }));
     return found;
 };
 

package/src/perftest/reads.ts

@@ -78,7 +78,7 @@ const lookups = async (system: System): Promise<{ readonly best: number; readonl
 /** Every entity a seeded world holds. */
 const entitiesOf = async (world: World): Promise<readonly Entity[]> => {
     const found: Entity[] = [];
-    await world.run(System.create({ observer: true, components: { with: [value] } }, row => { found.push(row.entity); }));
+    await world.run(System.create({ readonly: true, components: { with: [value] } }, row => { found.push(row.entity); }));
     return found;
 };
 
@@ -124,7 +124,7 @@ export const readBenchmarks: readonly Benchmark[] = [
         run: async () => {
             const world = await seeded(10_000);
             copied = 0;
-            const best = await fastest(() => world.run(System.create({ observer: true }, ({ resources }) => { copied = resources[level]; })), 300);
+            const best = await fastest(() => world.run(System.create({ readonly: true }, ({ resources }) => { copied = resources[level]; })), 300);
             check(copied === 3, "read run observer: wrong value");
             await world.dispose();
             return best;

package/src/perftest/remote.ts

@@ -49,7 +49,7 @@ export const reorder = System.create([flip, reverse]);
 export const observerSeen = { last: 0, notified: 0 };
 
 /** On a joined thread, after each sync point that changed it: the observed resource. */
-export const observerCounter = System.create({ observer: true, resources: { changed: [counter] } }, ({ resources }) => {
+export const observerCounter = System.create({ readonly: true, resources: { changed: [counter] } }, ({ resources }) => {
     observerSeen.last = resources[counter];
     observerSeen.notified++;
 });
@@ -61,7 +61,7 @@ const sortedKeys = { keys: new Float64Array(0), entities: new Float64Array(0), p
  * On a joined thread, after each sync point: the entities in `order`, sorted from a scan of the index of every ranked
  * entity into reused arrays.
  */
-export const observerSelect = System.create({ observer: true, lookup: { all: { index: ranked } } }, ({ lookup }) => {
+export const observerSelect = System.create({ readonly: true, lookup: { all: { index: ranked } } }, ({ lookup }) => {
     const list = lookup.all();
     const count = list.length;
     if (sortedKeys.keys.length < count) {
@@ -99,12 +99,12 @@ export const retext = System.create([count, recaption]);
 export const reamounted = System.create([count, reamount]);
 
 /** On a joined thread, after each sync point: every row's caption, out of its record. */
-export const observerCaptions = System.create({ observer: true, components: { with: [caption] } }, row => {
+export const observerCaptions = System.create({ readonly: true, components: { with: [caption] } }, row => {
     observerSeen.last += row[caption].length;
     observerSeen.notified++;
 });
 /** On a joined thread, after each sync point: every row's amount. */
-export const observerAmounts = System.create({ observer: true, components: { with: [amount] } }, row => {
+export const observerAmounts = System.create({ readonly: true, components: { with: [amount] } }, row => {
     observerSeen.last += row[amount];
     observerSeen.notified++;
 });
@@ -129,7 +129,7 @@ const joinedFile = "./joined.js";
 /** The observed resource, read by an observer run. */
 const counterOf = async (world: World): Promise<number> => {
     let value = 0;
-    await world.run(System.create({ observer: true }, ({ resources }) => { value = resources[counter]; }));
+    await world.run(System.create({ readonly: true }, ({ resources }) => { value = resources[counter]; }));
     return value;
 };
 

package/src/perftest/strings.ts

@@ -80,7 +80,7 @@ const read = (system: System, name: string) => measure(system, async world => {
 /** Each row's text, as the last write left it. */
 const written = (name: string) => async (world: World): Promise<void> => {
     let wrong = 0;
-    await world.run(System.create({ observer: true, components: { with: [text, boxed] } }, row => {
+    await world.run(System.create({ readonly: true, components: { with: [text, boxed] } }, row => {
         if (row[text] !== row[boxed].text && row[text] !== labelOf(row.entity, round) && row[boxed].text !== labelOf(row.entity, round)) wrong++;
     }));
     check(wrong === 0, `${name}: wrong text`);