@adobe/ecs 0.2.1 → 0.2.3

package/src/implementation/world/thread-systems.ts

@@ -279,6 +279,7 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
             return typeof preset === "object" && preset !== null ? presetSpawnerOf(components, preset) : spawnerOf(components);
         },
         despawn: entity => beginCommand(writer, despawnCommand, entity),
+        spawnTables: () => { throw new Error("commands.spawnTables runs on the world's thread: run the system there."); },
         add: (entity: number, components: symbol | readonly symbol[], values?: unknown) => {
             if (typeof components === "symbol") {
                 const key = givenKeyOf(components);

package/src/implementation/world/where.test.ts

@@ -62,10 +62,10 @@ export const noteInView = System.create({ components: { with: [position, note],
     row[note] = { text: `${row[position]}` };
 });
 const heard: number[] = [];
-export const hearInView = System.create({ observer: true, components: { with: [position], changed: [position], where: { [cell]: (at, { resources }) => visible(at, resources[camera].x, resources[camera].radius) } } }, row => { heard.push(row[position]); });
+export const hearInView = System.create({ readonly: true, components: { with: [position], changed: [position], where: { [cell]: (at, { resources }) => visible(at, resources[camera].x, resources[camera].radius) } } }, row => { heard.push(row[position]); });
 // Filtered by a resource the predicate doesn't read: a culled archetype coming into view catches up on its change.
 const signalled: number[] = [];
-export const signalInView = System.create({ observer: true, components: { with: [position], where: { [cell]: (at, { resources }) => visible(at, resources[camera].x, resources[camera].radius) } }, resources: { changed: [other] } }, row => { signalled.push(row[position]); });
+export const signalInView = System.create({ readonly: true, components: { with: [position], where: { [cell]: (at, { resources }) => visible(at, resources[camera].x, resources[camera].radius) } }, resources: { changed: [other] } }, row => { signalled.push(row[position]); });
 // A system moving the camera its own predicate reads: its next run sees the new view.
 const followed: number[] = [];
 export const follow = System.create({ components: { with: [position], where: { [cell]: (at, { resources }) => visible(at, resources[camera].x, resources[camera].radius) } } }, (row, { resources }) => {
@@ -79,7 +79,7 @@ export const noteChanged = System.create({ components: { with: [position, note],
     row[note] = { text: `${row[position]}` };
 });
 const notes: string[] = [];
-export const readNotes = System.create({ observer: true, components: { with: [note] } }, row => { if (row[note] !== null) notes.push(row[note].text); });
+export const readNotes = System.create({ readonly: true, components: { with: [note] } }, row => { if (row[note] !== null) notes.push(row[note].text); });
 export const nudgeNoted = System.create({ components: { with: [position, note] } }, row => { row[position] += 0.5; });
 
 /** Waits a turn at a time until `done`, for two seconds at most. */
@@ -91,7 +91,7 @@ const until = async (done: () => boolean): Promise<void> => {
 /** Every row's position and how often it was seen, by position. */
 const seenOf = async (world: ReturnType<typeof createWorld>): Promise<readonly string[]> => {
     const read: [number, string][] = [];
-    await world.run(System.create({ observer: true, components: { with: [position, seen] } }, row => { read.push([row[position], `${row[position]}:${row[seen]}`]); }));
+    await world.run(System.create({ readonly: true, components: { with: [position, seen] } }, row => { read.push([row[position], `${row[position]}:${row[seen]}`]); }));
     return read.sort((a, b) => a[0] - b[0]).map(([, text]) => text).filter(text => !text.endsWith(":0"));
 };
 

package/src/implementation/world/workers.fixture.ts

@@ -149,8 +149,8 @@ const emitted = { seen: 0 };
 const countEmitted = System.create({ components: { added: [position], with: [spawned] } }, () => { emitted.seen++; });
 
 const gathered: Entity[] = [];
-const gatherPositioned = System.create({ observer: true, components: { with: [position] } }, row => { gathered.push(row.entity); });
-const gatherSpawned = System.create({ observer: true, components: { with: [spawned] } }, row => { gathered.push(row.entity); });
+const gatherPositioned = System.create({ readonly: true, components: { with: [position] } }, row => { gathered.push(row.entity); });
+const gatherSpawned = System.create({ readonly: true, components: { with: [spawned] } }, row => { gathered.push(row.entity); });
 
 /** The entities an observer row system passes, in storage order. */
 const storageOrder = async (world: World, gather: System<void>): Promise<Entity[]> => {

package/src/index.ts

@@ -3,9 +3,6 @@
  * A high-performance, multithreaded Entity Component System.
  * @module @adobe/ecs
  */
-import { create, join } from './implementation/index.js';
-import type { Create } from './interface/world/create.js';
-import type { Join } from './interface/world/join.js';
 import type { World as Created } from './interface/world/world.js';
 
 export * from './interface/index.js';
@@ -15,30 +12,8 @@ export type World = Created;
 
 /**
  * How a world is made, `World.create(resources?)`, on the thread that will run it, with resources starting at the given
- * values in place of their defaults; and how another thread joins one that shared itself with it,
- * `World.join(port, { threads })`.
+ * values in place of their defaults; how another thread joins one that shared itself with it,
+ * `World.join(port, { threads })`; and `World.Table`, an archetype's rows as a readonly system's `tables` copies them
+ * and `commands.spawnTables` spawns them.
  */
-export const World: {
-    /**
-     * 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.
-     */
-    readonly 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
-     * 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.
-     */
-    readonly join: Join;
-} = { create, join };
+export * as World from './world.js';

package/src/interface/component/declarations.ts

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

package/src/interface/component/declared.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Schema } from '../schema/schema.js';
+import type { Key as TraitKey } from '../trait/key.js';
+
+/**
+ * A component's or resource's declaration as registered: its schema as `type` where its value is data, what it
+ * starts at as `default`, and its other traits, the built-in ones by name and those of your own by their keys.
+ */
+export type Declared = { readonly type?: Schema; readonly default?: unknown } & { readonly [T in TraitKey]?: unknown };

package/src/interface/component/index.ts

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

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

@@ -27,8 +27,8 @@ Rule.create({ components: { with: [position] }, derive: [slot] });
 declare const create: Create;
 declare const wgsl: typeof Gpu.wgsl;
 export const world = create({ [workers]: 4, [gpuDevice]: null });
-export const read = System.create({ observer: true, components: { with: [position, slot] } }, () => {});
-export const readOne = System.create({ observer: true, lookup: { at: { with: [position, slot] } } }, () => {});
+export const read = System.create({ readonly: true, components: { with: [position, slot] } }, () => {});
+export const readOne = System.create({ readonly: true, lookup: { at: { with: [position, slot] } } }, () => {});
 export const report = world.run(all);
 export const shader = wgsl(draw);
 export const added = world.add(read);

package/src/interface/indexes/index.type-test.ts

@@ -219,7 +219,7 @@ System.create({
 
 // An index lookup's `changed: true` runs its system only when the index's entries changed since it last ran: its
 // lists' `changed` then reports entries alone. Observer systems and CPU kernels take it; it's not a list of components.
-System.create({ observer: true, lookup: { living: { index: living, changed: true } } }, ({ lookup }) => {
+System.create({ readonly: true, lookup: { living: { index: living, changed: true } } }, ({ lookup }) => {
     const rows = lookup.living();
     check<Equal<typeof rows.changed, boolean>>();
     check<Equal<typeof rows.length, number>>();

package/src/interface/registry/names.ts

@@ -61,6 +61,14 @@ const entryOf = (key: symbol): Entry | undefined => {
     return entries.get(key);
 };
 
+/** Every key registered as `kind`, each by the symbol a world gives its values by, with its declaration. */
+export const declaredOf = (kind: "component" | "resource"): ReadonlyMap<symbol, AnyDeclaration> => {
+    catchUp();
+    const found = new Map<symbol, AnyDeclaration>();
+    for (const entry of entries.values()) if (entry.kind === kind && entry.declaration !== undefined) found.set(entry.newest, entry.declaration);
+    return found;
+};
+
 /** Whether a key is a component, a resource or a trait. */
 export const kindOf = (key: unknown): Kind | undefined => typeof key === "symbol" ? entryOf(key)?.kind : undefined;
 

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/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,2 +1,4 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export type { Key } from './key.js';
+export { declarations } from './declarations.js';
+export type { Declared } from '../component/declared.js';

package/src/interface/system/body.ts

@@ -10,14 +10,15 @@ 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>>;
@@ -51,8 +52,8 @@ 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,6 +2,7 @@
 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. */
@@ -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/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 };