@adobe/ecs 0.2.0 → 0.2.3

package/src/interface/registry/schedule.ts

@@ -28,15 +28,15 @@ const checkInputs = (leaves: readonly Leaf[]): void => {
 
 /**
  * Leaves in run order, grouped into tiers. Leaves in one tier have no ordering path between them. `reductions` are the
- * resources its leaves reduce into, each with how many of them contribute. `observer` are its observer leaves, in no
+ * resources its leaves reduce into, each with how many of them contribute. `observer` are its readonly leaves, in no
  * tier: they run after its sync point, ordered with nothing.
  */
 export type Schedule = { readonly tiers: readonly (readonly Leaf[])[]; readonly reductions: ReadonlyMap<Key, number>; readonly observer: readonly Leaf[] };
 
 export const isLeaf = (system: Definition): system is Leaf => system.kind !== "composite";
 
-/** Whether a system is an observer leaf, which runs after a sync point rather than in a tier. */
-export const isObserver = (system: Definition): system is Leaf & { readonly declaration: { readonly observer: true } } => system.kind !== "composite" && system.declaration.observer === true;
+/** Whether a system is a readonly system leaf, which runs after a sync point rather than in a tier. */
+export const isObserver = (system: Definition): system is Leaf & { readonly declaration: { readonly readonly: true } } => system.kind !== "composite" && system.declaration.readonly === true;
 
 /** Each system is an interval, from its start node to its end node. */
 const start = (unit: number): number => 2 * unit;
@@ -65,7 +65,7 @@ const graphOf = (root: Definition): Graph => {
     };
     visit(root);
     const successors = units.flatMap(() => [new Set<number>(), new Set<number>()]);
-    // An observer system is ordered with nothing, so constraints naming one are ignored.
+    // A readonly system is ordered with nothing, so constraints naming one are ignored.
     const resolve = (systems: readonly object[] | undefined): readonly number[] =>
         (systems ?? []).flatMap(system => {
             const unit = indexOf.get(firstItemOf(system));

package/src/interface/resource/condition.ts

@@ -1,9 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Key } from "./key.js";
-import type { Value } from './value.js';
+import type { Type } from './value.js';
 
 /** The resources a system can run on the condition of: their type allows `null` or `false`. */
-export type Condition = { [K in Key]: null extends Value<K> ? K : false extends Value<K> ? K : never }[Key];
+export type Condition = { [K in Key]: null extends Type<K> ? K : false extends Type<K> ? K : never }[Key];
 
 /** A condition's value while `is` holds: neither `null` nor `false`. */
-export type Holding<K extends Key> = Exclude<Value<K>, null | false>;
+export type Holding<K extends Key> = Exclude<Type<K>, null | false>;

package/src/interface/resource/declarations.ts

@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Declared } from '../component/declared.js';
+import { declaredOf } from '../registry/names.js';
+import type { Key } from './key.js';
+
+/** Every resource its modules registered so far, with its declaration. */
+export const declarations = (): ReadonlyMap<Key, Declared> => {
+    // Registration takes only keys declared in `Resources`, so each symbol registered as a resource is one of its keys.
+    const found = declaredOf("resource") as ReadonlyMap<Key, Declared>;
+    return found;
+};

package/src/interface/resource/index.ts

@@ -1,3 +1,4 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export type { Key } from './key.js';
-export type { Value } from './value.js';
+export { declarations } from './declarations.js';
+export type { Declared } from '../component/declared.js';

package/src/interface/resource/resource.ts

@@ -1,5 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Key } from './key.js';
+import type { Type } from './value.js';
 
-export type Resource = never;
+/** The type of resource `K`'s value, as its record in `Resources` declares it: `Resource<typeof clock>`. */
+export type Resource<K extends Key> = Type<K>;
 
 export * as Resource from './index.js';

package/src/interface/resource/value.ts

@@ -3,19 +3,19 @@ import type { ThreadOf } from '../thread/of.js';
 import type { Key } from "./key.js";
 import type { Resources } from "./types.js";
 
-/** Every resource's value type, computed once so `Value` is a lookup. */
-type ValueTypes = { readonly [K in Key]: Resources[K] extends { readonly type: infer T } ? T : never };
+/** Every resource's value type, computed once so `Type` is a lookup. */
+type Types = { readonly [K in Key]: Resources[K] extends { readonly type: infer T } ? T : never };
 
 /** The value type of resource `K`. */
