@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/world/move-log.test.ts

@@ -1,15 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { createBuffer, addCommand, pushCommand, pushComponent, removeCommand, type CommandBuffer } from "./buffer.js";
 import { readCell } from "./cells.js";
 import { createCommands } from "./commands.js";
 import { asEntity, indexOf, locate as locateHere } from "./entities.js";
 import { recordCount, structureWord, tableOffsetWord } from "./layout-directory.js";
 import { applying, cellOf, createMirror, nameComponent, rebuild, replay, stage, waitStructure, type Mirror } from "./mirror.js";
-import { createMoveLog, ownTag, slotValue, type MoveLog } from "./move-log.js";
+import { createMoveLog, logSyncWord, ownTag, slotValue, type MoveLog } from "./move-log.js";
 import { claimThreads } from "./remote.js";
 import { createState, defaultOf, idOf, startTicking, type State } from "./state.js";
 import { applySync, prepareSync, synchronize } from "./synchronize.js";
+import { createThreadDirectory } from "./thread-directory.js";
+import { createThreadSystems } from "./thread-systems.js";
+import {
+    completionCapacityWord, completionOffsetWord, payloadCapacityWord, payloadCount, payloadInput, payloadOffsetWord, payloadSequence, payloadSync, ringBaseWord,
+    ringCapacityWord, taskBlockWords, taskDoneWord, taskPostedWord,
+} from "./thread-tasks.js";
 
 // The move log on one thread: a world whose objects of thread "moveLogTest" a mirror fills, against an inline world given
 // the same commands, compared after every sync point by each entity's id.
@@ -28,21 +34,18 @@ declare module "@adobe/ecs" {
         [uid]: { type: number };
         [amount]: { type: number };
         [flag]: { type: true };
-        [label]: { type: { readonly text: string } | null; thread: "moveLogTest" };
+        [label]: { type: Label; thread: "moveLogTest" };
         [note]: { type: Note | null; thread: "moveLogTest" };
         [own]: { type: string };
     }
 }
-Component.register(uid, { type: { type: "number" } });
-Component.register(amount, { type: { type: "number" } });
-Component.register(flag, { type: { const: true } });
 /** A value that isn't data. */
 type Note = { readonly text: string; readonly read: () => string };
 /** The label's start, which a command on another thread than its own gives it by this value. */
-const none = { text: "none" };
-Component.register(label, { type: { anyOf: [{ type: "object", properties: { text: { type: "string" } } }, { type: "null" }], default: none }, thread: "moveLogTest" });
-Component.register(note, { thread: "moveLogTest" });
-Component.register(own, { type: { type: "string" } });
+const none = { text: "none" } as const;
+/** A label, which starts as `none`, the value commands on other threads give it by identity. */
+type Label = { readonly text: string } | null;
+const Label = { default: none };
 
 const remoteKeys = [label, note] as const;
 
