@adobe/ecs 0.2.0 → 0.2.3

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

@@ -5,7 +5,7 @@ import { Component } from "../index.js";
 export const instanced = Symbol();
 declare module "@adobe/ecs" {
     interface Traits<N> {
-        readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never;
+        readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never;
     }
 }
 

package/src/guide/12-lookups.ts

@@ -25,7 +25,7 @@ const track = System.create({
 
 const refreshed: boolean[] = [];
 const watch = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [target] },
     lookup: { enemy: { with: [health], changed: [health] } },
 }, (row, { lookup }) => {
@@ -34,7 +34,7 @@ const watch = System.create({
 });
 
 const aims: number[] = [];
-const readAims = System.create({ observer: true, components: { with: [aim] } }, row => {
+const readAims = System.create({ readonly: true, components: { with: [aim] } }, row => {
     aims.push(row[aim]);
 });
 

package/src/guide/13-indexes.ts

@@ -26,14 +26,14 @@ const count = System.create({ components: { with: [cell, crowded] }, lookup: { a
 
 const byScore = Index.create({ key: [score], sorted: true, components: { with: [player] } });
 
-const leaders = System.create({ observer: true, lookup: { scores: { index: byScore } } }, ({ lookup }) => {
+const leaders = System.create({ readonly: true, lookup: { scores: { index: byScore } } }, ({ lookup }) => {
     const winners: string[] = [];
     const high = lookup.scores({ ">=": 90 });
     for (let i = 0; i < high.length; i++) winners.push(high.at(i)[player]);
     return winners;
 });
 
-const list = System.create({ observer: true, components: { with: [player, score] }, order: byScore }, row => {
+const list = System.create({ readonly: true, components: { with: [player, score] }, order: byScore }, row => {
     console.log(row[player], row[score]);
 });
 
@@ -42,12 +42,12 @@ const find = System.create({ lookup: { byId: { index: byServerId } } }, ({ looku
     lookup.byId(input.id)?.[player] ?? null);
 
 const players = Index.create({ key: [], components: { with: [player] } });
-const countPlayers = System.create({ observer: true, lookup: { players: { index: players, changed: true } } }, ({ lookup }) => {
+const countPlayers = System.create({ readonly: true, lookup: { players: { index: players, changed: true } } }, ({ lookup }) => {
     console.log("players", lookup.players().length);
 });
 
 const crowds: number[] = [];
-const readCrowds = System.create({ observer: true, components: { with: [crowded] } }, row => {
+const readCrowds = System.create({ readonly: true, components: { with: [crowded] } }, row => {
     crowds.push(row[crowded]);
 });
 

package/src/guide/14-kernels.ts

@@ -29,7 +29,7 @@ const slow = System.create({ kernel: false, components: { with: [velocity] } },
 });
 
 const moved: string[] = [];
-const read = System.create({ observer: true, components: { with: [position, velocity] } }, row => {
+const read = System.create({ readonly: true, components: { with: [position, velocity] } }, row => {
     moved.push(`at ${row[position][0]}, moving at ${row[velocity][0]}`);
 });
 

package/src/guide/15-reductions.ts

@@ -23,7 +23,7 @@ const weigh = System.create({ components: { with: [mass] } }, (row, { reduce })
     reduce[count](1);
 });
 
-const report = System.create({ observer: true }, ({ resources }) =>
+const report = System.create({ readonly: true }, ({ resources }) =>
     `${resources[count]} weigh ${resources[total]}, at most ${resources[heaviest]}`);
 
 const spawn = System.create(({ commands }) => {

package/src/guide/16-gpu.ts

@@ -32,7 +32,7 @@ const draw = System.render({ shader: { accessors: { dotPosition: position, dotSi
 });
 const shaderCode = Gpu.wgsl(draw);
 
-const read = System.create({ observer: true, components: { with: [position] } }, row => {
+const read = System.create({ readonly: true, components: { with: [position] } }, row => {
     console.log("at", row[position]);
 });
 

package/src/guide/17-hierarchies.ts

@@ -21,7 +21,7 @@ const place = System.create({ components: { with: [offset, placed] }, up: { thro
 });
 
 const where: string[] = [];
-const read = System.create({ observer: true, components: { with: [label, placed] } }, row => {
+const read = System.create({ readonly: true, components: { with: [label, placed] } }, row => {
     where.push(`${row[label]} at ${row[placed]}`);
 });
 

package/src/guide/18-identity.out

@@ -1 +1 @@
-Error: System "explode" (@adobe/ecs@0.2.0/src/guide/18-identity.ts#explode) failed: boom
+Error: System "explode" (@adobe/ecs@0.2.3/src/guide/18-identity.ts#explode) failed: boom

package/src/guide/19-threads.md

@@ -11,6 +11,8 @@ A *logical thread* is where objects live and the code touching them runs: the pa
 `World.join(port, { threads: ["audio"] })`, claiming the threads it fills. Usually the other end of the channel goes
 to a worker; [here both ends](19-threads.ts#L44-L54) are on one thread.
 
-- `share` resolves once the thread joined, with the observer systems it added as `join` resolved, before awaiting
-  anything else. Those observers run there after the world's sync points: `listen` hears what `mix` wrote.
+- `share` resolves once the thread joined, with the readonly systems it added as `join` resolved, before awaiting
+  anything else. Those readonly systems run there after the world's sync points: `listen` hears what `mix` wrote.
+- A joined thread adds only [readonly systems](03-systems.md), which run on it; a system that writes is added on the
+  world's thread.
 - A joined world runs systems as the world does: [`audio.run`](19-threads.ts#L60-L61) spawns and mixes too.

package/src/guide/19-threads.ts

@@ -22,7 +22,7 @@ const mix = System.create({ components: { with: [volume] } }, (row, { resources
 });
 
 let heard = 0;
-const listen = System.create({ observer: true }, ({ resources }) => {
+const listen = System.create({ readonly: true }, ({ resources }) => {
     heard = resources[levels].size;
 });
 
@@ -31,7 +31,7 @@ const spawn = System.create(({ commands }) => {
     commands.spawn([volume])({ [volume]: 0.3 });
 });
 
-const countVoices = System.create({ observer: true }, ({ resources }) => resources[levels].size);
+const countVoices = System.create({ readonly: true }, ({ resources }) => resources[levels].size);
 
 /** Waits a turn of the event loop at a time until `done`, for two seconds at most. */
 const until = async (done: () => boolean): Promise<void> => {

package/src/guide/20-shared.ts

@@ -56,7 +56,7 @@ let drawn = 0;
 let left = Infinity;
 let right = -Infinity;
 const draw = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position], where: { [cell]: (at, { resources }) => resources[camera]?.sees(at) === true } },
 }, row => {
     drawn += 1;
@@ -66,7 +66,7 @@ const draw = System.create({
 
 let refreshed = 0;
 const refresh = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position], changed: [position], where: { [cell]: (at, { resources }) => resources[camera]?.sees(at) === true } },
 }, () => {
     refreshed += 1;
@@ -74,7 +74,7 @@ const refresh = System.create({
 
 // Only chunk [4, 0], which no unit is in until one crosses into it.
 let east = 0;
-const countEast = System.create({ observer: true, components: { with: [position], where: { [cell]: [4, 0] } } }, () => {
+const countEast = System.create({ readonly: true, components: { with: [position], where: { [cell]: [4, 0] } } }, () => {
     east += 1;
 });
 

package/src/guide/21-dom.md

@@ -13,9 +13,9 @@ same.
 Each tick runs one composite:
 
 1. [`move`](21-dom.ts#L38-L44) moves every particle and turns it back from the walls.
-2. [`create`](21-dom.ts#L46-L51) gives each particle without a dot an element, with `commands.add`. Observers can't
+2. [`create`](21-dom.ts#L46-L51) gives each particle without a dot an element, with `commands.add`. Readonly systems can't
    issue commands, so it ticks, and its condition `is: [stage]` waits for a stage.
-3. [`draw`](21-dom.ts#L52-L60), an observer, sets each moved dot's `style.translate`, a transform, which the page
+3. [`draw`](21-dom.ts#L52-L60), a readonly system, sets each moved dot's `style.translate`, a transform, which the page
    doesn't lay out again. `changed: [position]` skips the dots that didn't move.
 
 [A finalizer](21-dom.ts#L61-L63) removes a particle's element when the particle goes, and every element when the

package/src/guide/21-dom.ts

@@ -51,7 +51,7 @@ const create = System.create({ components: { with: [position], not: [dot] }, res
 });
 // Moves each dot whose particle moved, by a transform, which the page doesn't lay out again.
 const draw = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position, dot], optional: [traced], changed: [position] },
 }, (row, { resources }) => {
     const [x, y] = row[position];

package/src/guide/22-canvas.md

@@ -2,7 +2,7 @@
 
 The same particles, drawn in immediate mode: each frame, the canvas is cleared and drawn again whole.
 
-[`draw`](22-canvas.ts#L52-L80) is one observer without components, so it runs once per tick, not per particle.
+[`draw`](22-canvas.ts#L52-L80) is one readonly system without components, so it runs once per tick, not per particle.
 
 - `changed: [clock]` runs it after every tick, and `is: [pen]` waits for a 2D context.
 - It reads every particle through [an index without a key](22-canvas.ts#L50-L51), `key: []`, and the traced one

package/src/guide/22-canvas.ts

@@ -51,7 +51,7 @@ const particles = Index.create({ key: [], components: { with: [position] } });
 const tracedOnes = Index.create({ key: [], components: { with: [position, traced] } });
 // Clears the canvas and draws every particle, after each tick.
 const draw = System.create({
-    observer: true,
+    readonly: true,
     resources: { is: [pen], changed: [clock] },
     lookup: { particles: { index: particles }, traced: { index: tracedOnes } },
 }, ({ resources, lookup }) => {

package/src/guide/CLAUDE.md

@@ -45,5 +45,5 @@ it in `NN-name.type-test.ts`, under a `// @ts-expect-error` that the package's b
   before they're printed.
 - Keys are `Symbol()` with no description: the build's id names each by its binding.
 - Archetypes are types, so their names are PascalCase: `const Particle = [position, velocity] as const`.
-- Use the public API only, as a consumer imports it, not internal modules. Read a world through observer systems.
+- Use the public API only, as a consumer imports it, not internal modules. Read a world through readonly systems.
 - Lines change as code does: the test of links fails on any that no longer covers whole code, so move them with it.

package/src/guide/guide.test.ts

@@ -69,12 +69,12 @@ const listed = [...read("README.md").matchAll(/^(?:- |(\d+)\. )\[([^\]]+)\]\(([^
 /** What each chapter teaches, which its prose names as code and its program does; 0 is the unnumbered keys chapter's. */
 const teaches: { readonly [chapter: number]: readonly string[] } = {
     0: ["Symbol()", "declare module \"@adobe/ecs\"", "Components", "Resources", "row[score]", "resources[bonus]", "default"],
-    1: ["Resources", "default", "World.create", "observer: true", "run", "ReadonlyMap", "Entity"],
+    1: ["Resources", "default", "World.create", "readonly: true", "run", "ReadonlyMap", "Entity"],
     2: ["Components", "type: true", "as const", "commands.spawn", "commands.remove", "with: [...Particle]"],
-    3: ["System.create", "with", "not", "observer: true", "optional: [velocity]"],
+    3: ["System.create", "with", "not", "readonly: true", "optional: [velocity]"],
     4: ["clock", "delta", "cadence", "always", "resources: { changed: [elapsed] }", "wake", "reduce[wake]", "world.add", "world.remove"],
     5: ["after", "during", "System.create([heal, hit])", "during: [update]"],
-    6: ["commands.spawn", "commands.add", "commands.despawn", "after: [spawn]"],
+    6: ["commands.spawn", "commands.add", "commands.despawn", "after: [spawn]", "readonly: true"],
     7: ["resources: { changed: [level] }", "changed: [score]", "resources: { is: [map], not: [paused] }", "resources[map]"],
     8: ["world.run(hit, { amount: 3 })", "target: \"entity\""],
     9: ["Rule.create", "derived: true"],
@@ -106,10 +106,12 @@ const mutations: { readonly [chapter: number]: readonly (readonly [string, strin
     ],
     1: [["World.create({ [gravity]: -1.6 })", "World.create()"], ["default: -9.8 ", ""], ["{ default: -Infinity }", "{}"]],
     2: [["commands.remove(row.entity, enemy);", ""], ["{ [position]: [0, 10, 0] }", "{}"]],
-    3: [["not: [frozen]", "not: []"], ["System.create([count, fail])", "System.create([fail])"]],
+    3: [
+        ["not: [frozen]", "not: []"], ["System.create([count, fail])", "System.create([fail])"],
+    ],
     4: [["world.remove(advance);", ""]],
     5: [["after: [hit] ", ""], ["during: [update] ", ""]],
-    6: [["commands.add(hero, health, 5);", ""], ["commands.despawn(commands.spawn([health])({ [health]: 1 }));", "commands.spawn([health])({ [health]: 1 });"], ["watched.add(watch);", ""]],
+    6: [["commands.add(hero, health, 5);", ""], ["commands.despawn(commands.spawn([health])({ [health]: 1 }));", "commands.spawn([health])({ [health]: 1 });"], ["watched.add(watch);", ""], ["const watch = System.create({ readonly: true, ", "const watch = System.create({ "]],
     7: [["resources: { changed: [level] } ", ""], [", changed: [score]", ""], [", not: [paused]", ""], ["is: [map], ", ""]],
     8: [["target: \"entity\",", ""]],
     9: [["with: [mesh], not: [hidden]", "with: [mesh]"], ["Rule.create({ components: { with: [sprite], not: [hidden] }, derive: [drawn] });", ""], ["Rule.create({ components: { with: [drawn] }, derive: [layer] });", ""]],

package/src/implementation/compiler/describe.test-helper.ts

@@ -51,7 +51,7 @@ export const spawn = System.create(({ commands }) => {
     commands.spawn([position, velocity])({ [position]: [0, 0, 0], [velocity]: [1, 0, 0] });
 });
 
-export const observe = System.create({ observer: true, components: { with: [position] } }, row => {
+export const observe = System.create({ readonly: true, components: { with: [position] } }, row => {
     console.log(row[position]);
 });
 

package/src/implementation/compiler/describe.test.ts

@@ -109,7 +109,7 @@ describe("a module's systems described", () => {
     it("says why systems that run as written have no code: per-run systems, observers, render systems, kernel: false and one declared in a function", () => {
         expect(described("spawn")).toMatchObject({ kind: "per-run", runs: `Its body as written, on the "world" thread` });
         for (const backend of ["js", "wasm", "wgsl"] as const) expect(reasonOf(described("spawn")[backend])).toBe("per-run systems run as written; only row systems compile");
-        expect(described("observe")).toMatchObject({ kind: "observer", js: { kind: "none", reason: expect.stringMatching(/^an observer runs as written/) } });
+        expect(described("observe")).toMatchObject({ kind: "readonly", js: { kind: "none", reason: expect.stringMatching(/^a readonly system runs as written/) } });
         expect(described("draw")).toMatchObject({ kind: "render", runs: expect.stringContaining("while the world has a GPU device"), wgsl: { kind: "none", reason: expect.stringMatching(/^a render system runs as written/) } });
         const unflagged = described("unflagged");
         expect(unflagged).toMatchObject({ kernel: false, js: { kind: "none", reason: "as written, because `kernel: false`" }, wasm: { kind: "none", reason: "as written, because `kernel: false`" }, wgsl: { kind: "eligible" } });

package/src/implementation/compiler/describe.ts

@@ -30,7 +30,7 @@ export type Backend =
  * What runs a system: over every matched row, once per run, as an observer, on one entity its input names (`target`),
  * or as a render system.
  */
-export type SystemKind = "row" | "per-run" | "observer" | "target" | "render";
+export type SystemKind = "row" | "per-run" | "readonly" | "target" | "render";
 
 /**
  * A system of a module as the build compiles it: its call's offsets in the code transformed, the binding it's
@@ -427,7 +427,7 @@ export const describeSystems = async (sites: TransformedSites, format: (code: st
         const kernel: boolean | "gpu" | null = literal === true || literal === false ? literal : literal === "gpu" ? "gpu" : null;
         const kind: SystemKind = created === "render" ? "render"
             : declaration === undefined ? "per-run"
-            : propertyOf(declaration, "observer") !== null ? "observer"
+            : propertyOf(declaration, "readonly") !== null ? "readonly"
             : propertyOf(declaration, "target") !== null ? "target"
             : propertyOf(declaration, "components") !== null ? "row" : "per-run";
         const base = { start: node.start, end: node.end, binding: bindings.get(node) ?? null, kind, kernel };
@@ -442,7 +442,7 @@ export const describeSystems = async (sites: TransformedSites, format: (code: st
             ? threadOf(declaration, body, kind === "render" ? positionsOf("render", declaration) : positionsOf("system", declaration)) : "world";
         if (kind === "render") return asWritten("a render system runs as written, recording GPU work with shaders of your own; `Gpu.wgsl` gives them their accessors", "world");
         if (kind === "per-run") return asWritten("per-run systems run as written; only row systems compile", written());
-        if (kind === "observer") return asWritten("an observer runs as written, reading the settled state after the run's last sync point; only row systems that aren't observers compile", written());
+        if (kind === "readonly") return asWritten("a readonly system runs as written, reading the settled state after the run's last sync point; only row systems that aren't readonly compile", written());
         if (kind === "target") return asWritten("a system with `target` runs as written, once, on the entity its input names; only systems over every matched row compile", written());
         if (declaration === undefined || body === undefined || body.type === "SpreadElement" || !isFunction(body)) {
             return asWritten(declaration === undefined ? "its declaration isn't written in its call, so the build can't read whether it's a kernel" : "its body isn't a function written in place or bound at module scope, so the build can't read it", "world");

package/src/implementation/compiler/hygiene.test.ts

@@ -34,7 +34,7 @@ const spawn = System.create(({ commands }) => {
 });
 
 const read: number[][] = [];
-const readAll = System.create({ observer: true, components: { with: [p, c, l, s, e, v0, v1] } }, row => {
+const readAll = System.create({ readonly: true, components: { with: [p, c, l, s, e, v0, v1] } }, row => {
     read.push([row[p], row[c], row[l], row[s], row[e], row[v0], row[v1]]);
 });
 

package/src/implementation/compiler/plugin.test.ts

@@ -645,7 +645,7 @@ export { World as OtherWorld };
 export const runOther = async (key) => {
     const spawn = System.create(({ commands }) => { commands.spawn([key].slice())({ [key]: 10 }); });
     let total = 0;
-    const count = System.create({ observer: true, components: { with: [key] } }, (row) => { total += row[key]; });
+    const count = System.create({ readonly: true, components: { with: [key] } }, (row) => { total += row[key]; });
     const world = World.create();
     await world.run(spawn);
     await world.run(spawn);
@@ -662,7 +662,7 @@ declare$(score, "component", { type: { type: "number" } });
 ${recorder}
 const spawn = System.create(({ commands }) => { commands.spawn([score].slice())({ [score]: 1 }); });
 let counted = 0;
-const count = System.create({ observer: true, components: { with: [score] } }, (row) => { counted += row[score]; });
+const count = System.create({ readonly: true, components: { with: [score] } }, (row) => { counted += row[score]; });
 export const copies = World === OtherWorld ? 1 : 2;
 export const run = async () => {
     const world = World.create();

package/src/implementation/compiler/signature.ts

@@ -120,7 +120,7 @@ export const kernelOf = (declaration: ObjectExpression): KernelRequest | null =>
         }
     }
     if (declaration.properties.some(property => property.type === "SpreadElement")) return null;
-    if (!declares(declaration, "components") || declares(declaration, "observer") || declares(declaration, "target")) return null;
+    if (!declares(declaration, "components") || declares(declaration, "readonly") || declares(declaration, "target")) return null;
     return { target: "cpu", required: false };
 };
 

package/src/implementation/compiler/transform.test.ts

@@ -335,7 +335,7 @@ describe("kernels by default", () => {
     test("runs as written, without failing, a body that leaves the subset or a declaration a kernel can't have", async () => {
         expect(await attached(`const log = []; const kernel = System.create({ components: { with: [mass] } }, row => { log.push(row[mass]); });`)).toBe(false);
         expect(await attached(`const kernel = System.create({ components: { with: [mass] } }, (row, { resources }) => { resources[delta] = row[mass]; });`)).toBe(false);
-        expect(await attached(`const kernel = System.create({ observer: true, components: { with: [mass] } }, row => { void row[mass]; });`)).toBe(false);
+        expect(await attached(`const kernel = System.create({ readonly: true, components: { with: [mass] } }, row => { void row[mass]; });`)).toBe(false);
         expect(await attached(`const kernel = System.create({ target: "entity", components: { with: [score] } }, row => { row[score] = 1; });`)).toBe(false);
         expect(await attached(`const make = () => System.create({ components: { with: [score] } }, row => { row[score] = 1; });`)).toBe(false);
     });
@@ -1418,11 +1418,11 @@ describe("inferred access", () => {
     });
 
     test("an observer's row it can't follow as unknown without a warning, since the world takes an observer's as read", async () => {
-        const result = await transform(system("observer: true, components: { with: [position] }", "(row) => { helper(row); }"));
+        const result = await transform(system("readonly: true, components: { with: [position] }", "(row) => { helper(row); }"));
         expect(result !== null && "code" in result ? [result.code.includes("components: null"), result.warnings] : null).toEqual([true, []]);
     });
 
-    test("a row it can't follow with a warning unless the declaration says observer: true, as the world reads it", async () => {
+    test("a row it can't follow with a warning unless the declaration says readonly: true, as the world reads it", async () => {
         for (const observer of ["observer: false, ", "observer: watching, "]) {
             const result = await transform(`const watching = true;\n${system(`${observer}components: { with: [position] }`, "(row) => { helper(row); }")}`);
             expect(result !== null && "code" in result ? result.warnings.length : null).toBe(1);

package/src/implementation/compiler/transform.ts

@@ -141,7 +141,7 @@ export const functionOf = (binding: ModuleBinding | undefined): Node | undefined
 const empty: ObjectExpression = { type: "ObjectExpression", properties: [], start: 0, end: 0 };
 
 /** Whether a declaration has property `name`, written out. */
-/** Whether a declaration gives `name` the literal `true`, as the world takes `observer`. */
+/** Whether a declaration gives `name` the literal `true`, as the world takes `readonly`. */
 const declaresTrue = (declaration: ObjectExpression, name: string): boolean => declaration.properties.some(property =>
     property.type === "Property" && !property.computed && property.key.type === "Identifier" && property.key.name === name
     && property.value.type === "Literal" && property.value.value === true);
@@ -313,9 +313,9 @@ export const transformKernels = async (
             const used = kernel?.used ?? inOrder(usedBy(declared, body, module.bindings, positions), declared);
             requireRequired(used, declared, body);
             const where = at(body);
-            // An observer's row, and a lookup's rows, it can't follow are taken as read whole, which is what their
+            // A readonly system's row, and a lookup's rows, it can't follow are taken as read whole, which is what their
             // declarations already say; only a row taken as written whole costs what the author should know of.
-            if (used.query === null && !declaresTrue(declared, "observer")) warnings.push(`${where}: the build can't follow how this body uses its row, so it takes every component in with, added and changed as written: index the row by key directly, or destructure it by key, to let it tell what the body reads and writes.`);
+            if (used.query === null && !declaresTrue(declared, "readonly")) warnings.push(`${where}: the build can't follow how this body uses its row, so it takes every component in with, added and changed as written: index the row by key directly, or destructure it by key, to let it tell what the body reads and writes.`);
             accessing = true;
             const access = accessText(used, where, whereReads.has(node) ? whereReads.get(node) ?? null : undefined);
             if (kernel !== undefined) {

package/src/implementation/world/change-blocks.test.ts

@@ -89,7 +89,7 @@ const setGroup = System.create({ target: "entity", components: { with: [group] }
 // Readers.
 let found: number[] = [];
 const onMain = System.create({ components: { with: [at], changed: [value] } }, row => { found.push(row[at]); });
-const observed = System.create({ observer: true, components: { with: [at], changed: [value] } }, row => { found.push(row[at]); });
+const observed = System.create({ readonly: true, components: { with: [at], changed: [value] } }, row => { found.push(row[at]); });
 const ofTwo = System.create({ components: { with: [at], changed: [group, value] } }, row => { found.push(row[at]); });
 const inKernel = System.create({ kernel: true, components: { with: [seen], changed: [value] } }, row => { row[seen] += 1; });
 const inUp = System.create({ components: { with: [at], changed: [value] }, up: { through: parent } }, row => { found.push(row[at]); });

package/src/implementation/world/commands.ts

@@ -1,8 +1,12 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Commands } from '../../interface/system/commands.js';
-import { addCommand, despawnCommand, pushCommand, pushComponent, removeCommand, type CommandBuffer } from './buffer.js';
+import { addCommand, createBuffer, despawnCommand, pushCommand, pushComponent, removeCommand, spawnCommand, type CommandBuffer } from './buffer.js';
+import { reserve } from './entities.js';
 import { listShapeOf, presetSpawnerOf, spawnerOf, type ListShape } from './lists.js';
 import { commandIdOf, idOf, storedShared, type Key, type State } from './state.js';
+import { spawnTables } from './tables.js';
+import { declarationOf, isWorldWritten, kindOf, labelOf, threadOfDeclaration, whyUnregistered } from '../../interface/registry/index.js';
+import { matchesSchema } from '../../interface/registry/schemas.js';
 
 const collect = (state: State, buffer: CommandBuffer, key: Key, value: unknown): void => {
     if (value !== undefined) pushComponent(buffer, idOf(state, key), value);
@@ -44,6 +48,38 @@ const addShared = (state: State, buffer: CommandBuffer, entity: number, shape: L
     for (let k = 0; k < keys.length; k++) pushComponent(buffer, ids[k], values[k]);
 };
 
+/**
+ * Throws for a key of `resources` that isn't a resource, is one only the world writes or one living on another thread,
+ * or is given a value its schema doesn't take.
+ */
+const checkResources = (resources: object): void => {
+    for (const key of Object.getOwnPropertySymbols(resources)) {
+        const fail = (message: string): never => { throw new Error(`commands.spawnTables: "${labelOf(key)}" ${message}.`); };
+        if (kindOf(key) !== "resource") fail(`isn't a registered resource: ${whyUnregistered(key)}`);
+        if (isWorldWritten(key)) fail("is written only by the world");
+        const declaration = declarationOf(key);
+        if (declaration === undefined) continue;
+        const thread = threadOfDeclaration(declaration);
+        if (thread !== null && thread !== "world") fail(`lives on thread "${thread}", not the world's`);
+        if (declaration.type !== undefined && !matchesSchema(declaration.type, Reflect.get(resources, key))) fail("is given a value its type doesn't take");
+    }
+};
+
+/**
+ * Queues `resources`' values for the sync point as the world's own change to its resource entity, which it reserves
+ * when the world has none yet: a buffer of their own, since the sync point skips systems' commands to that entity.
+ */
+const queueResources = (state: State, resources: object): void => {
+    if (Object.getOwnPropertySymbols(resources).length === 0) return;
+    const buffer = createBuffer();
+    if (state.resourceEntity < 0) {
+        state.resourceEntity = reserve(state.entities);
+        pushValues(state, buffer, spawnCommand, state.resourceEntity, resources);
+    }
+    else pushValues(state, buffer, addCommand, state.resourceEntity, resources);
+    state.queued.push({ buffer, guarded: false });
+};
+
 /** Values of a list add given none, which only an untyped caller does. */
 const empty = {};
 
@@ -83,6 +119,13 @@ export const createCommands = (state: State, target: { readonly buffer: CommandB
             pushComponent(buffer, ids[k], value === undefined ? starts[k] : value);
         }
     },
+    spawnTables: (tables, resources) => {
+        if (resources === undefined) return spawnTables(state, tables);
+        checkResources(resources);
+        const spawned = spawnTables(state, tables);
+        queueResources(state, resources);
+        return spawned;
+    },
     remove: (entity: number, components: symbol | readonly symbol[]) => {
         const { buffer } = target;
         if (typeof components === "symbol") {

package/src/implementation/world/create.ts

@@ -46,7 +46,7 @@ import { createState, defaultOf, idOf, reside, startTicking, type Key } from './
 import { indexOf } from './entities.js';
 import { touchedHeld } from './up.js';
 import { isHeld } from './transfers.js';
-import type { ReadonlyValue as ReadonlyResourceValue } from '../../interface/resource/value.js';
+import type { ReadonlyType as ReadonlyResourceType } from '../../interface/resource/value.js';
 import { labelOf, whyUnregistered } from '../../interface/registry/index.js';
 
 type Queue = <T>(task: () => T | Promise<T>) => Promise<T>;
@@ -425,12 +425,12 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     const deviceId = idOf(state, gpuDevice);
     const deviceDefault = defaultOf(gpuDevice);
     /** The `gpuDevice` resource's value, read each run, so without allocating. */
-    const readDevice = (): ReadonlyResourceValue<typeof gpuDevice> => {
+    const readDevice = (): ReadonlyResourceType<typeof gpuDevice> => {
         const index = state.resourceEntity < 0 ? -1 : indexOf(state.resourceEntity);
         const storage = index < 0 ? undefined : state.archetypes[state.entities.archetype[index]]?.storageById[deviceId];
         const value = storage !== undefined ? readCell(storage, state.entities.row[index]) : state.initial.has(gpuDevice) ? state.initial.get(gpuDevice) : deviceDefault;
         // The resource's value matches its registered schema, `GPUDevice | null`.
-        return value as ReadonlyResourceValue<typeof gpuDevice>;
+        return value as ReadonlyResourceType<typeof gpuDevice>;
     };
 
     /**

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

@@ -56,7 +56,7 @@ describe("a derived component declared without a default", () => {
             commands.spawn([tagged])({});
         });
         const seen: unknown[] = [];
-        const read = System.create({ observer: true, components: { with: [index] } }, row => { seen.push(row[index]); });
+        const read = System.create({ readonly: true, components: { with: [index] } }, row => { seen.push(row[index]); });
         await using first = createWorld();
         await using second = createWorld();
         for (const world of [first, second]) {

package/src/implementation/world/entities.ts

@@ -70,6 +70,12 @@ export const createEntities = (memory: Memory): Entities => {
 /** Reserves an entity. Safe to call from any thread between sync points. */
 export const reserve = ({ cursor, free, generation }: Reservations): Entity => entityAt(cursor, free, generation, Atomics.add(cursor, taken, 1));
 
+/** Reserves an entity for each of `into`'s elements, with one atomic add. Safe to call from any thread between sync points. */
+export const reserveRun = ({ cursor, free, generation }: Reservations, into: Float64Array): void => {
+    const first = Atomics.add(cursor, taken, into.length);
+    for (let i = 0; i < into.length; i++) into[i] = entityAt(cursor, free, generation, first + i);
+};
+
 /**
  * Reservations a thread takes in blocks of positions, so threads spawning together don't contend for the cursor.
  * Positions a block leaves unused are reserved entities that never spawn, which the sync point releases.

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

@@ -137,7 +137,7 @@ describe("finalizers", () => {
         const reads = System.create({}, ({ resources }) => { void resources[level]; });
         // Read after every run, as a read through a run of its own would apply the commands left for it.
         let seen: string | null = null;
-        const watch = System.create({ observer: true, lookup: { labels: { with: [label] } } }, ({ lookup }) => {
+        const watch = System.create({ readonly: true, lookup: { labels: { with: [label] } } }, ({ lookup }) => {
             seen = lookup.labels(other)?.[label] ?? null;
         });
         const world = createWorld({ [workers]: 0 });

package/src/implementation/world/finalizers.ts

@@ -12,7 +12,7 @@ import { asEntity, indexOf, locate } from './entities.js';
 import { createContext, rowBinder, type Context } from './rows.js';
 import { idOf, type Key, type State } from './state.js';
 import type { Queued } from './synchronize.js';
-import type { Essential, ReadonlyValue } from '../../interface/component/value.js';
+import type { Essential, ReadonlyType } from '../../interface/component/value.js';
 import type { Leaf } from '../../interface/finalizer/created.js';
 import { newestKeyOf, threadOf } from '../../interface/registry/index.js';
 import type { Layout } from '../../interface/registry/layout.js';
@@ -369,8 +369,8 @@ const changesOf = (state: State, runner: FinalizerRunner, queued: readonly Queue
     return {
         groups: [...groups.values()],
         // Stored and commanded values match each component's registered schema, so they have its type.
-        previous: <K extends Essential>(entity: Entity, key: K) => (bornHere(entity) ? null : live(entity, idOf(state, key))) as ReadonlyValue<K> | null,
-        next: <K extends Essential>(entity: Entity, key: K) => next(entity, idOf(state, key)) as ReadonlyValue<K> | null,
+        previous: <K extends Essential>(entity: Entity, key: K) => (bornHere(entity) ? null : live(entity, idOf(state, key))) as ReadonlyType<K> | null,
+        next: <K extends Essential>(entity: Entity, key: K) => next(entity, idOf(state, key)) as ReadonlyType<K> | null,
     };
 };
 

package/src/implementation/world/index-changed.test.ts

@@ -109,7 +109,7 @@ describe("an index lookup's changed: true", () => {
         await using world = inline();
         spawned = [];
         const orders: string[] = [];
-        const ordering = System.create({ observer: true, lookup: { inOrder: { index: inOrder, changed: true } } }, ({ lookup }) => {
+        const ordering = System.create({ readonly: true, lookup: { inOrder: { index: inOrder, changed: true } } }, ({ lookup }) => {
             const all = lookup.inOrder();
             const groups: number[] = [];
             for (let i = 0; i < all.length; i++) groups.push(all.at(i).entity === spawned[0] ? -1 : 0);
@@ -205,7 +205,7 @@ describe("an index lookup's changed: true", () => {
         await using world = inline();
         spawned = [];
         const totals: number[] = [];
-        const readTotals = System.create({ observer: true, components: { with: [total] } }, row => {
+        const readTotals = System.create({ readonly: true, components: { with: [total] } }, row => {
             totals.push(row[total]);
         });
         const totalsOf = async (): Promise<number[]> => {

package/src/implementation/world/index-joined.test.ts

@@ -87,7 +87,7 @@ const stirBands = System.create({ components: { with: [serial, band] } }, (row,
 /** An observer system of the joined thread's labels: the serials of each reader's band, in entity order, by reader. */
 let observedBands: string[] = [];
 const observeBands = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [target, bandReader, label] },
     lookup: { inBand: { index: bands } },
 }, (row, { lookup }) => {
@@ -219,14 +219,14 @@ const inOrder = System.create({ components: { with: [rank, label] }, order: rank
 const countWhenMoved = System.create({ components: { with: [cell, label] }, lookup: { near: { index: grid, changed: true } } }, (row, { lookup }) => {
     row[label] = { text: String(lookup.near(row[cell]).length) };
 });
-const readWhenMoved = System.create({ observer: true, components: { with: [label] }, lookup: { near: { index: grid, changed: true } } }, row => {
+const readWhenMoved = System.create({ readonly: true, components: { with: [label] }, lookup: { near: { index: grid, changed: true } } }, row => {
     void row[label];
 });
-const ownWhenMoved = System.create({ observer: true, lookup: { near: { index: grid, changed: true } } }, () => {});
+const ownWhenMoved = System.create({ readonly: true, lookup: { near: { index: grid, changed: true } } }, () => {});
 
 /** The entities `readLabels` reads, and their labels. */
 const reading: { entities: readonly Entity[]; labels: readonly string[] } = { entities: [], labels: [] };
-const readLabels = System.create({ observer: true, lookup: { labeled: { with: [label] } } }, ({ lookup }) => {
+const readLabels = System.create({ readonly: true, lookup: { labeled: { with: [label] } } }, ({ lookup }) => {
     reading.labels = reading.entities.map(entity => lookup.labeled(entity)?.[label].text ?? "missing");
 });
 
@@ -279,7 +279,7 @@ const heldSerials = Index.create({ key: [serial], unique: true, components: { wi
 let observedHeld = "";
 /** An observer system reading every held row through the keyless index, and serial 3's through the unique one. */
 const observeHeld = System.create({
-    observer: true,
+    readonly: true,
     lookup: { all: { index: held }, bySerial: { index: heldSerials } },
 }, ({ lookup }) => {
     const all = lookup.all();

package/src/implementation/world/index-order.test.ts

@@ -72,7 +72,7 @@ const expected = async (world: CreatedWorld, only?: (weighed: number) => boolean
 };
 
 const markerValues: number[] = [];
-const readMarkers = System.create({ observer: true, components: { with: [marker] } }, row => { markerValues.push(row[marker]); });
+const readMarkers = System.create({ readonly: true, components: { with: [marker] } }, row => { markerValues.push(row[marker]); });
 
 /** Markers' values in the order they were spawned: their archetype's rows', in storage order. */
 const markers = async (world: CreatedWorld): Promise<number[]> => {