-export type Value<K extends Key> = ValueTypes[K];
+export type Type<K extends Key> = Types[K];
 
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
 /** Resource `K`'s value as reads return it: read-only, with branded primitives such as `Entity` as they are. */
-export type ReadonlyValue<K extends Key> = Value<K> extends Primitive ? Value<K> : Readonly<Value<K>>;
+export type ReadonlyType<K extends Key> = Type<K> extends Primitive ? Type<K> : Readonly<Type<K>>;
 
 /** Every resource's thread, computed once so `ThreadOf` is a lookup. */
-type Threads = { readonly [K in Key]: ThreadOf<Resources[K], Value<K>> };
+type Threads = { readonly [K in Key]: ThreadOf<Resources[K], Type<K>> };
 
 /** The thread resource `K` lives on, or `never` for a struct, which lives in shared memory. */
 export type ThreadOfResource<K extends Key> = Threads[K];

package/src/interface/resources/cadence.ts

@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { registerResource } from '../registry/declarations.js';
 
-/** The cadence's value, for the implementation: `Resource.Value<typeof cadence>`. */
+/** The cadence's value, for the implementation: `Resource<typeof cadence>`. */
 export type Cadence = { readonly kind: "frame" } | { readonly kind: "fixed"; readonly step: number; readonly maxSteps?: number };
 
 /**

package/src/interface/system/access.ts

@@ -26,7 +26,7 @@ export type ComponentAccess = {
      * that runs the system, once per archetype as it appears and again whenever a resource it reads changed. With
      * change filters, an archetype it skipped keeps its rows unseen until it passes again.
      */
-    readonly where?: { readonly [K in Shared]?: Component.Value<K> | ((value: Component.Value<K>, context: { readonly resources: ReadResources }) => boolean) };
+    readonly where?: { readonly [K in Shared]?: Component<K> | ((value: Component<K>, context: { readonly resources: ReadResources }) => boolean) };
 };
 
 /**

package/src/interface/system/body.ts

@@ -10,20 +10,21 @@ import type { Commands } from './commands.js';
 import type { Declaration } from './declaration.js';
 import type { Listed, Property } from './property.js';
 import type { RenderContext } from './render.js';
+import type { Tables } from './tables.js';
 import type { ComponentValues, LookupFunction, ResourceValues, Values } from './values.js';
 
 /** The components every entity a declaration matches has: those in `with`, `added` and `changed`. */
 export type Members<D> =
     | Listed<Property<D, "components">, "with"> | Listed<Property<D, "components">, "added"> | Listed<Property<D, "components">, "changed">;
 
-/** Whether a declaration only reads: an observer or a render system. */
-type Reading<D> = D extends { readonly observer: true } | { readonly shader: object } ? true : false;
+/** Whether a declaration only reads: one declared `readonly`, or a render system. */
+type Reading<D> = D extends { readonly readonly: true } | { readonly shader: object } ? true : false;
 
 /** The components a declaration's rows hold only where an entity has them. */
 export type Optional<D> = Exclude<Listed<Property<D, "components">, "optional">, Members<D>>;
 
 /** Each optional component's value or `undefined`, as `ComponentValues` gives members'. */
-type OptionalValues = { readonly [K in Component.Key]: Component.Value<K> | undefined };
+type OptionalValues = { readonly [K in Component.Key]: Component<K> | undefined };
 
 /**
  * Its members' values, writable but for references and shared components, and in a system that only reads; its
@@ -45,14 +46,14 @@ export type ReadResources = Values<Resource.Key, never, Resource.Key, ResourceVa
 export type WriteResources = Values<Resource.Key, Writes, Resource.Key, ResourceValues>;
 
 /** Each reduced resource, as a function contributing a value to the run's fold. */
-type Reductions = { readonly [K in Reduced]: (value: Resource.Value<K>) => void };
+type Reductions = { readonly [K in Reduced]: (value: Resource<K>) => void };
 
 type Is<D> = Listed<Property<D, "resources">, "is">;
 
 /**
  * What a body uses besides its row: every resource, its lookups by name, the resources it may reduce into, its
- * parent's values with `up`, and its commands, there for every system but a GPU kernel, a render system and an
- * observer system. The build infers which of them the body reads and writes.
+ * parent's values with `up`, and its commands, there for every system but a GPU kernel, a render system and one
+ * declared `readonly`. The build infers which of them the body reads and writes.
  */
 export type Context<D extends Declaration> =
     {
@@ -66,7 +67,8 @@ export type Context<D extends Declaration> =
         /** The parent's values the body reads, or null for a row without a parent or whose parent lacks one of them. */
         readonly up: ComponentValues | null;
     } : {})
