@adobe/ecs 0.2.3 → 0.3.0

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

@@ -62,6 +62,11 @@ const readTotal = System.create({ readonly: true }, ({ resources }) => resources
 const mix = System.create({}, ({ resources }, input: { readonly level: number }) => {
     resources[levels] = [...resources[levels], input.level];
 });
+/** Runs on the thread claiming joinTestAudio, as `mix` does, and despawns by a query, which only the world's thread does. */
+const mixAndClear = System.create({}, ({ resources, commands }) => {
+    resources[levels] = [...resources[levels], 0];
+    commands.despawnWhere({ with: [marked] });
+});
 /** An observer system recording each total it reads into `into`. */
 const totalsInto = (into: number[]) => System.create({ readonly: true }, ({ resources }) => { into.push(resources[total]); });
 /** An observer system recording how many levels it reads into `into`. */
@@ -155,6 +160,12 @@ describe("joining", () => {
         await remote.dispose();
         await world.dispose();
     });
+    it("rejects a run asking for its changes, which only the world's thread records", async () => {
+        const { world, remote } = await joined();
+        await expect(remote.run(idle, { changes: true })).rejects.toThrow("a run's changes are recorded only on the world's thread");
+        await remote.dispose();
+        await world.dispose();
+    });
     it("rejects a run that failed, naming its system, and a run of a system without an id", async () => {
         const { world, remote } = await joined();
         await expect(remote.run(fail)).rejects.toThrow(/^System "fail" \(.*join\.test\.ts#fail\) failed: joinTest failure$/);
@@ -216,6 +227,14 @@ describe("the join signal", () => {
         await world.run(mix, { level: 1 });
         expect(await eventually(() => heard.includes(1))).toBe(true);
     });
+    it("fails a system on a joined thread that despawns by a query, which runs on the world's thread", async () => {
+        await using world = createWorld({ [workers]: 0 });
+        const channel = new MessageChannel();
+        const shared = world.share(channel.port1);
+        await using _remote = await join(channel.port2, { threads: ["joinTestAudio"] });
+        await shared;
+        await expect(world.run(mixAndClear)).rejects.toThrow("commands.despawnWhere runs on the world's thread");
+    });
     it("resolves several joins at once, each with its own claims, and each of their observer systems sees the world's next run", async () => {
         await using world = createWorld({ [workers]: 0 });
         const claims: readonly (readonly ("main" | "joinTestAudio")[])[] = [[], ["main"], ["joinTestAudio"]];

package/src/implementation/world/join.ts

@@ -1,9 +1,13 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { asksForChanges, takesInput } from './run-changes.js';
+import type { ChangeSet } from '../../interface/finalizer/body.js';
+import type { Essential } from '../../interface/component/value.js';
+import type { Resource } from '../../interface/resource/resource.js';
 import type { Thread } from '../../interface/thread/thread.js';
 import type { World } from '../../interface/world/world.js';
 import type { Input } from '../../interface/system/input.js';
 import type { System } from '../../interface/system/system.js';
-import { declarationOf, identifiedItems, idOfItem, idOfKey, indexOfLookup, keyOfId, labelOf, requireDefinition, threadOf, threadOfDeclaration, watchedBy, type Definition } from '../../interface/registry/index.js';
+import { declarationOf, definitionOf, identifiedItems, idOfItem, idOfKey, indexOfLookup, keyOfId, labelOf, requireDefinition, threadOf, threadOfDeclaration, watchedBy, type Definition } from '../../interface/registry/index.js';
 import { unsharedKeyOf } from './index-keys.js';
 import { layoutOf, type Views } from '../../interface/registry/layout.js';
 import {
@@ -681,9 +685,19 @@ export const joinWorld = (port: Parameters<World["share"]>[0], options: { readon
         return runNumbered(numberOf(id, true), definition, input, null);
     };
 
+    function run<I, R>(system: System<I, R>, ...input: Input<NoInfer<I>>): Promise<R>;
+    function run<I, R>(system: System<I, R>, ...input: [...Input<NoInfer<I>>, options: { readonly changes: true }]): Promise<ChangeSet<Essential, Resource.Key>>;
+    function run(system: System<unknown, unknown>, ...args: readonly unknown[]): Promise<unknown> {
+        const definition = definitionOf(system);
+        // A system taking input whose input is all it was given runs with it.
+        const asked = args.length > 0 && asksForChanges(args[args.length - 1]) && definition !== undefined && !(args.length < 2 && takesInput(definition));
+        if (asked) return Promise.reject(new Error(`System "${system.name}": a run's changes are recorded only on the world's thread.`));
+        return runOn(system, args);
+    }
+
     const world: World = {
         // A run gives what its system's body returned, `R` by the system's type.
-        run: <I, R>(system: System<I, R>, ...args: Input<NoInfer<I>>) => runOn(system, args) as Promise<R>,
+        run,
         add: system => {
             const definition = requireDefinition(system);
             const leaves = observerLeavesOf(definition);

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

@@ -73,7 +73,7 @@ export const freshKernel = (system: System): System => {
     const description = kernelOf(system);
     if (leaf === undefined || leaf.kind === "composite" || description === undefined) throw new Error("Not a kernel system.");
     // What `System.create` makes of the same declaration and body, without the id a top-level binding takes.
-    const copy: Leaf & System = { kind: leaf.kind, name: leaf.name, declaration: leaf.declaration, input: leaf.input, body: leaf.body };
+    const copy: Leaf & System = { kind: leaf.kind, name: leaf.name, declaration: leaf.declaration, input: leaf.input, body: leaf.body, commands: leaf.commands };
     claimSystem(copy, undefined);
     return attachKernel(copy, description);
 };

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

@@ -43,8 +43,7 @@ const failOnce = System.create(() => { throw new Error("unnamed"); });
 
 describe("systems, rules and finalizers of one label", () => {
     it("are distinct in schedules, both run, and are told apart in reports by their ids", async () => {
-        // Its body is written in place, calling what it's given with the row, which the build takes as writing every member.
-        const linked = (after: readonly System[], body: (row: { [value]: number }) => void): System => System.create({ components: { with: [value] }, after }, row => body(row));
+        const linked = (after: readonly System[], body: (row: { [value]: number }) => void): System => System.create({ components: { with: [value], whole: true }, after }, row => body(row));
         const a = linked([], row => { ran.push("a"); row[value] += 1; });
         const b = linked([a], row => { ran.push("b"); row[value] += 1; throw new Error("b failed"); });
         const c = linked([b], row => { ran.push(`c${row[value]}`); });

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

@@ -0,0 +1,61 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { System } from "../../interface/system/system.js";
+import { workers } from "../../interface/resources/workers.js";
+import { createWorld } from "./create.js";
+import { runRan, runReported } from "./outcomes.test-helper.js";
+
+const seed = Symbol("passesTest/seed");
+const event = Symbol("passesTest/event");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [seed]: { type: number };
+        [event]: { type: number };
+    }
+}
+
+/** What the systems below ran, in order. */
+const order: string[] = [];
+let firing = false;
+
+const plant = System.create(({ commands }) => { commands.spawn([seed])({ [seed]: 1 }); });
+const emit = System.create({ components: { with: [seed] } }, (row, { commands }) => {
+    order.push("emit");
+    if (firing) commands.spawn([event])({ [event]: row[seed] });
+});
+const handle = System.create({ components: { with: [event] }, after: [emit] }, row => { order.push(`handle ${row[event]}`); });
+const finish = System.create({ after: [handle] }, () => { order.push("finish"); });
+const chain = System.create([emit, handle, finish]);
+
+const fail = System.create({ components: { with: [seed] }, after: [emit] }, () => {
+    order.push("fail");
+    throw new Error("passesTest: fail");
+});
+const afterFail = System.create({ after: [fail] }, () => { order.push("after fail"); });
+const failing = System.create([emit, fail, afterFail]);
+
+describe("tiers on the world's thread", () => {
+    it("run one after another past sync points that apply nothing, and apply one with commands before the tier after it", async () => {
+        expect(System.describe(chain).tiers.map(tier => tier.sync === null)).toEqual([false, true, true]);
+        await using world = createWorld({ [workers]: 0 });
+        await world.run(plant);
+        order.length = 0;
+        firing = false;
+        expect((await runRan(world, chain)).systems).toBe(3);
+        firing = true;
+        expect((await runRan(world, chain)).systems).toBe(3);
+        expect(order).toEqual(["emit", "finish", "emit", "handle 1", "finish"]);
+    });
+
+    it("stop at a tier whose system fails, skipping those after it", async () => {
+        await using world = createWorld({ [workers]: 0 });
+        await world.run(plant);
+        order.length = 0;
+        firing = false;
+        const reported = await runReported(world, failing);
+        expect([reported.failures.map(failure => failure.message), reported.skipped]).toEqual([["passesTest: fail"], [afterFail.name]]);
+        expect(order).toEqual(["emit", "fail"]);
+        expect((await runRan(world, failing)).systems).toBe(2);
+    });
+});

package/src/implementation/world/perf.md

@@ -220,7 +220,7 @@ Shared components and `where`, against `12e366d`, node: the whole suite three ti
 - **A shared value read in a row costs what a column's does:** `shared read 100K` 4.04–4.10 ns a row against 4.24–4.27 for `column read 100K`, the value bound with the row once per archetype. In a kernel it's a parameter of each call: `shared read 100K kernel` 0.40–0.41 against 0.50 for `column read 100K kernel`, one column fewer to stream.
 - **Spawning with a shared constant:** `spawn bulk shared`, one spawner reused, 17.3–18.1 ns a spawn against 33.3–34.3 for `spawn bulk plain`, whose cell is a column; `spawn singles shared`, its spawner found by its constants each call, 313–323 ns against 229 for `spawn singles plain`: about 90 ns a call to find the spawner, a tuple's leaves walked through a tree of its stored leaves (`shared.ts`) and each constant in turn through the shape's tree of spawners, with no text built.
 - **`where` over 1K cells,** 3 × 3 of them in view: `where 1K cells still` 0.49 ns a cell, 0.5 µs a run with nothing evaluated; `where 1K cells moving`, every predicate evaluated again as the camera moves each run, 18.7–19.0 ns a cell, each predicate's resources read once per evaluation.
-- **Many small archetypes:** `small archetypes 1K`, 10K rows over 1K archetypes of one cell each, 7.26–7.43 ns a row against 3.46–3.49 for `one archetype 10K`: about 39 ns an archetype, binding its row and walking its filters, which a shared component's values multiply.
+- **Many small archetypes:** `small archetypes 1K`, 10K rows over 1K archetypes of one cell each, 6.8–7.0 ns a row against 3.04 for `one archetype 10K`: about 38 ns an archetype, binding its row, which a shared component's values multiply.
 
 Review fixes to shared components and `where`, node, alternating against the commit before each, medians of four to six rounds:
 - **Arrivals precise** (`arrivals.ts`): a system with `where` and change filters reads a ring of the moves since its last run, each archetype moved into owing the point of the one its rows came from, where every arrival made the archetype count from the oldest point of all matches, found by a scan of them. New `where changed 1K cells drifting in view`, every cell in view, 1% of 10K rows moving to the next cell before each run: 123.6 → 69.2 ns a cell; `where changed 1K cells drifting`, 3 × 3 cells in view, 2.0 → 2.8 ns a cell, the ring's 102 entries a run read, about 7 ns each, and cells moved into from culled ones scanned since that one's point; `changed 1K cells drifting`, without `where`, 52.3 → 52.0. `where 1K cells still` and `moving` within noise.
@@ -229,6 +229,15 @@ Review fixes to shared components and `where`, node, alternating against the com
 - **A spawner's guard** against a component given in both calls, one check of each constant's key a spawn: `spawn singles shared` 323 → 323 ns, `spawn bulk shared` 18.0 → 18.1 ns.
 - **Reclaiming** (`reclaim.ts`): an entity walking one cell a run made an archetype, an interned value, a batch and spawner levels per cell, for good: after 20K cells 20,002 archetypes, 185 MB of heap and 9.1 MB of arena, and `one row after 100K cells walked`, a system over one row, 2.76 ms a run against 250 ns before the walk. Reclaimed and reused, after 100K cells: 11 archetypes, 9 values, 9 batches, 18 spawner levels, heap 29.7–29.9 MB from 1K cells on, arena 71,616 B throughout; `one row after 100K cells walked` 250 ns; `walk to a new cell` 10.3 → 2.8 µs a run. Waiting out empty sync points (`emptyFor`), `circle 8 cells`, round 8 cells, each emptied 7 sync points: 2.67–2.69 µs a run at 1, 2 and 4, reclaiming and reusing one archetype a run, 1.00 at 8 and 16, reclaiming nothing; `walk to a new cell` 2.69–2.73 µs at 1 to 4, 2.81 at 8, 3.06 at 16, scanning more candidates; `flicker between 2 cells` 958 ns at all, against 916 before reclaiming, the sync point's scan of its emptied archetypes. 8, so a cell left for up to 7 sync points keeps its archetype. Edges cached to an archetype of shared values are kept on it to clear, but a batch's archetype is checked by its generation instead: an edge object per spawned archetype, allocated between archetypes and their storages, made `where 1K cells moving` 10% slower, its 1K predicates walking archetypes spread over more memory; checked, +1.8%. Worlds without shared components, five rounds against the commit before: within noise (`run idle` 208 → 208 ns, `run observer` 125 → 125, `loop tick idle`, `move 1K`, `main thread 1K`, `sync point one spawn` 708 → 708, `create` +0.5%, `create flat`, `spawn bulk`, `despawn one`, `churn`, `add value`, `remote run`, `joined observer resource`, `joined observer 10K`, `handoff`, `tail prompt` +0.5% over eight rounds, `log replay`, `read run`); `run 50 idle` was +5% a system until the run's check for reclaimed archetypes kept the scan for new ones apart, out of what its runner inlines: 71.2 → 71.2 ns.
 
+Sync points and tiers that apply nothing (adobe/data#245), node, alternating eight rounds against `244f952` with the
+new benchmarks added there: eight systems over rows no entity has, each with a command it never issues. `chained
+unordered`, one tier, 538 → 538 ns a run; `chained quiet`, eight tiers by `after` with no commands, 717 → 636;
+`chained noting`, eight tiers whose commands no later system depends on, 723 → 636; `chained commanding`, eight tiers
+and seven sync points, 859 → 713. A tier boundary on the world's thread costs about 14 ns, from 26, the tiers running
+as one pass; a sync point between them with nothing to apply about 11 ns, from 20, its check of what's pending standing
+for its activation, rewinds and publishing. The other node benchmarks are within noise of `244f952` over three
+rounds, and `read run` (+3.7%) and `loop tick add remove again` (+3.9%), which make a schedule each run, over ten.
+
 ## Where the gains came from
 
 Step figures marked (vitest) are from the node vitest lane: read them as relative.
@@ -241,6 +250,8 @@ Step figures marked (vitest) are from the node vitest lane: read them as relativ
   kernel, the second call stayed a call and boxed each entity, a double past 2^32. `despawn bulk kernel` 4.60 → 4.12 ms;
   `despawn bulk` compiled 4.55 ms against 4.32 as written before, 4.10 after.
 - Inline value writes instead of closures, an 8-shape spawn cache, edges indexed by component id, archetypes grown once per sync point: create 38 → 27.6 ms.
+- Holders of references spawned in a sync point are linked a block at a time before the cascade, from their columns, rather than listed as triples for the cascade and for the holder index each; and `commands.spawnTables` lists owners between its rows only when one is dropped, and reserves a table's entities at once when every row spawns: `spawn tables 1M owner` 160 → 53 ms, `spawn owned 1M` 133 → 64 ms, against 10 ms for `spawn tables 1M`. Each holder is journaled once, so an `up` tree builds again past 4096 journal entries and an eighth of its rows, as indexes do: `up load` 183 → 120 ms.
+- A row loop reads the body into a local once, which V8 otherwise loads again each row, since the call could change it; rows bind without allocating, and filters are found by archetype id: `with 100K` 4.24 → 3.97 ns a row, `one archetype 10K` 3.47 → 3.04, `small archetypes 1K` 7.74 → 6.90, `shared read 100K` 4.07 → 3.78.
 
 **Change filters.**
 - Chunk ticks, the newest tick per 1024 rows, so filters skip unchanged chunks: clustered sparse to ~0.09 ms.

package/src/implementation/world/program.ts

@@ -10,5 +10,8 @@ import type { Key } from './state.js';
 export const triggersOf = (item: Rule | Finalizer): { readonly keys: readonly Key[]; readonly any: boolean } => {
     if (item.kind === "rule") return { keys: item.declaration.components.has ?? [], any: false };
     if (item.kind === "finalizer") return { keys: [...item.declaration.components.read ?? [], ...item.declaration.components.has ?? []], any: false };
-    return { keys: item.declaration.watch ?? [], any: true };
+    const { watch } = item.declaration;
+    // Every component, or those declaring a trait, may be met at any sync point.
+    if (watch.components === true || watch.componentTraits.length + watch.resourceTraits.length > 0) return { keys: [], any: true };
+    return { keys: [...watch.components, ...watch.resources], any: true };
 };

package/src/implementation/world/resource-changes.test.ts

@@ -0,0 +1,61 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { expect, it } from "vitest";
+import { Finalizer, System } from "../../index.js";
+import { Observe } from "../../observe/index.js";
+import { createWorld } from "../index.js";
+import { sameValue } from "./resource-changes.js";
+
+const size = Symbol("resourceChanges/size");
+const corner = Symbol("resourceChanges/corner");
+const unwatched = Symbol("resourceChanges/unwatched");
+const log = Symbol("resourceChanges/log");
+const label = Symbol("resourceChanges/label");
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [label]: { type: string };
+    }
+    interface Resources {
+        [size]: { type: number; default: 1 };
+        [corner]: { type: readonly [number, number] };
+        [unwatched]: { type: number };
+        [log]: { type: readonly string[]; default: [] };
+    }
+}
+
+// Watching only resources, it sees no component's changes.
+Finalizer.changes({ watch: [size, corner] }, (changes, { resources }) => {
+    const lines = changes.resources.map(change => change.key === size ? `size ${change.previous} → ${change.next}` : `corner ${change.previous.join(",")} → ${change.next.join(",")}`);
+    resources[log] = [...resources[log], ...changes.groups.map(() => "group"), ...lines];
+});
+
+const resize = System.create({}, ({ resources }, input: { readonly to: number }) => {
+    resources[size] = input.to;
+    resources[size] = input.to + 1;
+});
+const move = System.create({}, ({ resources }, input: { readonly x: number }) => { resources[corner] = [input.x, 0]; });
+const touch = System.create({}, ({ resources }) => { resources[unwatched] += 1; });
+const spawn = System.create({}, ({ commands }) => { commands.spawn([label])({ [label]: "a" }); });
+const read = System.create({ readonly: true }, ({ resources }) => resources[log]);
+
+it("reports each watched resource written since its finalizers last ran, with its first and last value, once", async () => {
+    await using world = createWorld();
+    // A run writing nothing else still has a sync point, so its finalizers see the write.
+    await world.run(resize, { to: 4 });
+    expect(await world.run(read)).toEqual(["size 1 → 5"]);
+    await world.run(spawn);
+    await world.run(touch);
+    expect(await world.run(read)).toEqual(["size 1 → 5"]);
+    await world.run(move, { x: 2 });
+    // Written back to an equal value, leaf by leaf: not reported.
+    await world.run(move, { x: 2 });
+    await world.run(resize, { to: 4 });
+    expect(await world.run(read)).toEqual(["size 1 → 5", "corner 0,0 → 2,0"]);
+    expect(await Observe.toPromise(Observe.resource(world, size))).toBe(5);
+});
+
+it("compares data leaf by leaf and other objects by identity", () => {
+    const map = new Map();
+    expect([sameValue([1, { a: -0 }], [1, { a: -0 }]), sameValue({ a: 1 }, { a: 1, b: 2 }), sameValue(0, -0), sameValue(NaN, NaN), sameValue(map, new Map()), sameValue(map, map)])
+        .toEqual([true, false, false, true, false, true]);
+});

package/src/implementation/world/resource-changes.ts

@@ -0,0 +1,67 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { readCell } from './cells.js';
+import { indexOf } from './entities.js';
+import type { Storage } from './archetype.js';
+import type { State } from './state.js';
+
+/** A watched resource written to a value that isn't equal to the one its finalizers last saw. */
+export type ResourceChange = { readonly id: number; readonly previous: unknown; readonly next: unknown };
+
+const noChanges: readonly ResourceChange[] = [];
+
+/** Where resource `id` lives now, or null before the world has it. */
+const cellOf = (state: State, id: number): { readonly storage: Storage; readonly row: number } | null => {
+    if (state.resourceEntity < 0) return null;
+    const index = indexOf(state.resourceEntity);
+    const storage = state.archetypes[state.entities.archetype[index]]?.storageById[id];
+    return storage === undefined ? null : { storage, row: state.entities.row[index] };
+};
+
+/** Starts following resource `id` for a changes finalizer watching it, from its value now. */
+export const watchResource = (state: State, id: number): void => {
+    if (state.resourcesSeen.has(id)) return;
+    const cell = cellOf(state, id);
+    state.resourcesSeen.set(id, cell === null ? { value: state.starts[id], tick: 0 } : { value: readCell(cell.storage, cell.row), tick: cell.storage.changed[cell.row] });
+};
+
+/** Whether a watched resource was written since its finalizers last ran, so a sync point is due for them to see it. */
+export const resourcesWritten = (state: State): boolean => {
+    for (const [id, seen] of state.resourcesSeen) {
+        const cell = cellOf(state, id);
+        if (cell !== null && cell.storage.changed[cell.row] > seen.tick) return true;
+    }
+    return false;
+};
+
+/**
+ * Each watched resource written since its finalizers last ran, to a value that isn't equal to the one they saw then,
+ * with that value and its value now, which they see from now on.
+ */
+export const takeResourceChanges = (state: State): readonly ResourceChange[] => {
+    let changes: ResourceChange[] | null = null;
+    for (const [id, seen] of state.resourcesSeen) {
+        const cell = cellOf(state, id);
+        if (cell === null) continue;
+        const tick = cell.storage.changed[cell.row];
+        if (tick <= seen.tick) continue;
+        const next = readCell(cell.storage, cell.row);
+        if (!sameValue(seen.value, next)) (changes ??= []).push({ id, previous: seen.value, next });
+        state.resourcesSeen.set(id, { value: next, tick });
+    }
+    return changes ?? noChanges;
+};
+
+const isPlain = (value: object): boolean => {
+    const prototype: unknown = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+
+/** Whether two values are equal: data leaf by leaf, as `Object.is` compares leaves, and any other object by identity. */
+export const sameValue = (a: unknown, b: unknown): boolean => {
+    if (Object.is(a, b)) return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+    if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((item, i) => sameValue(item, b[i]));
+    if (Array.isArray(b) || !isPlain(a) || !isPlain(b)) return false;
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every(key => Object.hasOwn(b, key) && sameValue(Reflect.get(a, key), Reflect.get(b, key)));
+};

package/src/implementation/world/rows.ts

@@ -12,7 +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 { tablesReader } 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';
@@ -131,13 +131,26 @@ const viewOf = (storage: RowStorage): TypedArray => {
     return layout.kind === "linear" && storage.write !== writeGeneral ? storage.views[layout.leaves[0].view] : storage.views.f32;
 };
 
-const slotOf = (archetype: RowArchetype, id: number): Slot => {
+const storageOf = (archetype: RowArchetype, id: number): RowStorage => {
     const storage = archetype.storageById[id];
     // A system matches only archetypes with every component it reads or writes.
     if (storage === undefined) throw new Error(`Archetype ${archetype.id} lacks component ${id}.`);
+    return storage;
+};
+
+const slotOf = (archetype: RowArchetype, id: number): Slot => {
+    const storage = storageOf(archetype, id);
     return { storage, view: viewOf(storage), value: constantOf(storage) };
 };
 
+/** Points `slot` at `archetype`'s storage of component `id`, allocating nothing, since rows bind once per archetype a run. */
+const bindSlot = (slot: Slot, archetype: RowArchetype, id: number): void => {
+    const storage = storageOf(archetype, id);
+    slot.storage = storage;
+    slot.view = viewOf(storage);
+    slot.value = constantOf(storage);
+};
+
 /** An optional component's getter where the archetype lacks it, and its setter, which fails its system. */
 const absentGetter = (): undefined => undefined;
 const absentSetterOf = (key: Key): (value: unknown) => void => () => {
@@ -168,11 +181,7 @@ export const createRow = (host: RowHost, archetype: RowArchetype, keys: readonly
             row.entities = next.entities;
             for (let i = 0; i < ids.length; i++) {
                 const slot = slots[i];
-                if (slot === undefined) continue;
-                const { storage, view, value } = slotOf(next, ids[i]);
-                slot.storage = storage;
-                slot.view = view;
-                slot.value = value;
+                if (slot !== undefined) bindSlot(slot, next, ids[i]);
             }
         },
     };
@@ -271,12 +280,7 @@ export const sharedRows = (host: RowHost, keys: readonly Key[], ids: readonly nu
             slots: ids.map(id => slotOf(archetype, id)),
             bind: next => {
                 row.entities = next.entities;
-                for (let i = 0; i < ids.length; i++) {
-                    const { storage, view, value } = slotOf(next, ids[i]);
-                    row.slots[i].storage = storage;
-                    row.slots[i].view = view;
-                    row.slots[i].value = value;
-                }
+                for (let i = 0; i < ids.length; i++) bindSlot(row.slots[i], next, ids[i]);
             },
         };
         Object.defineProperty(value, rowOfValue, { value: row });
@@ -511,7 +515,10 @@ export const createContext = (state: State, declaration: Pick<Resolved, "lookup"
     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 });
+    if (tables !== undefined) {
+        const read = tablesReader(state, tables);
+        Object.defineProperty(value, "tables", { get: read, enumerable: true });
+    }
     const { lookup, resources } = declaration;
     const names = Object.keys(lookup ?? {});
     if (names.length > 0) {

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

@@ -226,6 +226,43 @@ describe("references", () => {
         await world.dispose();
     });
 
+    it("cascade through entities spawned together, whichever archetype each is spawned into first", async () => {
+        const world = createWorld({ [workers]: 0 });
+        const step = at(world);
+        let gone = Entity.none, owner = Entity.none, child = Entity.none, watcher = Entity.none;
+        await step(commands => { gone = commands.spawn([mark])({ [mark]: 0 }); });
+        await step(commands => commands.despawn(gone));
+        await step(commands => {
+            // The archetypes of the child and the watcher take their first spawns before the owner's does.
+            commands.spawn([mark, owned])({ [mark]: 1, [owned]: Entity.none });
+            commands.spawn([mark, follows])({ [mark]: 2, [follows]: Entity.none });
+            owner = commands.spawn([mark, owned, sprite])({ [mark]: 3, [owned]: gone });
+            child = commands.spawn([mark, owned])({ [mark]: 4, [owned]: owner });
+            watcher = commands.spawn([mark, follows])({ [mark]: 5, [follows]: owner });
+        });
+        expect(await read(world, owner, mark)).toBeNull();
+        expect(await read(world, child, mark)).toBeNull();
+        expect(await components(world, watcher)).toEqual([mark]);
+        await world.dispose();
+    });
+
+    it("cascade to entities spawned in the sync point their owner despawns in", async () => {
+        const world = createWorld({ [workers]: 0 });
+        const step = at(world);
+        let owner = Entity.none, child = Entity.none, grandchild = Entity.none;
+        await step(commands => { owner = commands.spawn([mark])({ [mark]: 0 }); });
+        await step(commands => {
+            // The grandchild's archetype takes its first spawn before the child's does.
+            commands.spawn([mark, owned, sprite])({ [mark]: 1, [owned]: Entity.none });
+            child = commands.spawn([mark, owned])({ [mark]: 2, [owned]: owner });
+            grandchild = commands.spawn([mark, owned, sprite])({ [mark]: 3, [owned]: child });
+            commands.despawn(owner);
+        });
+        expect(await read(world, child, mark)).toBeNull();
+        expect(await read(world, grandchild, mark)).toBeNull();
+        await world.dispose();
+    });
+
     it("move a holder whose weak reference is dropped to an archetype no entity had, closed by the rules", async () => {
         const world = createWorld({ [workers]: 0 });
         const step = at(world);

package/src/implementation/world/run-changes.test.ts

@@ -0,0 +1,88 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { expect, it } from "vitest";
+import { Entity, Finalizer, System } from "../../index.js";
+import { createWorld } from "../index.js";
+import type { Tables } from "../../interface/system/tables.js";
+import type { Table } from "../../interface/world/table/table.js";
+
+const name = Symbol("runChanges/name");
+const score = Symbol("runChanges/score");
+const spent = Symbol("runChanges/spent");
+const echo = Symbol("runChanges/echo");
+const budget = Symbol("runChanges/budget");
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [name]: { type: string };
+        [score]: { type: number };
+        [spent]: { type: true };
+        [echo]: { type: string };
+    }
+    interface Resources {
+        [budget]: { type: number; default: 10 };
+    }
+}
+
+// An entity spent leaves an echo, which its finalizer spawns at the next sync point.
+Finalizer.create({ components: { with: [name, spent] } }, (row, { commands }) => { commands.spawn([echo])({ [echo]: row[name] }); });
+
+const spawn = System.create({}, ({ commands }, input: { readonly who: string }) => { commands.spawn([name])({ [name]: input.who }); });
+const score10 = System.create({ components: { with: [name], not: [score] }, after: [spawn] }, (row, { commands }) => { commands.add(row.entity, score, 10); });
+const enter = System.create([spawn, score10]);
+const rescore = System.create({ components: { with: [score] } }, (row, { commands }) => { commands.add(row.entity, score, row[score] + 1); });
+const spend = System.create({ components: { with: [name] } }, (row, { commands, resources }) => {
+    commands.add(row.entity, spent);
+    commands.despawn(row.entity);
+    resources[budget] -= 1;
+});
+const raise = System.create({}, ({ resources }) => { resources[budget] = resources[budget]; });
+const readNamed = System.create({ readonly: true, tables: { components: [name] } }, ({ tables }): Tables => tables);
+const copied: { tables: readonly Table[] } = { tables: [] };
+const copy = System.create(({ commands }) => { commands.spawnTables(copied.tables); });
+const clear = System.create(({ commands }) => { commands.despawnWhere({ with: [name] }); });
+
+const describe = (changes: Awaited<ReturnType<typeof run>>) => changes.groups.map(group => ({
+    from: group.from?.map(key => key.description) ?? null, to: group.to?.map(key => key.description) ?? null,
+    replaced: group.replaced.map(key => key.description),
+    values: group.entities.map(entity => [changes.previous(entity, score), changes.next(entity, score), changes.previous(entity, name) ?? changes.next(entity, name)]),
+}));
+const run = (world: ReturnType<typeof createWorld>) => world.run(rescore, { changes: true });
+
+it("resolves to the run's own changes, merged across its sync points, with values before and after it", async () => {
+    await using world = createWorld();
+    const entered = await world.run(enter, { who: "ada" }, { changes: true });
+    expect(describe(entered)).toEqual([{ from: null, to: ["runChanges/name", "runChanges/score"], replaced: [], values: [[null, 10, "ada"]] }]);
+    expect(entered.resources).toEqual([]);
+    expect(describe(await run(world))).toEqual([{ from: ["runChanges/name", "runChanges/score"], to: ["runChanges/name", "runChanges/score"], replaced: ["runChanges/score"], values: [[10, 11, "ada"]] }]);
+});
+
+it("leaves out what finalizers of an earlier sync point queued, and gives what its systems wrote of resources", async () => {
+    await using world = createWorld();
+    await world.run(enter, { who: "bo" });
+    // Its finalizer queues an echo for the next sync point, which applies before the next run's own changes.
+    const spent = await world.run(spend, { changes: true });
+    expect(describe(spent)).toEqual([{ from: ["runChanges/name", "runChanges/score"], to: null, replaced: [], values: [[10, null, "bo"]] }]);
+    expect(spent.resources).toEqual([{ key: budget, previous: 10, next: 9 }]);
+    const raised = await world.run(raise, { changes: true });
+    expect([raised.groups, raised.resources]).toEqual([[], []]);
+    expect(raised.previous(Entity.none, name)).toBe(null);
+});
+
+it("runs as usual without the option, and with input that only looks like it", async () => {
+    await using world = createWorld();
+    const echoing = System.create({}, (_context, input: { readonly changes: boolean }) => input.changes);
+    expect(await world.run(echoing, { changes: true })).toBe(true);
+    expect(await world.run(raise)).toBe(undefined);
+});
+
+it("gives the rows spawnTables spawns and the entities despawnWhere despawns as a run's changes", async () => {
+    await using world = createWorld();
+    await world.run(enter, { who: "cy" });
+    copied.tables = (await world.run(readNamed)).archetypes;
+    // The tables copy names alone.
+    expect(describe(await world.run(copy, { changes: true }))).toEqual([{ from: null, to: ["runChanges/name"], replaced: [], values: [[null, null, "cy"]] }]);
+    expect(describe(await world.run(clear, { changes: true }))).toEqual([
+        { from: ["runChanges/name"], to: null, replaced: [], values: [[null, null, "cy"]] },
+        { from: ["runChanges/name", "runChanges/score"], to: null, replaced: [], values: [[10, null, "cy"]] },
+    ]);
+});