@@ -80,7 +83,7 @@ const inline = (): State => {
 /** Brings the mirror up to the last sync point, rebuilding when its log lapped it. */
 const follow = (mirror: Mirror): void => {
     const replayed = replay(mirror);
-    if (replayed === "lapped") expect(rebuild(mirror)).toBe(true);
+    if (replayed === "lapped") expect(rebuild(mirror)).toBe("rebuilt");
     else expect(replayed).toBe("current");
 };
 
@@ -224,6 +227,49 @@ const property = (seed: number, minimum: number, steps: number): { readonly comp
     return { compared, rebuilds: mirror.rebuilds };
 };
 
+/**
+ * A thread's systems over a mirror the log lapped, so its next task rebuilds it: `post` posts a task of no systems,
+ * which runs once the mirror is current, its input by message when `input`; `refreshes` counts its tries.
+ */
+const lapped = () => {
+    const { state, mirror, log } = threaded(4);
+    const { commands, target } = worldCommands(state);
+    const queue = (): void => { state.queued.push({ buffer: target.buffer, guarded: true }); };
+    const entity = commands.spawn([uid, label])({ [uid]: 1 });
+    queue();
+    synchronize(state);
+    follow(mirror);
+    const { memory } = state;
+    const control = new Int32Array(memory.memory.buffer, memory.allocate(taskBlockWords * 4), taskBlockWords);
+    const payload = memory.allocate(256);
+    Atomics.store(control, payloadOffsetWord, payload);
+    Atomics.store(control, payloadCapacityWord, 256);
+    Atomics.store(control, completionOffsetWord, memory.allocate(256));
+    Atomics.store(control, completionCapacityWord, 256);
+    Atomics.store(control, ringBaseWord, memory.allocate(1 << 16));
+    Atomics.store(control, ringCapacityWord, 1 << 16);
+    const directory = createThreadDirectory(memory.memory, mirror);
+    let refreshed = 0;
+    const counted = { ...directory, refresh: () => { refreshed++; return directory.refresh(); } };
+    const systems = createThreadSystems({
+        memory: memory.memory, mirror, directory: counted, control, claims: new Set(["moveLogTest"]),
+        worldWaits: true, post: () => {}, keyNumber: () => 0, numbered: () => 0,
+    });
+    // More entries than the log holds.
+    for (let k = 0; k < 8; k++) commands.add(entity, amount, k);
+    queue();
+    synchronize(state);
+    const post = (input: boolean): void => {
+        const words = new Float64Array(memory.memory.buffer, payload, 32);
+        words[payloadSequence] = 1;
+        words[payloadSync] = Atomics.load(log.header, logSyncWord) >>> 0;
+        words[payloadCount] = 0;
+        words[payloadInput] = input ? 1 : 0;
+        Atomics.store(control, taskPostedWord, 1);
+    };
+    return { state, mirror, entity, commands, queue, systems, post, done: () => Atomics.load(control, taskDoneWord) === 1, refreshes: () => refreshed };
+};
+
 describe("the move log", () => {
     it("gives a joined thread's columns the inline world's values and ticks after every sync point, replaying its log", () => {
         for (const seed of [1, 2, 3, 4]) {
@@ -323,4 +369,61 @@ describe("the move log", () => {
         synchronize(state);
         expect(words[record + recordCount]).toBe(4);
     });
+    it("runs a thread's task once its rebuild failed for a sync point applied during it, with no wake after", async () => {
+        const { state, mirror, entity, commands, queue, systems, post, done } = lapped();
+        // A sync point applies while the thread rebuilds, after it read the structure epoch, and none follows it.
+        const through = mirror.finalize;
+        let applied = false;
+        mirror.finalize = (sync, old) => {
+            if (!applied) {
+                applied = true;
+                commands.add(entity, amount, 9);
+                queue();
+                synchronize(state);
+            }
+            return through === null || through(sync, old);
+        };
+        post(false);
+        expect(systems.process()).toBe(false);
+        expect(applied).toBe(true);
+        await new Promise(resolve => setTimeout(resolve, 5));
+        expect(done()).toBe(true);
+    });
+    it("runs a thread's task once the sync point its rebuild found applying is applied", async () => {
+        const { state, mirror, entity, commands, queue, systems, post, done, refreshes } = lapped();
+        commands.add(entity, amount, 9);
+        queue();
+        expect(prepareSync(state)).toBe(true);
+        expect(rebuild(mirror)).toBe("moved");
+        post(false);
+        expect(systems.process()).toBe(false);
+        const tried = refreshes();
+        await new Promise(resolve => setTimeout(resolve, 5));
+        expect(done()).toBe(false);
+        // It waits on the structure epoch, trying nothing until the sync point is applied.
+        expect(refreshes()).toBe(tried);
+        applySync(state);
+        await new Promise(resolve => setTimeout(resolve, 5));
+        expect(done()).toBe(true);
+    });
+    it("keeps a thread's event loop while its task waits for its input, after a rebuild outside a task found a sync point applying", async () => {
+        const { state, mirror, entity, commands, queue, systems, post, done, refreshes } = lapped();
+        commands.add(entity, amount, 9);
+        queue();
+        expect(prepareSync(state)).toBe(true);
+        // Its finalizers replay, and the rebuild finds the sync point applying.
+        mirror.stagedTransfers = 1;
+        systems.finalize();
+        applySync(state);
+        // A task whose input is posted after it: nothing runs it until the input arrives.
+        post(true);
+        expect(systems.process()).toBe(false);
+        const before = refreshes();
+        for (let k = 0; k < 200; k++) await Promise.resolve();
+        const tries = refreshes() - before;
+        systems.input(1, { given: true });
+        expect(done()).toBe(true);
+        // None while the thread's event loop goes on, so the input's message can arrive.
+        expect(tries).toBe(0);
+    });
 });

package/src/implementation/world/move-log.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Archetype } from './archetype.js';
 import type { Memory } from './memory.js';
 

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Finalizer } from "../../interface/finalizer/finalizer.js";
 import { identify } from "../../interface/registry/ids.test-helper.js";
 import { workers } from "../../interface/resources/workers.js";
@@ -7,7 +7,8 @@ import { Rule } from "../../interface/rule/rule.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
 import { count } from "./reads.test-helper.js";
-import { runReported } from "./reports.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
+import { ownId } from "./package-id.test-helper.js";
 
 const value = Symbol("namesTest/value");
 const other = Symbol("namesTest/other");
@@ -23,35 +24,36 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(value, { type: { type: "number" } });
-Component.register(other, { type: { type: "number" } });
-Component.register(first, { type: { const: true }, derived: true });
-Component.register(second, { type: { const: true }, derived: true });
 
-// Two libraries, written apart, both name a rule, a finalizer and a system "linked".
-Rule.create({ name: "namesTest/linked", components: { has: [value] }, derive: [first] });
-Rule.create({ name: "namesTest/linked", components: { has: [value] }, derive: [second] });
+// Two libraries, written apart, each declare a rule, a finalizer and a system labeled "linked".
+const library = (finalizer: (row: { readonly [value]: number }) => void, derived: typeof first | typeof second) => {
+    Rule.create({ components: { with: [value] }, derive: [derived] });
+    // Its body is written in place, so the build reads it, and calls what it's given with the row.
+    Finalizer.create({ components: { with: [value] } }, row => finalizer(row));
+};
 const released: string[] = [];
 let failing = false;
-Finalizer.create({ name: "namesTest/linked", components: { read: [value] } }, row => { released.push(`first ${row[value]}`); });
-Finalizer.create({ name: "namesTest/linked", components: { read: [value] } }, row => { released.push(`second ${row[value]}`); if (failing) throw new Error("second failed"); });
+library(row => { released.push(`first ${row[value]}`); }, first);
+library(row => { released.push(`second ${row[value]}`); if (failing) throw new Error("second failed"); }, second);
 
 const ran: string[] = [];
-const spawn = System.create({ name: "namesTest/spawn" }, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); });
-const despawn = System.create({ name: "namesTest/despawn", components: { has: [value] } }, (row, { commands }) => { commands.despawn(row.entity); });
+const spawn = System.create({}, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); });
+const despawn = System.create({ components: { with: [value] } }, (row, { commands }) => { commands.despawn(row.entity); });
 const failOnce = System.create(() => { throw new Error("unnamed"); });
 