-    & (D extends { readonly kernel: "gpu" } | { readonly shader: object } | { readonly observer: true } ? {} : { readonly commands: Commands });
+    & (D extends { readonly kernel: "gpu" } | { readonly shader: object } | { readonly readonly: true } ? {} : { readonly commands: Commands })
+    & (D extends { readonly tables: object } ? { readonly tables: Tables } : {});
 
 /**
  * `(row, context, input)` for a system with `components`, `(context, input)` for one without, and `(gpu, context)` for

package/src/interface/system/check.ts

@@ -147,15 +147,15 @@ const checkWhere = (leaf: Leaf): void => {
 };
 
 /**
- * Throws for what an observer system can't declare: it only reads, after a sync point, so it writes and reduces into
+ * Throws for what a readonly system can't declare: it only reads, after a sync point, so it writes and reduces into
  * nothing, takes no input, isn't a kernel or a render system, has no `up`, and is ordered with nothing.
  */
-const checkObserver = (leaf: Leaf): void => {
+const checkReadonly = (leaf: Leaf): void => {
     const { name, declaration } = leaf;
-    const { observer } = declaration;
-    if (observer === undefined) return;
-    const fail = (message: string): never => { throw new Error(`System "${name}" is an observer, so it ${message}.`); };
-    if (observer !== true) throw new Error(`System "${name}": observer is true or left out.`);
+    const { readonly } = declaration;
+    if (readonly === undefined) return;
+    const fail = (message: string): never => { throw new Error(`System "${name}" is readonly, so it ${message}.`); };
+    if (readonly !== true) throw new Error(`System "${name}": readonly is true or left out.`);
     if (leaf.kind === "render") fail("records no GPU work");
     if (declaration.kernel === true || declaration.kernel === "gpu") fail("isn't a kernel");
     if ((declaration.components?.write?.length ?? 0) + (declaration.resources?.write?.length ?? 0) > 0) fail("writes nothing");
@@ -165,9 +165,22 @@ const checkObserver = (leaf: Leaf): void => {
     if ((declaration.before?.length ?? 0) + (declaration.after?.length ?? 0) + (declaration.during?.length ?? 0) > 0) fail("is ordered with nothing");
 };
 
+/** Throws for `tables` on a system that isn't readonly or has components, or naming keys that aren't registered as their kind. */
+const checkTables = (leaf: Leaf): void => {
+    const { name, declaration } = leaf;
+    const { tables } = declaration;
+    if (tables === undefined) return;
+    if (declaration.readonly !== true) throw new Error(`System "${name}" reads tables, which only a readonly system reads.`);
+    if (declaration.components !== undefined) throw new Error(`System "${name}" reads tables, so it has no components.`);
+    requireRegistered("System", name, "component", tables.components);
+    requireRegistered("System", name, "component", tables.with);
+    requireRegistered("System", name, "component", tables.not);
+    requireRegistered("System", name, "resource", tables.resources);
+};
+
 /**
  * Throws for a leaf that names a component or resource that isn't registered as one, lists a key in both `read` and
- * `write`, writes a reference, has a lookup reading a component it writes, uses object components and resources of different threads, declares what an observer system can't, or whose
+ * `write`, writes a reference, has a lookup reading a component it writes, uses object components and resources of different threads, declares what a readonly system can't, or whose
  * reductions, conditions, `up` or placement can't hold.
  */
 export const checkLeaf = (leaf: Leaf): void => {
@@ -190,6 +203,7 @@ export const checkLeaf = (leaf: Leaf): void => {
         if (writes.has(key)) throw new Error(`System "${name}": its rows are ordered by an index keyed by "${labelOf(key)}", which the system writes.`);
     }
     checkTarget(leaf);
+    checkTables(leaf);
     threadOf(declaration, "System", name);
     requireRegistered("System", name, "component", components?.has);
     requireRegistered("System", name, "component", components?.not);
@@ -202,7 +216,7 @@ export const checkLeaf = (leaf: Leaf): void => {
         if (declarationOf(key)?.reference !== undefined) throw new Error(`System "${name}" writes "${labelOf(key)}", a reference, which changes only through commands.`);
         if (declarationOf(key)?.shared === true) throw new Error(`System "${name}" writes "${labelOf(key)}", a shared component, whose value is its archetype's: give it another with commands.add.`);
     }
-    checkObserver(leaf);
+    checkReadonly(leaf);
     checkWhere(leaf);
     checkReductions(leaf);
     checkConditions(leaf);

package/src/interface/system/commands.ts

@@ -2,16 +2,17 @@
 import type { Component } from '../component/component.js';
 import type { Entity } from '../entity/entity.js';
 import type { Essential, Shared } from '../component/value.js';
+import type { Table } from '../world/table/table.js';
 import type { ValuesOf } from './values-of.js';
 
 /** The value an `add` of one component takes: none for a tag. */
-type ValueArgument<K extends Essential> = Component.Value<K> extends true ? [value?: true] : [value: Component.Value<K>];
+type ValueArgument<K extends Essential> = Component<K> extends true ? [value?: true] : [value: Component<K>];
 
 /** Values of components of `C` a spawner's first call may give, constant for every entity it spawns. */
-type Preset<C extends readonly Essential[]> = { readonly [K in C[number]]?: Component.Value<K> };
+type Preset<C extends readonly Essential[]> = { readonly [K in C[number]]?: Component<K> };
 
 /** The value of each shared component of `C`, which a spawner's first call must give, since they choose the archetype. */
-type SharedPreset<C extends readonly Essential[]> = { readonly [K in C[number] & Shared]: Component.Value<K> };
+type SharedPreset<C extends readonly Essential[]> = { readonly [K in C[number] & Shared]: Component<K> };
 
 /**
  * Whether `C` names a shared component, so a spawner of it takes its constants: a list that isn't a tuple, whose
@@ -27,7 +28,7 @@ type Named<C extends readonly Essential[], P> = { readonly [K in Exclude<keyof P
  * the spawn takes their values first.
  */
 type Spawned<C extends readonly Essential[], P> = RequiresPreset<C> extends true
-    ? [keyof P] extends [never] ? C & { readonly "error: a spawn of a shared component takes its value first, in its constants": { readonly [K in C[number] & Shared]: Component.Value<K> } } : C
+    ? [keyof P] extends [never] ? C & { readonly "error: a spawn of a shared component takes its value first, in its constants": { readonly [K in C[number] & Shared]: Component<K> } } : C
     : C;
 
 /** Each component of `C` the constants `P` gave, whose value a spawn's values give again as a message naming it. */
@@ -68,4 +69,17 @@ export type Commands = {
     add<const C extends readonly Essential[]>(entity: Entity, components: C, values: ValuesOf<C>): void;
     remove(entity: Entity, component: Essential): void;
     remove(entity: Entity, components: readonly Essential[]): void;
+    /**
+     * Spawns an entity for each row of `tables`, as a readonly system's `tables` gives them, of each table's components
+     * with its columns' values: a block copy per column. Entity values are rewritten as the world's references would
+     * leave them had the entities outside the tables despawned: each naming an entity of the tables, a reference, a
+     * struct's field or an array's item, names the one spawned for it; a row whose owner reference names an entity
+     * outside them isn't spawned, nor anything it owns, through owner references, as despawning its owner would; a
+     * weak reference to one is left out of its row, which is spawned without it; any other value naming one is
+     * `Entity.none`. Returns, at once, each table's new entities, alive at the sync point. A column's stride must be its
+     * component's in this world, and its length its table's count. `resources` sets each resource it names, by key, at
+     * the sync point, as commands apply, each value checked against its resource's schema; not one only the world
+     * writes, nor one living on another thread. On the world's thread only.
+     */
+    spawnTables(tables: readonly Table[], resources?: { readonly [key: symbol]: unknown }): Table.Spawned;
 };

package/src/interface/system/create.test.ts

@@ -105,17 +105,17 @@ describe("System.create", () => {
             [{ kernel: "gpu", components: { write: [position], changed: [position] } }, "can't run on the GPU: GPU kernels don't support change filters yet"],
             [{ kernel: "gpu", components: { read: [position] }, lookup: { others: { read: [position] } } }, "can't run on the GPU: GPU kernels don't support lookups yet"],
             [{ kernel: "gpu", components: { has: [position] }, resources: { reduce: [total] } }, "can't run on the GPU: GPU kernels don't support reductions yet"],
-            [{ observer: false, resources: { read: [time] } }, "observer is true or left out"],
-            [{ observer: true, components: { write: [position] } }, "is an observer, so it writes nothing"],
-            [{ observer: true, resources: { write: [time] } }, "is an observer, so it writes nothing"],
-            [{ observer: true, components: { has: [position] }, resources: { reduce: [total] } }, "is an observer, so it reduces into nothing"],
-            [{ observer: true, kernel: true, components: { read: [position] } }, "is an observer, so it isn't a kernel"],
-            [{ observer: true, components: { read: [position] }, up: { through: parent } }, "is an observer, so it has no up"],
-            [{ observer: true, resources: { read: [time] }, after: [System.create(() => {})] }, "is an observer, so it is ordered with nothing"],
-            [{ observer: true, resources: { read: [time] }, before: [System.create(() => {})] }, "is an observer, so it is ordered with nothing"],
-            [{ observer: true, resources: { read: [time] }, during: [System.create(() => {})] }, "is an observer, so it is ordered with nothing"],
+            [{ readonly: false, resources: { read: [time] } }, "readonly is true or left out"],
+            [{ readonly: true, components: { write: [position] } }, "is readonly, so it writes nothing"],
+            [{ readonly: true, resources: { write: [time] } }, "is readonly, so it writes nothing"],
+            [{ readonly: true, components: { has: [position] }, resources: { reduce: [total] } }, "is readonly, so it reduces into nothing"],
+            [{ readonly: true, kernel: true, components: { read: [position] } }, "is readonly, so it isn't a kernel"],
+            [{ readonly: true, components: { read: [position] }, up: { through: parent } }, "is readonly, so it has no up"],
+            [{ readonly: true, resources: { read: [time] }, after: [System.create(() => {})] }, "is readonly, so it is ordered with nothing"],
+            [{ readonly: true, resources: { read: [time] }, before: [System.create(() => {})] }, "is readonly, so it is ordered with nothing"],
+            [{ readonly: true, resources: { read: [time] }, during: [System.create(() => {})] }, "is readonly, so it is ordered with nothing"],
         ];
-        expect(() => createTaking({ observer: true }, { type: "object", properties: {} })).toThrow("is an observer, so it takes no input");
+        expect(() => createTaking({ readonly: true }, { type: "object", properties: {} })).toThrow("is readonly, so it takes no input");
         rejected.forEach(([declaration, message], index) => {
             expect(() => create({ ...declaration })).toThrow(message);
         });
@@ -171,9 +171,9 @@ describe("System.create of a composite", () => {
         const looped = System.create({ before: [first], after: [second] }, () => {});
         expect(() => System.create({ systems: [first, second, looped] })).toThrow("Ordering cycle");
     });
-    it("runs observer members after its sync point, in no tier, never conflicting and ignoring constraints naming them", () => {
+    it("runs readonly members after its sync point, in no tier, never conflicting and ignoring constraints naming them", () => {
         const write = System.create({ components: { with: [position] } }, row => { row[position] += 1; });
-        const watch = System.create({ observer: true, components: { with: [position] } }, row => { void row[position]; });
+        const watch = System.create({ readonly: true, components: { with: [position] } }, row => { void row[position]; });
         const later = System.create({ components: { with: [position] }, after: [watch, write] }, row => { void row[position]; });
         const free = System.create({ after: [watch] }, ({ resources }) => { void resources[time]; });
         const schedule = scheduleOf(requireDefinition(System.create([write, watch, later, free])));
@@ -205,6 +205,6 @@ describe("System.render", () => {
         const render = (declaration: object, uses: Parameters<typeof giveAccess>[1] = {}): unknown => Reflect.apply(System.render, undefined, [giveAccess(declaration, uses), () => {}]);
         expect(() => System.render({ shader: { accessors: { loop: height } } }, () => {})).toThrow(`can't render: "loop" isn't usable as a WGSL function name.`);
         expect(() => render({ shader: { accessors: {} } }, { resources: { reduce: [total] } })).toThrow("writes or reduces into resources; a render system only reads");
-        expect(() => render({ shader: { accessors: {} }, observer: true })).toThrow("is an observer, so it records no GPU work");
+        expect(() => render({ shader: { accessors: {} }, readonly: true })).toThrow("is readonly, so it records no GPU work");
     });
 });

package/src/interface/system/create.ts

@@ -50,10 +50,10 @@ type GpuKernel = {
 };
 
 /**
- * An observer system only reads, after a sync point: its row and resources are read-only, and it never compiles to a
+ * A readonly system only reads, after a sync point: its row and resources are read-only, and it never compiles to a
  * kernel, has no `up`, and is ordered with nothing. That it takes no input is checked at its body.
  */
-type Observer = {
+type Readonly = {
     readonly kernel?: false;
     readonly up?: never;
     readonly before?: never;
@@ -97,7 +97,12 @@ type Validate<D extends Declaration> =
     // GPU kernels don't read components an archetype may lack yet.
     & (D extends { readonly components: { readonly optional: readonly [unknown, ...unknown[]] } }
         ? { readonly kernel?: boolean | { readonly "error: a GPU kernel can't have optional components yet": true } } : {})
-    & (D extends { readonly observer: true } ? Observer : {})
+    & (D extends { readonly readonly: true } ? Readonly : {})
+    // Tables are copies a readonly system without components reads.
+    & (D extends { readonly tables: object }
+        ? (D extends { readonly readonly: true } ? {} : { readonly tables?: { readonly "error: tables are read by a readonly system": true } })
+        & (Property<D, "components"> extends undefined ? {} : { readonly tables?: { readonly "error: a system reading tables has no components": true } })
+        : {})
     & (D extends { readonly target: string } ? Targeted : {})
     & (D extends { readonly target: string } ? Property<D, "components"> extends undefined ? { readonly target?: { readonly "error: a system on one entity runs on its row, so it needs components": true } } : {} : {})
     // A body's input is the type of its parameter after its context, not part of its declaration.
@@ -109,7 +114,7 @@ type EntityFields<I> = { [K in keyof I]-?: [Exclude<I[K], undefined>] extends [E
 /**
  * What a declaration requires of the input its body takes, checked at the body, since the input is known only once the
  * body is: a target names an entity field of it, and a system with input doesn't filter on added or changed, as its
- * runs pass different input, nor is it an observer. Every check passes for `never`, the input before the body is
+ * runs pass different input, nor is it a readonly system. Every check passes for `never`, the input before the body is
  * inferred.
  */
 type Checks<D, I> = [I] extends [never] ? unknown :
@@ -119,7 +124,7 @@ type Checks<D, I> = [I] extends [never] ? unknown :
         : unknown)
     & ([I] extends [undefined] ? unknown
         : (D extends { readonly components: { readonly added: object } | { readonly changed: object } } ? { readonly "error: a system with input can't filter on added or changed, as its runs pass different input; pass it through a resource": true } : unknown)
-        & (D extends { readonly observer: true } ? { readonly "error: an observer system takes no input": true } : unknown));
+        & (D extends { readonly readonly: true } ? { readonly "error: a readonly system takes no input": true } : unknown));
 
 /** The body of a system that declares nothing, which runs once per run with its resources and commands. */
 type Alone = (context: Context<{}>) => void;
@@ -144,10 +149,10 @@ type Checked<C> = C extends Alone ? ReturnsNoPromise<C> : C extends CompositeDec
  * input, with every field of theirs. Throws if a system names a key that isn't registered as its kind, its body writes
  * a reference, a lookup's rows are read where it writes them or it goes through an index keyed by what it writes, its
  * rows are ordered by an index it isn't sorted or keyed by what it writes, its object components and resources live on
- * different threads, or its reductions, conditions, `up`, `order` or placement can't hold, or it's an observer and
+ * different threads, or its reductions, conditions, `up`, `order` or placement can't hold, or it's a readonly system and
  * writes, reduces, takes input, is a kernel, has `up` or is ordered; if the build couldn't follow how its body uses its
  * resources, lookups or parent; or if a composite's member isn't a system a constructor returned, or two members
- * declare an input field with different schemas. A composite's observer members run after its sync point, ordered
+ * declare an input field with different schemas. A composite's readonly members run after its sync point, ordered
  * with nothing.
  *
  * A run of a system without components resolves to what its body returns, or `undefined` when its conditions, resource
@@ -180,13 +185,13 @@ export function create(first: Declaration | Leaf["body"] | readonly System<unkno
 
 /** A declaration as the world takes it, with what the build inferred its body uses. */
 const resolve = (what: string, declared: Declaration, access: ReturnType<typeof accessOf>): Resolved => {
-    const reading = declared.observer === true;
+    const reading = declared.readonly === true;
     const { components, lookup, up, resources, ...rest } = declared;
     const uses = resourceUses(what, access, resources?.is);
-    // What `where`'s predicates read counts as the system's reads, for its order, conflicts and placement.
     const whereReads = whereReadsOf(what, components, access);
     const conditions: readonly symbol[] = resources?.is ?? [];
-    for (const key of whereReads) if (!uses.read.includes(key) && !uses.write.includes(key) && !conditions.includes(key)) uses.read.push(key);
+    // What `where`'s predicates and `tables` read counts as the system's reads, for its order, conflicts and placement.
+    for (const key of [...whereReads, ...declared.tables?.resources ?? []]) if (!uses.read.includes(key) && !uses.write.includes(key) && !conditions.includes(key)) uses.read.push(key);
     const resolved: Resolved = {
         ...rest,
         ...components === undefined ? {} : { components: componentLists(components, access.components, reading, whereReads) },

package/src/interface/system/declaration.ts

@@ -4,6 +4,7 @@ import type { Resource } from '../resource/resource.js';
 import type { ComponentAccess, ComponentLists, ResourceAccess, ResourceLists, SystemLookup, SystemLookupLists, Up, UpLists } from './access.js';
 import type { Shader } from './render.js';
 import type { System } from './system.js';
+import type { TablesDeclaration } from './tables.js';
 
 /**
  * A system never declares its thread: it runs on the one its object components and resources live on, those it
@@ -59,9 +60,15 @@ export type Declaration = {
     readonly during?: readonly System<unknown>[];
     /**
      * Runs after the last sync point of each run and tick (a tick is a run of the added composite), reading the settled
-     * state; changes nothing; never ordered; doesn't keep the loop ticking.
+     * state, on the thread that added or ran it; changes nothing, its row and resources typed read-only and its context
+     * without `commands`; takes no input; never ordered; doesn't keep the loop ticking. A joined thread adds only these.
      */
-    readonly observer?: true;
+    readonly readonly?: true;
+    /**
+     * For a readonly system without components: gives its context `tables`, copies of whole archetypes' columns, as
+     * `TablesDeclaration` says, read on the world's thread. Its components and resources count as what it reads.
+     */
+    readonly tables?: TablesDeclaration;
 };
 
 /** A declaration as the world takes it: the build's inferred reads, writes and reductions joined with what it declares. */

package/src/interface/system/lists.type-test.ts

@@ -23,7 +23,7 @@ export const Particle = [position, velocity] as const;
 expectType<Equal<typeof Particle, readonly [typeof position, typeof velocity]>>();
 export const one: readonly Component.Key[] = Particle;
 export const move = System.create({ components: { with: [...Particle] } }, row => { row[position] += row[velocity]; });
-export const read = System.create({ observer: true, components: { with: [...Particle] } }, row => { void row[velocity]; });
+export const read = System.create({ readonly: true, components: { with: [...Particle] } }, row => { void row[velocity]; });
 
 // Declared without `as const`, a list's keys widen to `symbol`, which no list of components takes.
 const loose = [position, velocity];

package/src/interface/system/optional.type-test.ts

@@ -36,7 +36,7 @@ System.create({
 }, row => { void row[velocity]; });
 
 // An observer system reads its optional components and writes nothing.
-System.create({ observer: true, components: { with: [position], optional: [velocity] } }, row => {
+System.create({ readonly: true, components: { with: [position], optional: [velocity] } }, row => {
     void row[velocity];
     // @ts-expect-error an observer system's row is read-only
     row[velocity] = 1;

package/src/interface/system/shared.type-test.ts

@@ -126,7 +126,7 @@ System.create({ components: { with: [health], optional: [team] } }, row => {
     // @ts-expect-error nor an optional one
     row[team] = "red";
 });
-System.create({ observer: true, components: { with: [team] } }, row => {
+System.create({ readonly: true, components: { with: [team] } }, row => {
     check<Equal<typeof row[typeof team], "red" | "blue">>();
 });
 

package/src/interface/system/struct.ts

@@ -4,7 +4,7 @@ import type { Resource } from '../resource/resource.js';
 import type { IsStruct } from '../schema/is-struct.js';
 
 /** Components whose values are structs, which kernels read and write. */
-export type StructComponent = { [K in Component.Key]: IsStruct<Component.Value<K>> extends true ? K : never }[Component.Key];
+export type StructComponent = { [K in Component.Key]: IsStruct<Component<K>> extends true ? K : never }[Component.Key];
 
 /** Resources whose values are structs, which kernels read. */
-export type StructResource = { [K in Resource.Key]: IsStruct<Resource.Value<K>> extends true ? K : never }[Resource.Key];
+export type StructResource = { [K in Resource.Key]: IsStruct<Resource<K>> extends true ? K : never }[Resource.Key];

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

@@ -367,7 +367,7 @@ System.render({ shader: { accessors: { place: position } } }, gpu => { void gpu.
 
 // Observer systems read what a sync point left, after it: rows, resources, lookups and change filters, and no commands.
 export const watchPositions = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position], changed: [position] },
     lookup: { targets: { with: [velocity] } },
 }, (row, context) => {
@@ -379,33 +379,39 @@ export const watchPositions = System.create({
     void context.commands;
 });
 check<Equal<typeof watchPositions, System>>();
-export const watchTime = System.create({ observer: true, resources: { changed: [time] } }, ({ resources }) => { void resources[time]; });
+export const watchTime = System.create({ readonly: true, resources: { changed: [time] } }, ({ resources }) => { void resources[time]; });
 // A composite may hold observer members, which run after its sync point.
 export const withWatch = System.create([integrate, watchTime]);
 check<Equal<typeof withWatch, System>>();
-// @ts-expect-error observer is true or left out
-System.create({ observer: false }, () => {});
-System.create({ observer: true, components: { with: [position] } }, (row, { resources }) => {
-    // @ts-expect-error an observer system writes no components
+// @ts-expect-error observer isn't a declaration's: readonly is
+System.create({ observer: true }, () => {});
+// @ts-expect-error readonly is true or left out
+System.create({ readonly: false }, () => {});
+System.create({ readonly: true, components: { with: [position] } }, (row, { resources }) => {
+    // @ts-expect-error a readonly system writes no components
     row[position] = 0;
-    // @ts-expect-error an observer system writes no resources
+    // @ts-expect-error a readonly system writes no resources
     resources[score] = 0;
 });
-System.create({ observer: true }, context => {
-    // @ts-expect-error an observer system reduces into nothing
+System.create({ readonly: true }, context => {
+    // @ts-expect-error a readonly system reduces into nothing
     void context.reduce;
+    // @ts-expect-error a readonly system has no commands
+    void context.commands;
 });
-// @ts-expect-error an observer system takes no input
-System.create({ observer: true }, (_context, input: { readonly count: number }) => { void input; });
-// @ts-expect-error an observer system isn't a kernel
-System.create({ observer: true, kernel: true, components: { with: [position] } }, () => {});
-System.create({ observer: true, kernel: false, components: { with: [position] } }, () => {});
-// @ts-expect-error an observer system is ordered with nothing
-System.create({ observer: true, after: [integrate] }, () => {});
-// @ts-expect-error an observer system is ordered with nothing
-System.create({ observer: true, before: [integrate] }, () => {});
-// @ts-expect-error an observer system is ordered with nothing
-System.create({ observer: true, during: [integrate] }, () => {});
+// @ts-expect-error a readonly system takes no input
+System.create({ readonly: true }, (_context, input: { readonly count: number }) => { void input; });
+// @ts-expect-error a readonly system isn't a kernel
+System.create({ readonly: true, kernel: true, components: { with: [position] } }, () => {});
+// @ts-expect-error a readonly system isn't a GPU kernel
+System.create({ readonly: true, kernel: "gpu", components: { with: [position] } }, () => {});
+System.create({ readonly: true, kernel: false, components: { with: [position] } }, () => {});
+// @ts-expect-error a readonly system is ordered with nothing
+System.create({ readonly: true, after: [integrate] }, () => {});
+// @ts-expect-error a readonly system is ordered with nothing
+System.create({ readonly: true, before: [integrate] }, () => {});
+// @ts-expect-error a readonly system is ordered with nothing
+System.create({ readonly: true, during: [integrate] }, () => {});
 
 // A system on one entity: its input names the entity, and its body runs on that entity's row.
 type OnOne = { readonly entity: Entity; readonly by: number };

package/src/interface/system/tables.ts

@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+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/src/interface/system/up.type-test.ts

@@ -62,6 +62,6 @@ System.create({
     up: { through: parent },
 }, () => {});
 
-// An observer system reads what a sync point left, in no order.
-// @ts-expect-error an observer system has no up
-System.create({ observer: true, components: { with: [local] }, up: { through: parent } }, () => {});
+// A readonly system reads what a sync point left, in no order.
+// @ts-expect-error a readonly system has no up
+System.create({ readonly: true, components: { with: [local] }, up: { through: parent } }, () => {});

package/src/interface/system/values-of.ts

@@ -2,7 +2,7 @@
 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`
@@ -12,6 +12,6 @@ type Omissible<K extends Component.Key> = Component.Value<K> extends true ? K :
  */
 export type ValuesOf<C extends readonly Component.Key[], Given extends PropertyKey = never> = number extends C["length"]
     // A list whose components aren't known until it runs, so any of them may be given.
-    ? { readonly [K in Exclude<C[number], Given>]?: Component.Value<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> ? K : never]?: 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<K> }
+        & { readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? K : never]?: Component<K> };