@adobe/ecs 0.2.0 → 0.2.3

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

@@ -57,16 +57,16 @@ const idle = System.create({}, () => {});
 const totalPlus = System.create({}, ({ resources }, input: { readonly plus: number }) => resources[total] + input.plus);
 const described = System.create(({ resources }) => ({ total: resources[total], names: resources[names] }));
 const unpostable = System.create(() => () => "a function");
-const readTotal = System.create({ observer: true }, ({ resources }) => resources[total]);
+const readTotal = System.create({ readonly: true }, ({ resources }) => resources[total]);
 /** Writes levels, an object of joinTestAudio, so it runs on the thread claiming it. */
 const mix = System.create({}, ({ resources }, input: { readonly level: number }) => {
     resources[levels] = [...resources[levels], input.level];
 });
 /** An observer system recording each total it reads into `into`. */
-const totalsInto = (into: number[]) => System.create({ observer: true }, ({ resources }) => { into.push(resources[total]); });
+const totalsInto = (into: number[]) => System.create({ readonly: true }, ({ resources }) => { into.push(resources[total]); });
 /** An observer system recording how many levels it reads into `into`. */
-const levelsInto = (into: number[]) => System.create({ observer: true }, ({ resources }) => { into.push(resources[levels].length); });
-const failingRead = System.create({ observer: true }, () => { throw new Error("joinTest read failure"); });
+const levelsInto = (into: number[]) => System.create({ readonly: true }, ({ resources }) => { into.push(resources[levels].length); });
+const failingRead = System.create({ readonly: true }, () => { throw new Error("joinTest read failure"); });
 
 /** A world shared with a thread joined through a channel, and the joined world, once both say it joined. */
 const joined = async (threads: readonly ("main")[] = []): Promise<{ readonly world: CreatedWorld; readonly remote: World; readonly channel: MessageChannel }> => {

package/src/implementation/world/join.ts

@@ -33,6 +33,12 @@ const observerLeavesOf = (definition: Definition): readonly Leaf[] | null => {
     return schedule.tiers.length === 0 && schedule.observer.length > 0 ? schedule.observer : null;
 };
 
+/** Throws for a readonly system reading tables, which only the world's thread gives. */
+const refuseTables = (leaves: readonly Leaf[]): void => {
+    const reading = leaves.find(leaf => leaf.declaration.tables !== undefined);
+    if (reading !== undefined) throw new Error(`System "${reading.name}" reads tables, which only the world's thread gives: run or add it there.`);
+};
+
 /** A run not yet settled: how to settle it, and its rejection once posted. */
 type Run = { readonly resolve: (value: unknown) => void; readonly reject: (error: unknown) => void; message: ToJoined | null; error: unknown; readonly local: Local | null };
 
@@ -659,6 +665,7 @@ export const joinWorld = (port: Parameters<World["share"]>[0], options: { readon
             // This thread's own observer systems run here, after the sync point of an empty run of the world's.
             const leaves = observerLeavesOf(definition);
             if (leaves !== null) {
+                refuseTables(leaves);
                 if (failure !== null) return Promise.reject(failure);
                 const locals = leaves.map(localOf);
                 if (locals.length === 1 && definition.kind !== "composite") return runNumbered(locals[0].number, locals[0].leaf, undefined, locals[0]);
@@ -680,7 +687,8 @@ export const joinWorld = (port: Parameters<World["share"]>[0], options: { readon
         add: system => {
             const definition = requireDefinition(system);
             const leaves = observerLeavesOf(definition);
-            if (leaves === null) throw new Error("A joined thread adds only observer systems; others are added to ticks on the world's thread.");
+            if (leaves === null) throw new Error(`System "${definition.name}" isn't readonly, and a joined thread adds only readonly systems: declare it readonly: true to read the world from this thread, or add it on the world's thread.`);
+            refuseTables(leaves);
             if (added.has(definition) || failure !== null) return;
             const locals = leaves.map(localOf);
             added.set(definition, locals);
@@ -692,7 +700,7 @@ export const joinWorld = (port: Parameters<World["share"]>[0], options: { readon
         },
         remove: system => {
             const definition = requireDefinition(system);
-            if (observerLeavesOf(definition) === null) throw new Error("A joined thread removes only observer systems; others are removed from ticks on the world's thread.");
+            if (observerLeavesOf(definition) === null) throw new Error(`System "${definition.name}" isn't readonly, and a joined thread removes only readonly systems: others are removed on the world's thread.`);
             const locals = added.get(definition);
             if (locals === undefined) return;
             added.delete(definition);

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

@@ -22,7 +22,7 @@ declare module "@adobe/ecs" {
 
 /** What the observer system read, were it run: this test stands for the thread, so it never runs. */
 const seen: number[] = [];
-const watch = System.create({ observer: true, components: { with: [amount] } }, row => { seen.push(row[amount]); });
+const watch = System.create({ readonly: true, components: { with: [amount] } }, row => { seen.push(row[amount]); });
 
 describe("an observer system on a joined thread", () => {
     it("is waited for, not cancelled, by a sync point after a writer copied the rest of a post the thread claimed partway", async () => {

package/src/implementation/world/joining-worker.fixture.ts

@@ -42,7 +42,7 @@ const channel = scopeChannel<FromJoiningWorker, ToJoiningWorker>();
 let hosted: ReturnType<typeof createWorld> | null = null;
 /** What the observer system `listen` adds heard. */
 const heard: number[] = [];
-const hear = System.create({ observer: true }, ({ resources }) => { heard.push(resources[total]); });
+const hear = System.create({ readonly: true }, ({ resources }) => { heard.push(resources[total]); });
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 /** Ends this thread at once: node's worker exits, and a browser worker closes, dropping the tasks it queued. */
 const exit = (): void => {

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

@@ -16,7 +16,7 @@ import { add, drive, idle, names, shelf, total, until } from "./joining.test-hel
 /** A system only this thread imports, which a world on a worker never did. */
 const unimportedByWorker = System.create({}, () => {});
 /** An observer system only this thread imports, reading an object of `main`, so it's placed on a thread claiming it. */
-const shelvedHere = System.create({ observer: true }, ({ resources }) => resources[shelf].length);
+const shelvedHere = System.create({ readonly: true }, ({ resources }) => resources[shelf].length);
 
 type Worker = {
     readonly ask: (message: ToJoiningWorker, transfer?: readonly unknown[]) => Promise<FromJoiningWorker>;

package/src/implementation/world/joining.test-helper.ts

@@ -36,7 +36,7 @@ export const append = System.create({}, ({ resources }, input: { readonly name:
     return resources[names].length;
 });
 /** Reads `total` from an observer system, which a joined thread runs itself. */
-export const readTotal = System.create({ observer: true }, ({ resources }) => resources[total]);
+export const readTotal = System.create({ readonly: true }, ({ resources }) => resources[total]);
 export const spawn = System.create({}, ({ commands }, input: { readonly x: number }) => {
     commands.spawn([point, label, marked])({ [point]: [input.x, -input.x], [label]: `p${input.x}` });
 });

package/src/implementation/world/kernel-spawns.test.ts

@@ -63,7 +63,7 @@ const countAdded = System.create({ components: { added: [value], with: [made] }
 
 /** Each made entity's value, in storage order. */
 const madeValues: number[] = [];
-const readMade = System.create({ observer: true, components: { with: [value, made] } }, row => { madeValues.push(row[value]); });
+const readMade = System.create({ readonly: true, components: { with: [value, made] } }, row => { madeValues.push(row[value]); });
 const valuesOf = async (world: ReturnType<typeof createWorld>): Promise<number[]> => {
     madeValues.length = 0;
     await world.run(readMade);

package/src/implementation/world/observe-factories.test.ts

@@ -37,7 +37,7 @@ const nothing = System.create({}, () => {});
 
 /** Counts passes: the observer passes after each run's sync point. */
 const passes = { count: 0 };
-const counter = System.create({ observer: true }, () => { passes.count++; });
+const counter = System.create({ readonly: true }, () => { passes.count++; });
 
 /**
  * A world of `count` entities, each amount its index and one more, at level 1: the runs below registered, so runners
@@ -184,7 +184,7 @@ describe("observer factories", () => {
     it("rethrow only their own systems' failures from their runs, not those of observer systems the world added", async () => {
         using reported = catchOutOfBand();
         await using world = await seeded(3);
-        const failing = System.create({ observer: true }, () => { throw new Error("added failed"); });
+        const failing = System.create({ readonly: true }, () => { throw new Error("added failed"); });
         world.add(failing);
         const caught: unknown[] = [];
         const original = globalThis.queueMicrotask;

package/src/implementation/world/observe-ticks-cases.test.ts

@@ -29,7 +29,7 @@ const count = System.create({}, ({ resources }) => { resources[frames] += 1; });
 const watch = System.create({}, ({ resources }) => { resources[seen] = resources[clock].tick; });
 const fail = System.create({}, () => { throw new Error("tick failed"); });
 const nothing = System.create({}, () => {});
-const idle = System.create({ observer: true }, () => {});
+const idle = System.create({ readonly: true }, () => {});
 const fast = System.create({}, ({ resources }) => {
     resources[cadence] = { kind: "fixed", step: 1 };
     resources[always] = true;

package/src/implementation/world/observe.test-helper.ts

@@ -2,7 +2,7 @@
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
 
-const settled = System.create({ observer: true }, () => {});
+const settled = System.create({ readonly: true }, () => {});
 
 /**
  * Resolves once every observer factory subscribed before it had its first value: after the factories' flush, which the

package/src/implementation/world/observer-contained-worker.fixture.ts

@@ -24,7 +24,7 @@ export type FromContainedWorker =
 
 const channel = scopeChannel<FromContainedWorker, ToContainedWorker>();
 let remote: World | null = null;
-const placed = System.create({ observer: true }, () => {});
+const placed = System.create({ readonly: true }, () => {});
 
 channel.onMessage(async message => {
     if ("protocol" in message) return;

package/src/implementation/world/observer-contained.test-helper.ts

@@ -32,7 +32,7 @@ export const setHolding = System.create({}, ({ resources }, input: { readonly ho
 });
 
 /** After each sync point that changed the tally: notes it, and, while `holding` says so, waits there to be released. */
-export const watchTally = System.create({ observer: true, resources: { changed: [tally] } }, ({ resources }) => {
+export const watchTally = System.create({ readonly: true, resources: { changed: [tally] } }, ({ resources }) => {
     const value = resources[tally];
     tallies.push(value);
     const { words } = gate;

package/src/implementation/world/observer-contained.test.ts

@@ -29,10 +29,10 @@ const pause = System.create({}, ({ resources }, input: { readonly paused: boolea
 });
 
 const seen: { wide: number[][]; steps: number[] } = { wide: [], steps: [] };
-const watchWide = System.create({ observer: true, resources: { changed: [wide] } }, ({ resources }) => {
+const watchWide = System.create({ readonly: true, resources: { changed: [wide] } }, ({ resources }) => {
     seen.wide.push([...resources[wide]]);
 });
-const watchSteps = System.create({ observer: true, resources: { not: [paused], changed: [steps] } }, ({ resources }) => {
+const watchSteps = System.create({ readonly: true, resources: { not: [paused], changed: [steps] } }, ({ resources }) => {
     seen.steps.push(resources[steps]);
 });
 

package/src/implementation/world/observer-joined.test-helper.ts

@@ -103,7 +103,7 @@ export type Seen = { counter: number; rows: number; wrong: number };
 export const seen: Seen[] = [];
 
 /** Reads every row, which must all be of one tick, pausing at the end of its first chunk while `stall` says so. */
-export const watchRows = System.create({ observer: true, components: { with: [stamp, spot, word] } }, (row, { resources }) => {
+export const watchRows = System.create({ readonly: true, components: { with: [stamp, spot, word] } }, (row, { resources }) => {
     const value = resources[counter];
     let last = seen.at(-1);
     if (last === undefined || last.counter !== value || last.rows === 1000) seen.push(last = { counter: value, rows: 0, wrong: 0 });
@@ -117,7 +117,7 @@ export const watchRows = System.create({ observer: true, components: { with: [st
 export const looked: Entity[] = [];
 
 /** Looks up every row by entity, which must all be of one tick, spinning halfway while `stall` says so. */
-export const lookRows = System.create({ observer: true, lookup: { found: { with: [stamp, spot] } } }, ({ resources, lookup }) => {
+export const lookRows = System.create({ readonly: true, lookup: { found: { with: [stamp, spot] } } }, ({ resources, lookup }) => {
     const value = resources[counter];
     const run: Seen = { counter: value, rows: 0, wrong: 0 };
     seen.push(run);
@@ -146,7 +146,7 @@ export const nextPhase = System.create({}, ({ resources }) => {
 export const hot: number[] = [];
 export const byHeat = Index.create({ key: [heat], sorted: true });
 /** Counts the rows at least 150 hot, through the sorted index on what the GPU kernel writes. */
-export const countHot = System.create({ observer: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
+export const countHot = System.create({ readonly: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
     hot.push(lookup.hot({ ">=": 150 }).length);
 });
 
@@ -164,7 +164,7 @@ export const mottos: { readonly round: number; readonly motto: string }[] = [];
  * Reads only resources, a string among them: waits on the gate first, while `stall` says so, its round plus one, then
  * reads the motto, which must be its round's.
  */
-export const watchMotto = System.create({ observer: true }, ({ resources }) => {
+export const watchMotto = System.create({ readonly: true }, ({ resources }) => {
     const round = resources[mottoRound];
     pauseAt(resources[stall], round + 1);
     mottos.push({ round, motto: resources[motto] });

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

@@ -59,43 +59,43 @@ const reset = (): void => {
 /** The entities the tests look up, by the joined thread's systems. */
 const watched: Entity[] = [];
 
-const watchLevel = System.create({ observer: true, resources: { changed: [level] } }, ({ resources }) => {
+const watchLevel = System.create({ readonly: true, resources: { changed: [level] } }, ({ resources }) => {
     seen.calls++;
     seen.levels.push(resources[level]);
 });
-const watchAmounts = System.create({ observer: true, components: { with: [amount], changed: [amount] } }, row => {
+const watchAmounts = System.create({ readonly: true, components: { with: [amount], changed: [amount] } }, row => {
     (seen.amounts[seen.amounts.length - 1] ??= []).push(row[amount]);
 });
-const startAmounts = System.create({ observer: true }, () => { seen.amounts.push([]); });
+const startAmounts = System.create({ readonly: true }, () => { seen.amounts.push([]); });
 const amountsPass = System.create([startAmounts, watchAmounts]);
-const lookChanged = System.create({ observer: true, lookup: { found: { with: [amount], changed: [amount] } } }, ({ lookup }) => {
+const lookChanged = System.create({ readonly: true, lookup: { found: { with: [amount], changed: [amount] } } }, ({ lookup }) => {
     seen.looked.push(watched.flatMap(entity => {
         const row = lookup.found(entity);
         return row === null ? [] : [row[amount], row.changed];
     }));
 });
-const countTagged = System.create({ observer: true, lookup: { all: { index: allTagged } } }, ({ lookup }) => {
+const countTagged = System.create({ readonly: true, lookup: { all: { index: allTagged } } }, ({ lookup }) => {
     seen.tagged.push(lookup.all().length);
 });
-const inCell = System.create({ observer: true, lookup: { found: { index: byCell } } }, ({ lookup }) => {
+const inCell = System.create({ readonly: true, lookup: { found: { index: byCell } } }, ({ lookup }) => {
     const found = lookup.found(11);
     seen.tagged.push(found.length === 0 ? 0 : found.length * 100 + (found.at(0)?.[amount] ?? -1));
 });
-const failing = System.create({ observer: true }, ({ resources }) => {
+const failing = System.create({ readonly: true }, ({ resources }) => {
     if (resources[level] > 1) throw new Error("observer joined failure");
 });
-const readLabels = System.create({ observer: true, components: { with: [label, amount] } }, row => {
+const readLabels = System.create({ readonly: true, components: { with: [label, amount] } }, row => {
     seen.labels.push(`${row[label].text}${row[amount]}`);
 });
 
 /** On the joined thread, as it reads labels: each watched entity's label and amount, which the world's run resolves to. */
-const labelsThere = System.create({ observer: true, lookup: { labelled: { with: [label, amount] } } }, ({ lookup }) =>
+const labelsThere = System.create({ readonly: true, lookup: { labelled: { with: [label, amount] } } }, ({ lookup }) =>
     watched.map(entity => {
         const row = lookup.labelled(entity);
         return row === null ? "none" : `${row[label].text}${row[amount]}`;
     }));
 /** On the joined thread, as it reads labels: throws there. */
-const failsThere = System.create({ observer: true, lookup: { labelled: { with: [label] } } }, ({ lookup }) => {
+const failsThere = System.create({ readonly: true, lookup: { labelled: { with: [label] } } }, ({ lookup }) => {
     if (lookup.labelled(Entity.none) === null) throw new Error("observerJoinedTest failure there");
     return 0;
 });
@@ -218,7 +218,7 @@ describe("observer systems on a joined thread", () => {
             Index.create({ key: [cell], sorted: true, components: { with: [amount] } }),
         ];
         const [madeTagged, madeByCell] = made();
-        const sizes = System.create({ observer: true, lookup: { all: { index: madeTagged, changed: [cell] }, cells: { index: madeByCell } } }, ({ lookup }) => {
+        const sizes = System.create({ readonly: true, lookup: { all: { index: madeTagged, changed: [cell] }, cells: { index: madeByCell } } }, ({ lookup }) => {
             const all = lookup.all();
             seen.looked.push([all.changed]);
             const high = lookup.cells({ ">=": 5 });
@@ -284,10 +284,18 @@ describe("observer systems on a joined thread", () => {
         await close();
     });
 
-    it("refuse only systems that aren't observer", async () => {
+    it("refuse only systems that aren't readonly, saying to declare them so", async () => {
         const { remote, close } = await joined();
-        expect(() => remote.add(raise)).toThrow("A joined thread adds only observer systems");
-        expect(() => remote.remove(raise)).toThrow("A joined thread removes only observer systems");
+        expect(() => remote.add(raise)).toThrow(`System "raise" isn't readonly, and a joined thread adds only readonly systems: declare it readonly: true to read the world from this thread, or add it on the world's thread.`);
+        expect(() => remote.remove(raise)).toThrow(`System "raise" isn't readonly, and a joined thread removes only readonly systems: others are removed on the world's thread.`);
+        await close();
+    });
+
+    it("refuse a readonly system reading tables, which only the world's thread gives", async () => {
+        const { remote, close } = await joined();
+        const readTables = System.create({ readonly: true, tables: { components: [label] } }, ({ tables }) => tables.archetypes.length);
+        expect(() => remote.add(readTables)).toThrow(`System "readTables" reads tables, which only the world's thread gives: run or add it there.`);
+        await expect(remote.run(readTables)).rejects.toThrow(`System "readTables" reads tables, which only the world's thread gives: run or add it there.`);
         await close();
     });
 
@@ -309,7 +317,7 @@ describe("observer systems on a joined thread", () => {
         const { world, close } = await joined(["observerJoinedTest"]);
         await world.run(spawnLabelled);
         // Made in a function, so the build gives it no id.
-        const made = () => System.create({ observer: true, components: { with: [label, amount] } }, row => {
+        const made = () => System.create({ readonly: true, components: { with: [label, amount] } }, row => {
             seen.labels.push(`${row[label].text}${row[amount]}`);
         });
         const madeLabels = made();

package/src/implementation/world/observer.browser.test.ts

@@ -27,11 +27,11 @@ const warm = System.create({ kernel: "gpu", components: { with: [rate, heat] } }
 });
 
 let total = 0;
-const sum = System.create({ observer: true, components: { with: [heat] } }, row => { total += row[heat]; });
+const sum = System.create({ readonly: true, components: { with: [heat] } }, row => { total += row[heat]; });
 
 const byHeat = Index.create({ key: [heat], sorted: true });
 let hot = 0;
-const countHot = System.create({ observer: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
+const countHot = System.create({ readonly: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
     hot = lookup.hot({ ">=": 150 }).length;
 });
 

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

@@ -37,33 +37,33 @@ const grow = System.create({ components: { with: [amount] } }, row => { row[amou
 const nothing = System.create({}, () => {});
 
 // It keeps its context, which the build can't follow, so it's given what it reads.
-const watchLevel = System.create(giveAccess({ observer: true }, { resources: { read: [level] } }), context => {
+const watchLevel = System.create(giveAccess({ readonly: true }, { resources: { read: [level] } }), context => {
     seen.levels.push(context.resources[level]);
     seen.contexts.push(context);
 });
-const watchAmounts = System.create({ observer: true, components: { with: [amount], changed: [amount] } }, row => { seen.amounts.push(row[amount]); });
-const count = System.create({ observer: true, components: { with: [amount] } }, () => { seen.counted.push(1); });
-const inCell = System.create({ observer: true, lookup: { found: { index: byCell } } }, ({ lookup }) => {
+const watchAmounts = System.create({ readonly: true, components: { with: [amount], changed: [amount] } }, row => { seen.amounts.push(row[amount]); });
+const count = System.create({ readonly: true, components: { with: [amount] } }, () => { seen.counted.push(1); });
+const inCell = System.create({ readonly: true, lookup: { found: { index: byCell } } }, ({ lookup }) => {
     seen.cells.push(lookup.found(7).length);
 });
-const failing = System.create({ observer: true }, ({ resources }) => {
+const failing = System.create({ readonly: true }, ({ resources }) => {
     if (resources[level] > 0) throw new Error("observer failed");
 });
 const raiseThenWatch = System.create([raise, watchLevel]);
-const watchLevelChanges = System.create({ observer: true, resources: { changed: [level] } }, ({ resources }) => {
+const watchLevelChanges = System.create({ readonly: true, resources: { changed: [level] } }, ({ resources }) => {
     seen.levels.push(resources[level]);
 });
 
 /** The world a removing body acts on. */
 let current: World | null = null;
-const removeLevel = System.create({ observer: true }, () => {
+const removeLevel = System.create({ readonly: true }, () => {
     seen.removals.push(1);
     current?.remove(watchLevel);
 });
 
 /** Adds `watchLevel` to the world the test runs, during a run. */
 const addWatch = System.create({}, () => { current?.add(watchLevel); });
-const addLevel = System.create({ observer: true }, () => {
+const addLevel = System.create({ readonly: true }, () => {
     current?.add(watchLevel);
 });
 

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

@@ -30,7 +30,7 @@ const assign = System.create({ kernel: true, components: { with: [position], opt
     row[velocity] = row[position];
 });
 const totals = { moved: 0, still: 0 };
-const sum = System.create({ observer: true, components: { with: [position], optional: [velocity] } }, row => {
+const sum = System.create({ readonly: true, components: { with: [position], optional: [velocity] } }, row => {
     if (row[velocity] === undefined) totals.still += row[position];
     else totals.moved += row[position];
 });

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

@@ -73,7 +73,7 @@ const copySpeedKernel = System.create({
     if (found !== null) row[order] = found[velocity] === undefined ? -found[position] : found[velocity];
 });
 const speeds: number[] = [];
-const readSpeeds = System.create({ observer: true, components: { with: [other, order] } }, row => { speeds.push(row[order]); });
+const readSpeeds = System.create({ readonly: true, components: { with: [other, order] } }, row => { speeds.push(row[order]); });
 
 /** What finalizers read of rows that stopped, on the world's thread and on the markers'. */
 const stopped: string[] = [];
@@ -87,7 +87,7 @@ export const finalizeThere = Finalizer.create({ components: { with: [position, m
 const despawnAll = System.create({ components: { with: [position] } }, (row, { commands }) => { commands.despawn(row.entity); });
 
 let seen: (readonly [number, number | undefined, string | undefined])[] = [];
-const read = System.create({ observer: true, components: { with: [position], optional: [velocity, label] } }, row => {
+const read = System.create({ readonly: true, components: { with: [position], optional: [velocity, label] } }, row => {
     seen.push([row[position], row[velocity], row[label]]);
 });
 const sorted = () => [...seen].sort((a, b) => a[0] - b[0]);
@@ -109,7 +109,7 @@ const lookedThere = System.create({ components: { with: [position, marker] }, lo
 });
 // An observer system there reads copies of rows across archetypes, which tell which have the optional component.
 let watched: (readonly [number, number | undefined])[] = [];
-const watchThere = System.create({ observer: true, components: { with: [position], optional: [velocity] } }, row => {
+const watchThere = System.create({ readonly: true, components: { with: [position], optional: [velocity] } }, row => {
     watched.push([row[position], row[velocity]]);
 });
 // A tail there: it writes only its thread's objects, so it runs after the sync point, reading copies of rows.
@@ -165,7 +165,7 @@ const markEither = System.create({ kernel: true, components: { with: [mark], opt
     if (row[far] !== undefined) row[mark] = 2;
 });
 const marked: number[] = [];
-const watchStamped = System.create({ observer: true, components: { with: [mark], changed: [mark] } }, row => { marked.push(row[mark]); });
+const watchStamped = System.create({ readonly: true, components: { with: [mark], changed: [mark] } }, row => { marked.push(row[mark]); });
 const clearNear = System.create({ kernel: false, components: { with: [mark], optional: [near] } }, row => {
     if (row[near] !== undefined) row[near] = undefined;
 });
@@ -195,7 +195,7 @@ describe("optional components", () => {
 
     it("pass change filters on other components, and are stamped changed when written", async () => {
         const changed: number[] = [];
-        const watch = System.create({ observer: true, components: { with: [velocity], changed: [velocity] } }, row => { changed.push(row[velocity]); });
+        const watch = System.create({ readonly: true, components: { with: [velocity], changed: [velocity] } }, row => { changed.push(row[velocity]); });
         const speedUp = System.create({ components: { with: [position], optional: [velocity] } }, row => {
             const speed = row[velocity];
             if (speed !== undefined && row[position] > 50) row[velocity] = speed + 1;
@@ -212,7 +212,7 @@ describe("optional components", () => {
     it("run in an index's order across archetypes that have them and don't", async () => {
         const byOrder = Index.create({ key: [order], sorted: true });
         const ordered: (number | undefined)[] = [];
-        const list = System.create({ observer: true, components: { with: [position], optional: [velocity] }, order: byOrder }, row => {
+        const list = System.create({ readonly: true, components: { with: [position], optional: [velocity] }, order: byOrder }, row => {
             ordered.push(row[velocity]);
         });
         await using world = inline();
@@ -297,7 +297,7 @@ describe("optional components", () => {
         await world.run(spawnMarked);
         stoppedThere.length = 0;
         await world.run(despawnAll);
-        await remote.run(System.create({ observer: true }, () => {}));
+        await remote.run(System.create({ readonly: true }, () => {}));
         expect(stoppedThere.sort()).toEqual(["10:5:null", "1:none:null"]);
         await remote.dispose();
         await world.dispose();

package/src/implementation/world/pool-size.cases.ts

@@ -12,7 +12,9 @@ export const poolSizeCases = (load: () => Promise<typeof Fixture>) => describe("
     });
     it("honors a number, and null again gives the platform's choice", async () => {
         const fixture = await load();
-        expect((await fixture.resized(1, [null])).started).toEqual([1, 1 + fixture.platformCount()]);
+        // The platform's choice starts a pool of its own unless it's the size the pool already is.
+        const platform = fixture.platformCount();
+        expect((await fixture.resized(1, [null])).started).toEqual([1, platform === 1 ? 1 : 1 + platform]);
     });
     it("starts the pool only once a kernel has rows enough for workers", async () => {
         const fixture = await load();

package/src/implementation/world/reads.test-helper.ts

@@ -1,17 +1,17 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Component } from '../../interface/component/component.js';
-import type { ReadonlyValue } from '../../interface/component/value.js';
+import type { ReadonlyType } from '../../interface/component/value.js';
 import type { Entity } from '../../interface/entity/entity.js';
 import type { Resource } from '../../interface/resource/resource.js';
-import type { ReadonlyValue as ReadonlyResourceValue } from '../../interface/resource/value.js';
+import type { ReadonlyType as ReadonlyResourceType } from '../../interface/resource/value.js';
 import type { World } from '../../interface/world/world.js';
 import { Observe } from '../../observe/index.js';
 
 // Tests' reads: each is the first value of an observer factory of `src/observe`.
 
 /** One component of an entity, or `null` if it's dead or lacks it. */
-export const read = async <C extends Component.Key>(world: World, entity: Entity, component: C): Promise<ReadonlyValue<C> | null> => {
-    const values: { readonly [K in C]: ReadonlyValue<K> } | null = await Observe.toPromise(Observe.entity(world, entity, { required: [component] }));
+export const read = async <C extends Component.Key>(world: World, entity: Entity, component: C): Promise<ReadonlyType<C> | null> => {
+    const values: { readonly [K in C]: ReadonlyType<K> } | null = await Observe.toPromise(Observe.entity(world, entity, { required: [component] }));
     return values === null ? null : values[component];
 };
 
@@ -19,12 +19,12 @@ export const read = async <C extends Component.Key>(world: World, entity: Entity
 export const readEntity = <const C extends readonly Component.Key[]>(world: World, entity: Entity, components: C) =>
     Observe.toPromise(Observe.entity(world, entity, { required: components }));
 
-export const readResource = <R extends Resource.Key>(world: World, name: R): Promise<ReadonlyResourceValue<R>> => Observe.toPromise(Observe.resource(world, name));
+export const readResource = <R extends Resource.Key>(world: World, name: R): Promise<ReadonlyResourceType<R>> => Observe.toPromise(Observe.resource(world, name));
 
 export const select = <const R extends readonly Component.Key[] = []>(world: World, query: Observe.Query<R>): Promise<readonly Entity[]> => Observe.toPromise(Observe.select(world, query));
 
 export const count = <const R extends readonly Component.Key[] = []>(world: World, query: Omit<Observe.Query<R>, "order">): Promise<number> => Observe.toPromise(Observe.count(world, query));
 
 /** One component of each of these entities, `null` for one that's dead or lacks it. */
-export const readEach = <C extends Component.Key>(world: World, entities: readonly Entity[], component: C): Promise<(ReadonlyValue<C> | null)[]> =>
+export const readEach = <C extends Component.Key>(world: World, entities: readonly Entity[], component: C): Promise<(ReadonlyType<C> | null)[]> =>
     Promise.all(entities.map(entity => read(world, entity, component)));

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

@@ -42,7 +42,7 @@ const caught: number[] = [];
 export const catchUp = System.create({ kernel: false, components: { with: [position], changed: [position], where: { [cell]: (at, { resources }) => at[0] === resources[camera] } } }, row => { caught.push(row[position]); });
 // On a joined thread.
 const heard: number[] = [];
-export const hear = System.create({ observer: true, components: { with: [cell, position], where: { [cell]: at => at[0] === 50 } } }, row => { heard.push(row[cell][0] * 1000 + row[position]); });
+export const hear = System.create({ readonly: true, components: { with: [cell, position], where: { [cell]: at => at[0] === 50 } } }, row => { heard.push(row[cell][0] * 1000 + row[position]); });
 
 /** Moves an entity to cell `[x, 0]`. */
 const step = System.create({}, ({ commands }, input: { readonly entity: Entity; readonly x: number }) => { commands.add(input.entity, cell, [input.x, 0]); });
@@ -59,7 +59,7 @@ const spawnAt = (world: ReturnType<typeof inline>, x: number, components: readon
 /** Every row's cell and position, by position. */
 const cellsOf = async (world: ReturnType<typeof inline>): Promise<readonly string[]> => {
     const found: [number, string][] = [];
-    await world.run(System.create({ observer: true, components: { with: [cell, position] } }, row => { found.push([row[position], `${row[cell][0]}:${row[position]}`]); }));
+    await world.run(System.create({ readonly: true, components: { with: [cell, position] } }, row => { found.push([row[position], `${row[cell][0]}:${row[position]}`]); }));
     return found.sort((a, b) => a[0] - b[0]).map(([, text]) => text);
 };
 
@@ -132,7 +132,7 @@ describe("reclaiming archetypes of shared values", () => {
         found.length = 0;
         await world.run(System.create({ kernel: false, components: { with: [cell, position] } }, row => { found.push(`body ${row[cell][0]}`); }));
         await world.run(copyCell);
-        await world.run(System.create({ observer: true, components: { with: [cell, seen] } }, row => { found.push(`kernel ${row[seen]}`); }));
+        await world.run(System.create({ readonly: true, components: { with: [cell, seen] } }, row => { found.push(`kernel ${row[seen]}`); }));
         await world.run(atFifty);
         await world.run(atLast);
         expect(found.sort()).toEqual(["body 50", `body ${emptyFor + 2}`, "kernel 50", `kernel ${emptyFor + 2}`, "value 0", "where 100"].sort());

package/src/implementation/world/register.ts

@@ -132,7 +132,7 @@ const observerTargetOf = (state: State, leaf: Leaf): ObserverTarget | undefined
 
 /** A runner for a leaf where it runs now: on the joined thread filling its thread, or that added it, or here. */
 const placedRunner = (state: State, leaf: Leaf, since = 0): Runner => {
-    if (leaf.declaration.observer === true) {
+    if (leaf.declaration.readonly === true) {
         const target = observerTargetOf(state, leaf);
         return target === undefined ? createRunner(state, leaf, since) : createJoinedObserverRunner(state, leaf, target, since);
     }
@@ -394,7 +394,7 @@ export const createRegistrar = (state: State): Registrar => {
 
     const place = (): void => {
         eachRunner((leaf, old, entry) => {
-            if (leaf.declaration.observer === true) {
+            if (leaf.declaration.readonly === true) {
                 if (observerTargetOf(state, leaf) === old.joined?.target) return;
                 replace(leaf, entry, old, placedRunner(state, leaf, old.lastRun()));
                 return;

package/src/implementation/world/remote-objects.test-helper.ts

@@ -72,7 +72,7 @@ export type Observers = "factory" | "observer";
 const observer: { entity: Entity | null; seen: ((odd: boolean, held: boolean, text: string | null | undefined) => void) | null } = { entity: null, seen: null };
 
 /** After each sync point, on the joined thread: the watched entity's phase and caption, and whether it's flagged. */
-export const observerWatch = System.create({ observer: true, lookup: { values: { with: [phase, caption] }, flagged: { with: [flag] } } }, ({ lookup }) => {
+export const observerWatch = System.create({ readonly: true, lookup: { values: { with: [phase, caption] }, flagged: { with: [flag] } } }, ({ lookup }) => {
     if (observer.entity === null) return;
     const row = lookup.values(observer.entity);
     if (row === null) return;

package/src/implementation/world/rows.ts

@@ -12,6 +12,7 @@ import { ownTag } from './move-log.js';
 import { resourceCell } from './resources.js';
 import { labelOf } from '../../interface/registry/names.js';
 import { idOf, type Key, type State } from './state.js';
+import { readTables } from './tables-read.js';
 import { combine, contributed, identityOf, type ReductionTarget } from './reductions.js';
 import { createIndexLookup, type Since } from './index-lookups.js';
 import type { WorldIndex } from './indexes.js';
@@ -506,8 +507,11 @@ const never: Since = { value: -1 };
 const own = (): object => Object.create({});
 
 /** Resource cells are resolved once per run: they move only at sync points. An unresolved resource throws on access. */
-export const createContext = (state: State, declaration: Pick<Resolved, "lookup" | "resources">, { targets = [], commands, indexes, since = never }: Extras = {}): Context => {
+export const createContext = (state: State, declaration: Pick<Resolved, "lookup" | "resources" | "tables">, { targets = [], commands, indexes, since = never }: Extras = {}): Context => {
     const value: { up?: unknown } = own();
+    const { tables } = declaration;
+    // Each read copies the tables as they are then.
+    if (tables !== undefined) Object.defineProperty(value, "tables", { get: () => readTables(state, tables), enumerable: true });
     const { lookup, resources } = declaration;
     const names = Object.keys(lookup ?? {});
     if (names.length > 0) {