-describe("systems, rules and finalizers of one name", () => {
-    it("are distinct in schedules, both run, and are told apart in reports by their labels", async () => {
-        const a = System.create({ name: "namesTest/linked", components: { write: [value] } }, row => { ran.push("a"); row[value] += 1; });
-        const b = System.create({ name: "namesTest/linked", components: { write: [value] }, after: [a] }, row => { ran.push("b"); row[value] += 1; throw new Error("b failed"); });
-        const c = System.create({ name: "namesTest/linked", components: { read: [value] }, after: [b] }, row => { ran.push(`c${row[value]}`); });
+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 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]}`); });
         await using world = createWorld({ [workers]: 0 });
         await world.run(spawn);
-        const report = await runReported(world, System.create({ name: "namesTest/frame", systems: [c, b, a] }));
+        const report = await runReported(world, System.create({ systems: [c, b, a] }));
         expect(ran).toEqual(["a", "b"]);
-        expect(report.failures.map(({ kind, name, message }) => ({ kind, name, message }))).toEqual([{ kind: "system", name: "namesTest/linked#6", message: "b failed" }]);
-        expect(report.skipped).toEqual(["namesTest/linked#7"]);
+        expect(report.failures.map(({ kind, name, id, message }) => ({ kind, name, id, message }))).toEqual([{ kind: "system", name: "linked", id: null, message: "b failed" }]);
+        expect(report.skipped).toEqual(["linked"]);
     });
     it("both apply, as rules and as finalizers", async () => {
         await using world = createWorld({ [workers]: 0 });
@@ -62,19 +64,17 @@ describe("systems, rules and finalizers of one name", () => {
         const report = await runReported(world, despawn);
         failing = false;
         expect(released).toEqual(["first 1", "second 1"]);
-        expect(report.failures.map(({ kind, name }) => ({ kind, name }))).toEqual([{ kind: "finalizer", name: "namesTest/linked#4" }]);
+        expect(report.failures.map(({ kind, name }) => ({ kind, name }))).toEqual([{ kind: "finalizer", name: "library" }]);
     });
-    it("are labeled by name and id where the plugin gave ids", async () => {
-        const write = (id: string) => System.create(identify({ name: "namesTest/library", components: { write: [other] } }, id), row => { row[other] = 1; throw new Error(id); });
-        const one = write("one.ts#library");
-        const two = write("two.ts#library");
+    it("are labeled by the bindings of their ids, which reports give beside them", async () => {
+        const [one, two] = ["one.ts#library", "two.ts#library"].map(id => System.create(identify({ components: { with: [other] } }, id), row => { row[other] = 1; throw new Error(id); }));
         await using world = createWorld({ [workers]: 0 });
-        await world.run(System.create({ name: "namesTest/spawnOther" }, ({ commands }) => { commands.spawn([other])({ [other]: 0 }); }));
-        const names = async (system: System) => (await runReported(world, system)).failures.map(failure => failure.name);
-        expect([await names(one), await names(two)]).toEqual([["namesTest/library (one.ts#library)"], ["namesTest/library (two.ts#library)"]]);
+        await world.run(System.create({}, ({ commands }) => { commands.spawn([other])({ [other]: 0 }); }));
+        const labels = async (system: System | undefined) => system === undefined ? [] : (await runReported(world, system)).failures.map(failure => [failure.name, failure.id]);
+        expect([await labels(one), await labels(two)]).toEqual([[["library", "one.ts#library"]], [["library", "two.ts#library"]]]);
     });
-    it("label a system without a name by its binding and the id the plugin gave it", async () => {
+    it("label a top-level system by its binding, its id naming its package, version, module and binding", async () => {
         await using world = createWorld({ [workers]: 0 });
-        expect((await runReported(world, failOnce)).failures.map(failure => failure.name)).toEqual(["failOnce (@adobe/ecs/src/implementation/world/names.test.ts#failOnce)"]);
+        expect((await runReported(world, failOnce)).failures.map(failure => [failure.name, failure.id])).toEqual([["failOnce", ownId("src/implementation/world/names.test.ts", "failOnce")]]);
     });
 });

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import type { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
@@ -7,6 +7,8 @@ import { gpuDevice } from "../../interface/resources/gpu-device.js";
 import { workers } from "../../interface/resources/workers.js";
 import { Observe } from "../../observe/index.js";
 import { settle } from "./observe.test-helper.js";
+import type { F32 } from "../../interface/math/index.js";
+import { gpu } from "./gpu.test-helper.js";
 
 // The observer factories of `src/observe` over values GPU kernels wrote.
 
@@ -17,24 +19,22 @@ const rate = Symbol("observeCasesGpuTest/rate");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [heat]: { type: number };
-        [rate]: { type: number };
+        [heat]: { type: F32 };
+        [rate]: { type: F32 };
     }
 }
 
-Component.register(heat, { type: { type: "number", precision: 1 } });
-Component.register(rate, { type: { type: "number", precision: 1 } });
 
 let spawned: Entity[] = [];
-const spawn = System.create({ name: "observeCasesGpuTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     spawned = [];
     for (let i = 0; i < 100; i++) spawned.push(commands.spawn([heat, rate])({ [heat]: i, [rate]: 1 }));
 });
-const warm = System.create({ name: "observeCasesGpuTest/warm", kernel: "gpu", components: { read: [rate], write: [heat] } }, row => {
+const warm = System.create({ kernel: "gpu", components: { with: [rate, heat] } }, row => {
     row[heat] = row[heat] + row[rate] * 100;
 });
 
-const idle = System.create({ name: "observeCasesGpuTest/idle" }, () => {});
+const idle = System.create({}, () => {});
 
 const device = async (): Promise<GPUDevice> => {
     const adapter = await navigator.gpu.requestAdapter();
@@ -43,7 +43,7 @@ const device = async (): Promise<GPUDevice> => {
 };
 
 describe("observers of GPU kernels' writes", () => {
-    it("give an entity's values the GPU wrote, read back after each run, and a first value once read back", async () => {
+    it.runIf(gpu)("give an entity's values the GPU wrote, read back after each run, and a first value once read back", async () => {
         const world = createWorld({ [workers]: 0, [gpuDevice]: await device() });
         await world.run(spawn);
         const seen: unknown[] = [];
@@ -63,7 +63,7 @@ describe("observers of GPU kernels' writes", () => {
         await world.dispose();
     });
 
-    it("give a query's result over values the GPU wrote", async () => {
+    it.runIf(gpu)("give a query's result over values the GPU wrote", async () => {
         const world = createWorld({ [workers]: 0, [gpuDevice]: await device() });
         await world.run(spawn);
         const counts: number[] = [];
@@ -77,7 +77,7 @@ describe("observers of GPU kernels' writes", () => {
         await world.dispose();
     });
 
-    it("give an observer waiting for its first value nothing from a run queued before it", async () => {
+    it.runIf(gpu)("give an observer waiting for its first value nothing from a run queued before it", async () => {
         const world = createWorld({ [workers]: 0, [gpuDevice]: await device() });
         await world.run(spawn);
         await world.run(warm);

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

@@ -1,15 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { workers } from "../../interface/resources/workers.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "../index.js";
 import { Observe } from "../../observe/index.js";
 import { settle } from "./observe.test-helper.js";
-import { fillReports, runReported, runThenNext } from "./reports.test-helper.js";
-import { retainedRuns } from "./reports.js";
-import { Report } from "../../interface/report/report.js";
+import { catchOutOfBand, runReported } from "./outcomes.test-helper.js";
+import type { F32 } from "../../interface/math/index.js";
 
 // The observer factories of `src/observe`. Each case subscribes, settles, then expects, so it holds whenever a first
 // value comes.
@@ -30,19 +28,15 @@ declare module "@adobe/ecs" {
     }
 }
 
-Resource.register(level, { type: { type: "number", default: 0 } });
-Resource.register(other, { type: { type: "number", default: 0 } });
-Resource.register(total, { type: { type: "number", default: 0 }, reduce: "+" });
-Component.register(weight, { type: { type: "number" } });
 
-const raise = System.create({ name: "observeCasesTest/raise", input: { type: "object", properties: { by: { type: "number" } } }, resources: { write: [level] } }, ({ input, resources }) => {
+const raise = System.create({}, ({ resources }, input: { readonly by: number }) => {
     resources[level] += input.by;
     resources[level] += input.by;
 });
-const touchOther = System.create({ name: "observeCasesTest/touchOther", resources: { write: [other] } }, ({ resources }) => { resources[other] += 1; });
-const spawn = System.create({ name: "observeCasesTest/spawn" }, ({ commands }) => { commands.spawn([weight])({ [weight]: 2 }); });
-const sum = System.create({ name: "observeCasesTest/sum", components: { read: [weight] }, reduce: { [total]: "+" } }, (row, { reduce }) => { reduce[total](row[weight]); });
-const keep = System.create({ name: "observeCasesTest/keep", resources: { write: [level] } }, ({ resources }) => { resources[level] = resources[level] + 0; });
+const touchOther = System.create({}, ({ resources }) => { resources[other] += 1; });
+const spawn = System.create({}, ({ commands }) => { commands.spawn([weight])({ [weight]: 2 }); });
+const sum = System.create({ components: { with: [weight] } }, (row, { reduce }) => { reduce[total](row[weight]); });
+const keep = System.create({}, ({ resources }) => { resources[level] = resources[level] + 0; });
 
 /** Errors thrown out of band while `catching` runs, as uncaught errors would be, caught instead. */
 const catching = async (run: () => Promise<void>): Promise<unknown[]> => {
@@ -81,25 +75,21 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(heat, { type: { type: "number" } });
-Component.register(tag, { type: { const: true } });
-Component.register(flag, { type: { const: true } });
-Component.register(filler, { type: { type: "number" } });
 
 /** The entity the systems below act on, set by `create`. */
 let target = Entity.none;
-const create = System.create({ name: "observeCasesTest/create" }, ({ commands }) => { target = commands.spawn([weight, heat])({ [weight]: 1, [heat]: 0 }); });
-const despawn = System.create({ name: "observeCasesTest/despawn" }, ({ commands }) => { commands.despawn(target); });
-const weigh = System.create({ name: "observeCasesTest/weigh", components: { write: [weight], not: [filler] } }, row => {
+const create = System.create({}, ({ commands }) => { target = commands.spawn([weight, heat])({ [weight]: 1, [heat]: 0 }); });
+const despawn = System.create({}, ({ commands }) => { commands.despawn(target); });
+const weigh = System.create({ components: { with: [weight], not: [filler] } }, row => {
     row[weight] += 1;
     row[weight] += 1;
 });
-const warm = System.create({ name: "observeCasesTest/warm", components: { write: [heat] } }, row => { row[heat] += 1; });
-const double = System.create({ name: "observeCasesTest/double", kernel: "cpu", components: { write: [heat] } }, row => { row[heat] = row[heat] * 2 + 1; });
-const addTag = System.create({ name: "observeCasesTest/addTag" }, ({ commands }) => { commands.add(target, tag, true); });
-const removeTag = System.create({ name: "observeCasesTest/removeTag" }, ({ commands }) => { commands.remove(target, tag); });
-const removeWeight = System.create({ name: "observeCasesTest/removeWeight" }, ({ commands }) => { commands.remove(target, weight); });
-const addFlag = System.create({ name: "observeCasesTest/addFlag" }, ({ commands }) => { commands.add(target, flag, true); });
+const warm = System.create({ components: { with: [heat] } }, row => { row[heat] += 1; });
+const double = System.create({ kernel: true, components: { with: [heat] } }, row => { row[heat] = row[heat] * 2 + 1; });
+const addTag = System.create({}, ({ commands }) => { commands.add(target, tag, true); });
+const removeTag = System.create({}, ({ commands }) => { commands.remove(target, tag); });
+const removeWeight = System.create({}, ({ commands }) => { commands.remove(target, weight); });
+const addFlag = System.create({}, ({ commands }) => { commands.add(target, flag, true); });
 
 const score = Symbol("observeCasesTest/score");
 const benched = Symbol("observeCasesTest/benched");
@@ -113,36 +103,33 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(score, { type: { type: "number" } });
-Component.register(benched, { type: { const: true } });
-Component.register(marker, { type: { const: true } });
 
 /** Players the systems below act on, in spawn order, set by `players`. */
 let roster: Entity[] = [];
-const players = System.create({ name: "observeCasesTest/players" }, ({ commands }) => {
+const players = System.create({}, ({ commands }) => {
     roster = [commands.spawn([score])({ [score]: 1 }), commands.spawn([score])({ [score]: 2 }), commands.spawn([score, benched])({ [score]: 3, [benched]: true })];
 });
-const join = System.create({ name: "observeCasesTest/join" }, ({ commands }) => { roster.push(commands.spawn([score])({ [score]: 0 })); });
-const bench = System.create({ name: "observeCasesTest/bench" }, ({ commands }) => { commands.add(roster[0], benched, true); });
+const join = System.create({}, ({ commands }) => { roster.push(commands.spawn([score])({ [score]: 0 })); });
+const bench = System.create({}, ({ commands }) => { commands.add(roster[0], benched, true); });
 /** The first player leaves the bench as the last joins it, so as many match as before. */
-const swap = System.create({ name: "observeCasesTest/swap" }, ({ commands }) => {
+const swap = System.create({}, ({ commands }) => {
     commands.add(roster[0], benched, true);
     commands.remove(roster[2], benched);
 });
-const mark = System.create({ name: "observeCasesTest/mark" }, ({ commands }) => { commands.add(roster[0], marker, true); });
-const leave = System.create({ name: "observeCasesTest/leave" }, ({ commands }) => { commands.despawn(roster[1]); });
-const score10 = System.create({ name: "observeCasesTest/score10", components: { write: [score] } }, row => { row[score] += 10; });
-const nudge = System.create({ name: "observeCasesTest/nudge", components: { write: [score] } }, row => { row[score] += 0; });
-const invert = System.create({ name: "observeCasesTest/invert", components: { write: [score] } }, row => { row[score] = -row[score]; });
-const invertKernel = System.create({ name: "observeCasesTest/invertKernel", kernel: "cpu", components: { write: [score] } }, row => { row[score] = 0 - row[score]; });
+const mark = System.create({}, ({ commands }) => { commands.add(roster[0], marker, true); });
+const leave = System.create({}, ({ commands }) => { commands.despawn(roster[1]); });
+const score10 = System.create({ components: { with: [score] } }, row => { row[score] += 10; });
+const nudge = System.create({ components: { with: [score] } }, row => { row[score] += 0; });
+const invert = System.create({ components: { with: [score] } }, row => { row[score] = -row[score]; });
+const invertKernel = System.create({ kernel: true, components: { with: [score] } }, row => { row[score] = 0 - row[score]; });
 /** Swaps the bench like `swap`, then despawns more entities than the journal holds, so it drops the swap's entries. */
-const swapAndCrowd = System.create({ name: "observeCasesTest/swapAndCrowd" }, ({ commands }) => {
+const swapAndCrowd = System.create({}, ({ commands }) => {
     commands.add(roster[0], benched, true);
     commands.remove(roster[2], benched);
     for (const spawned of crowded.splice(0)) commands.despawn(spawned);
 });
 const crowded: Entity[] = [];
-const crowdUp = System.create({ name: "observeCasesTest/crowdUp" }, ({ commands }) => {
+const crowdUp = System.create({}, ({ commands }) => {
     for (let i = 0; i < 5000; i++) crowded.push(commands.spawn([filler])({ [filler]: i }));
 });
 
@@ -156,22 +143,19 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(rank, { type: { type: "number" } });
-Component.register(second, { type: { type: "number" } });
 
 const coarse = Symbol("observeCasesTest/coarse");
 declare module "@adobe/ecs" {
     interface Components {
-        [coarse]: { type: number };
+        [coarse]: { type: F32 };
     }
 }
 // Kept at 32 bits, so a 64-bit bound may fall between two values it keeps.
-Component.register(coarse, { type: { type: "number", precision: 1 } });
 let coarseValues: readonly number[] = [];
-const spawnCoarse = System.create({ name: "observeCasesTest/spawnCoarse" }, ({ commands }) => {
+const spawnCoarse = System.create({}, ({ commands }) => {
     for (const each of coarseValues) commands.spawn([coarse])({ [coarse]: each });
 });
-const shiftCoarse = System.create({ name: "observeCasesTest/shiftCoarse", components: { write: [coarse] } }, row => { row[coarse] = row[coarse] + 0.1; });
+const shiftCoarse = System.create({ components: { with: [coarse] } }, row => { row[coarse] = row[coarse] + 0.1; });
 
 type Condition = number | { readonly "<"?: number; readonly ">"?: number; readonly "<="?: number; readonly ">="?: number; readonly "=="?: number; readonly "!="?: number };
 
@@ -183,12 +167,12 @@ const passesCondition = (value: number, condition: Condition): boolean => typeof
 let ranks: readonly (readonly [number, number, boolean])[] = [];
 /** The entities `rankAll` spawned, in order. */
 let ranked: Entity[] = [];
-const rankAll = System.create({ name: "observeCasesTest/rankAll" }, ({ commands }) => {
+const rankAll = System.create({}, ({ commands }) => {
     ranked = ranks.map(([value, key, marked]) => commands.spawn(marked ? [rank, second, marker] : [rank, second])({ [rank]: value, [second]: key }));
 });
 /** What `rerank` sets: an index into `ranked` and its new rank. */
 let reranks: readonly (readonly [number, number])[] = [];
-const rerank = System.create({ name: "observeCasesTest/rerank" }, ({ commands }) => {
+const rerank = System.create({}, ({ commands }) => {
     for (const [index, value] of reranks) commands.add(ranked[index], rank, value);
 });
 
@@ -281,10 +265,9 @@ describe("observing resources", () => {
         });
         resource(world, level)(value => seen.push(value));
         await settle(world);
-        const { failures } = await runThenNext(world, raise, { by: 1 });
-        expect(failures.map(({ kind, name, message }) => ({ kind, name, message }))).toEqual([
-            { kind: "system", name: expect.stringMatching(/^Observe\.resource\(observeCasesTest\/level\)/), message: "observer failed" },
-        ]);
+        using reported = catchOutOfBand();
+        await world.run(raise, { by: 1 });
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "Observe\.resource\(observeCasesTest\/level\)".* failed: observer failed$/)]);
         expect(seen).toEqual([0, 2]);
     });
 
@@ -354,8 +337,6 @@ describe("observing entities", () => {
 
     it("gives null once the entity is despawned, and nothing for another entity that reuses its index", async () => {
         await using world = createWorld();
-        // Past the runs that spawn reports, whose entities would take the freed index first.
-        await fillReports(world);
         await world.run(create);
         const despawned = target;
         const seen: unknown[] = [];
@@ -449,8 +430,9 @@ describe("observing entities", () => {
         });
         entity(world, target, { required: [weight] })(value => seen.push(value));
         await settle(world);
-        const { failures } = await runThenNext(world, weigh);
-        expect(failures.map(({ kind, message }) => ({ kind, message }))).toEqual([{ kind: "system", message: "observer failed" }]);
+        using reported = catchOutOfBand();
+        await world.run(weigh);
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "Observe\.entity\(.*\)".* failed: observer failed$/)]);
         expect(seen).toEqual([{ [weight]: 1 }, { [weight]: 3 }]);
     });
 
@@ -458,11 +440,11 @@ describe("observing entities", () => {
         await using world = createWorld();
         await world.run(create);
         const seen: unknown[] = [];
-        const subscribe = System.create({ name: "observeCasesTest/subscribeEntity" }, () => {
+        const subscribe = System.create({}, () => {
             entity(world, target, { required: [weight] })(value => seen.push(value));
         });
-        const later = System.create({ name: "observeCasesTest/laterWeigh", components: { write: [weight] }, after: [subscribe] }, row => { row[weight] += 2; });
-        await world.run(System.create({ name: "observeCasesTest/subscribeThenWeigh", systems: [subscribe, later] }));
+        const later = System.create({ components: { with: [weight] }, after: [subscribe] }, row => { row[weight] += 2; });
+        await world.run(System.create({ systems: [subscribe, later] }));
         await settle(world);
         await world.run(warm);
         expect(seen).toEqual([{ [weight]: 3 }]);
@@ -591,11 +573,11 @@ describe("observing queries", () => {
         await using world = createWorld();
         await world.run(players);
         const seen: number[] = [];
-        const subscribe = System.create({ name: "observeCasesTest/subscribe" }, () => {
+        const subscribe = System.create({}, () => {
             count(world, { required: [score], where: { [score]: { "<": 0 } } })(value => seen.push(value));
         });
-        const later = System.create({ name: "observeCasesTest/later", components: { write: [score] }, after: [subscribe] }, row => { row[score] = -row[score]; });
-        await world.run(System.create({ name: "observeCasesTest/subscribeThenWrite", systems: [subscribe, later] }));
+        const later = System.create({ components: { with: [score] }, after: [subscribe] }, row => { row[score] = -row[score]; });
+        await world.run(System.create({ systems: [subscribe, later] }));
         await settle(world);
         expect(seen).toEqual([3]);
     });
@@ -609,10 +591,9 @@ describe("observing queries", () => {
         const seen: number[] = [];
         const stop = count(world, { required: [score, benched] })(value => seen.push(value));
         await settle(world);
-        const { failures } = await runThenNext(world, bench);
-        expect(failures.map(({ kind, name, message }) => ({ kind, name, message }))).toEqual([
-            { kind: "system", name: expect.stringMatching(/^Observe\.count\(observeCasesTest\/score, observeCasesTest\/benched\)/), message: "observer failed" },
-        ]);
+        using reported = catchOutOfBand();
+        await world.run(bench);
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "Observe\.count\(observeCasesTest\/score, observeCasesTest\/benched\)".* failed: observer failed$/)]);
         stop();
         await world.run(join);
         await world.run(leave);
@@ -769,30 +750,3 @@ describe("observing a page of a query", () => {
         }
     });
 });
-
-describe("the factories' own runs", () => {
-    it("rethrow their systems' failures out of band, from their reports, once a later run of theirs read them", async () => {
-        await using world = createWorld({ [workers]: 0 });
-        const fail = System.create({ name: "observeCasesTest/failRun" }, () => { throw new Error("run failed"); });
-        const nothing = System.create({ name: "observeCasesTest/nothing" }, () => {});
-        let reports = -1;
-        const caught = await catching(async () => {
-            // Its notifier throws once the failed run's report loses its errors, which a run of the factories' own does
-            // as it takes that report's entity.
-            count(world, { required: [Report.errors] })(value => {
-                if (reports === 1 && value === 0) throw new Error("count failed");
-                reports = value;
-            });
-            await settle(world);
-            const failed = await world.run(fail);
-            expect(reports).toBe(1);
-            while (await world.run(nothing) < failed + retainedRuns - 1);
-            // The factories' runs for these first values: the first takes the report, failing in its pass.
-            resource(world, level)(() => {});
-            await settle(world);
-            resource(world, other)(() => {});
-            await settle(world);
-        });
-        expect(caught.map(error => error instanceof Error ? error.message : error)).toEqual([expect.stringMatching(/^Observe\.count\(Report\/errors\).*: count failed$/)]);
-    });
-});