@adobe/ecs 0.1.0 → 0.2.0

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

@@ -1,5 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Resource, System, workers } from "../../index.js";
+import { System, workers } from "../../index.js";
 import { createWorld, join } from "./create.js";
 
 // Observer systems reading only resources on a joined thread, whose posts hold copies of what they read, with the world
@@ -10,31 +11,28 @@ const paused = Symbol("observerContainedTest/paused");
 const steps = Symbol("observerContainedTest/steps");
 declare module "@adobe/ecs" {
     interface Resources {
-        [wide]: { type: readonly [number, number, number, number, number, number, number, number, number, number, number, number] };
+        [wide]: { type: readonly [number, number, number, number, number, number, number, number, number, number, number, number]; default: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
         [paused]: { type: boolean };
         [steps]: { type: number };
     }
 }
 /** Twelve f64s: more than a post's block holds, so its posts copy them into a snapshot of their own. */
-Resource.register(wide, { type: { type: "array", items: { type: "number" }, minItems: 12, maxItems: 12, default: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] } });
-Resource.register(paused, { type: { type: "boolean", default: false } });
-Resource.register(steps, { type: { type: "number", default: 0 } });
 
-const widen = System.create({ name: "observerContainedTest/widen", resources: { write: [wide] } }, ({ resources }) => {
+const widen = System.create({}, ({ resources }) => {
     const first = resources[wide][0] + 1;
     const base = first * 100;
     resources[wide] = [base, base + 1, base + 2, base + 3, base + 4, base + 5, base + 6, base + 7, base + 8, base + 9, base + 10, base + 11];
 });
-const step = System.create({ name: "observerContainedTest/step", resources: { write: [steps] } }, ({ resources }) => { resources[steps] += 1; });
-const pause = System.create({ name: "observerContainedTest/pause", input: { type: "object", properties: { paused: { type: "boolean" } } }, resources: { write: [paused] } }, ({ input, resources }) => {
+const step = System.create({}, ({ resources }) => { resources[steps] += 1; });
+const pause = System.create({}, ({ resources }, input: { readonly paused: boolean }) => {
     resources[paused] = input.paused;
 });
 
 const seen: { wide: number[][]; steps: number[] } = { wide: [], steps: [] };
-const watchWide = System.create({ name: "observerContainedTest/watchWide", observer: true, resources: { read: [wide], changed: [wide] } }, ({ resources }) => {
+const watchWide = System.create({ observer: true, resources: { changed: [wide] } }, ({ resources }) => {
     seen.wide.push([...resources[wide]]);
 });
-const watchSteps = System.create({ name: "observerContainedTest/watchSteps", observer: true, resources: { read: [steps], not: [paused], changed: [steps] } }, ({ resources }) => {
+const watchSteps = System.create({ observer: true, resources: { not: [paused], changed: [steps] } }, ({ resources }) => {
     seen.steps.push(resources[steps]);
 });
 
@@ -48,15 +46,9 @@ const turns = async (count = 20): Promise<void> => {
 const joined = async () => {
     const world = createWorld({ [workers]: 0 });
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    const remote = join(channel.port2, {});
-    for (let turn = 0; turn < 2000; turn++) {
-        let status = "";
-        world.threads(progress => { status = progress.at(-1)?.status ?? ""; })();
-        if (status === "joined") break;
-        await new Promise(resolve => setTimeout(resolve, 0));
-    }
-    await remote.run(System.create({ name: "observerContainedTest/nothing", observer: true }, () => {}));
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, {});
+    await shared;
     return { world, remote, close: async () => { await remote.dispose(); await world.dispose(); } };
 };
 

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { MessagePort as NodeMessagePort } from "node:worker_threads";
 import type { Entity } from "../../interface/entity/entity.js";
 import type { World } from "../../interface/world/world.js";
@@ -52,7 +53,7 @@ const entities = (world: World, count: number): Promise<readonly Entity[]> => ne
 channel.onMessage(async message => {
     if ("protocol" in message) return;
     if (message.kind === "join") {
-        remote = join(message.port, {});
+        remote = await join(message.port, {});
         channel.post({ kind: "joined" });
     }
     else if (message.kind === "add") {

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./observer-joined.fixture.js";
 

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
@@ -9,7 +10,7 @@ import type { LoopPlatform } from "./loop.js";
 import type { FromObserverWorker, ToObserverWorker } from "./observer-joined-worker.fixture.js";
 import { counter, gateWords, holdWord, phase, reachedWord, releasedWord, seed, setMotto, setStall, spawnHeated, ticked, warm } from "./observer-joined.test-helper.js";
 import { tailWriters } from "./tails.js";
-import { followReports } from "./reports.test-helper.js";
+import { catchOutOfBand } from "./outcomes.test-helper.js";
 
 /**
  * Scenarios of observer systems a joined worker adds, run built in node and from source in chromium: a system over
@@ -61,10 +62,10 @@ const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T
 
 const joined = async (world: CreatedWorld): Promise<Worker> => {
     const { port1, port2 } = new MessageChannel();
-    world.share(port1);
+    const shared = world.share(port1);
     const worker = start();
     await worker.ask({ kind: "join", port: port2 }, [port2]);
-    await until(world.threads, threads => threads.at(-1)?.status === "joined");
+    await shared;
     return worker;
 };
 
@@ -185,8 +186,8 @@ export const continuous = async (system: "rows" | "lookups") => {
     const world = createWorld({ [workers]: 0, [always]: true }, { loop: frames });
     const worker = await joined(world);
     const words = new Int32Array(new SharedArrayBuffer(gateWords * 4));
-    // What the worker's runs threw, which reach the world's reports.
-    const reports = followReports(world);
+    // What the worker's runs threw, which the world reports out of band.
+    const reported = catchOutOfBand();
     await world.run(seed, { count: 1000 });
     world.add(ticked);
     await worker.ask({ kind: "add", system, gate: words });
@@ -202,7 +203,8 @@ export const continuous = async (system: "rows" | "lookups") => {
         partway = await writerReadyPartway(world, worker, frames, words);
         behind = await fellBehind(world, worker, frames, words);
     }
-    const failures = reports.seen.flatMap(report => report.failures.map(failure => failure.message));
+    const failures = reported.messages();
+    reported[Symbol.dispose]();
     await world.dispose();
     const reply = await seenBy(worker);
     await worker.terminate();

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

@@ -1,8 +1,9 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Index } from "../../interface/indexes/index-type.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import type { Entity } from "../../interface/entity/entity.js";
+import type { Schema } from "../../interface/schema/schema.js";
+import type { F32, Vec3 } from "../../interface/math/index.js";
 
 // Keys and systems both threads of the observer-joined fixtures import: world systems writing every row's stamp each
 // tick, and observer systems a joined thread adds, reading those rows as of one sync point.
@@ -19,38 +20,28 @@ export const motto = Symbol("observerJoinedWorkerTest/motto");
 export const mottoRound = Symbol("observerJoinedWorkerTest/mottoRound");
 declare module "@adobe/ecs" {
     export interface Components {
-        [stamp]: { type: number };
-        [spot]: { type: readonly [number, number, number] };
-        [heat]: { type: number };
-        [rate]: { type: number };
+        [stamp]: { type: Schema.Type<{ type: "integer" }> };
+        [spot]: { type: Vec3 };
+        [heat]: { type: F32 };
+        [rate]: { type: F32 };
         [word]: { type: string };
     }
     export interface Resources {
-        [counter]: { type: number };
+        [counter]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
         [stall]: { type: number };
-        [phase]: { type: number };
-        [motto]: { type: string };
-        [mottoRound]: { type: number };
+        [phase]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
+        [motto]: { type: string; default: "motto 0" };
+        [mottoRound]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
     }
 }
-Component.register(stamp, { type: { type: "integer" } });
-Component.register(spot, { type: { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } });
-Component.register(heat, { type: { type: "number", precision: 1 } });
-Component.register(rate, { type: { type: "number", precision: 1 } });
 /** A string the world writes each tick, which lives in shared memory where the observer system reads it. */
-Component.register(word, { type: { type: "string" } });
-Resource.register(counter, { type: { type: "integer", default: 0 } });
 /** A string resource the world writes with the round it's of, which an observer system on the thread reads alone. */
-Resource.register(motto, { type: { type: "string", default: "motto 0" } });
-Resource.register(mottoRound, { type: { type: "integer", default: 0 } });
 /** Moves on once a joined thread asked the world to run its observer system, so the world's thread knows it did. */
-Resource.register(phase, { type: { type: "integer", default: 0 } });
 /**
  * Milliseconds the observer systems spin partway through each run, so the world's next writer is likely ready before
  * they finish; negative, they wait there on the gate instead, until the world's thread releases them once a writer
  * copied.
  */
-Resource.register(stall, { type: { type: "number", default: 0 } });
 
 const spin = (milliseconds: number): void => {
     const until = performance.now() + milliseconds;
@@ -90,20 +81,20 @@ export const hold = (): void => {
 export const wordOf = (value: number): string => `${"·".repeat(value % 37)}${value}`;
 
 /** On the world's thread: the counter moves on once a tick, then every row's stamp, spot and word take it. */
-export const count = System.create({ name: "observerJoinedWorkerTest/count", resources: { write: [counter] } }, ({ resources }) => {
+export const count = System.create({}, ({ resources }) => {
     resources[counter] += 1;
 });
-export const advance = System.create({ name: "observerJoinedWorkerTest/advance", components: { write: [stamp, spot, word] }, resources: { read: [counter] }, after: [count] }, (row, { resources }) => {
+export const advance = System.create({ components: { with: [stamp, spot, word] }, after: [count] }, (row, { resources }) => {
     const value = resources[counter];
     row[stamp] = value;
     row[spot] = [value, -value, value];
     row[word] = wordOf(value);
 });
-export const ticked = System.create({ name: "observerJoinedWorkerTest/ticked", systems: [count, advance] });
-export const seed = System.create({ name: "observerJoinedWorkerTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const ticked = System.create({ systems: [count, advance] });
+export const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let k = 0; k < input.count; k++) commands.spawn([stamp, spot, word])({ [stamp]: 0, [spot]: [0, 0, 0], [word]: wordOf(0) });
 });
-export const setStall = System.create({ name: "observerJoinedWorkerTest/setStall", input: { type: "object", properties: { pause: { type: "number" } } }, resources: { write: [stall] } }, ({ input, resources }) => {
+export const setStall = System.create({}, ({ resources }, input: { readonly pause: number }) => {
     resources[stall] = input.pause;
 });
 
@@ -112,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({ name: "observerJoinedWorkerTest/watchRows", observer: true, components: { read: [stamp, spot, word] }, resources: { read: [counter, stall] } }, (row, { resources }) => {
+export const watchRows = System.create({ observer: 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 });
@@ -126,7 +117,7 @@ export const watchRows = System.create({ name: "observerJoinedWorkerTest/watchRo
 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({ name: "observerJoinedWorkerTest/lookRows", observer: true, resources: { read: [counter, stall] }, lookup: { found: { read: [stamp, spot] } } }, ({ resources, lookup }) => {
+export const lookRows = System.create({ observer: true, lookup: { found: { with: [stamp, spot] } } }, ({ resources, lookup }) => {
     const value = resources[counter];
     const run: Seen = { counter: value, rows: 0, wrong: 0 };
     seen.push(run);
@@ -141,27 +132,27 @@ export const lookRows = System.create({ name: "observerJoinedWorkerTest/lookRows
 });
 
 /** 100 rows heated 0 to 99, which a GPU kernel warms by 100 each run. */
-export const spawnHeated = System.create({ name: "observerJoinedWorkerTest/spawnHeated" }, ({ commands }) => {
+export const spawnHeated = System.create({}, ({ commands }) => {
     for (let i = 0; i < 100; i++) commands.spawn([heat, rate])({ [heat]: i, [rate]: 1 });
 });
-export const warm = System.create({ name: "observerJoinedWorkerTest/warm", kernel: "gpu", components: { read: [rate], write: [heat] } }, row => {
+export const warm = System.create({ kernel: "gpu", components: { with: [rate, heat] } }, row => {
     row[heat] = row[heat] + row[rate] * 100;
 });
-export const nextPhase = System.create({ name: "observerJoinedWorkerTest/nextPhase", resources: { write: [phase] } }, ({ resources }) => {
+export const nextPhase = System.create({}, ({ resources }) => {
     resources[phase] += 1;
 });
 
 /** What `countHot` counted, run by run, on the joined thread. */
 export const hot: number[] = [];
-export const byHeat = Index.create({ name: "observerJoinedWorkerTest/byHeat", key: [heat], sorted: true });
+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({ name: "observerJoinedWorkerTest/countHot", observer: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
+export const countHot = System.create({ observer: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
     hot.push(lookup.hot({ ">=": 150 }).length);
 });
 
 /** On the world's thread: the motto of a round, and the round, every motto of one size. */
 export const mottoOf = (round: number): string => `motto ${round % 10}`;
-export const setMotto = System.create({ name: "observerJoinedWorkerTest/setMotto", input: { type: "object", properties: { round: { type: "integer" } } }, resources: { write: [motto, mottoRound] } }, ({ input, resources }) => {
+export const setMotto = System.create({}, ({ resources }, input: { readonly round: number }) => {
     resources[motto] = mottoOf(input.round);
     resources[mottoRound] = input.round;
 });
@@ -173,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({ name: "observerJoinedWorkerTest/watchMotto", observer: true, resources: { read: [motto, mottoRound, stall] } }, ({ resources }) => {
+export const watchMotto = System.create({ observer: 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

@@ -1,11 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component, Index, Resource, System, workers } from "../../index.js";
-import type { Entity } from "../../interface/entity/entity.js";
+import { Index, System, workers } from "../../index.js";
+import { Entity } from "../../interface/entity/entity.js";
 import type { World } from "../../interface/world/world.js";
 import { createWorld, join, type CreatedWorld } from "./create.js";
 import { tablesOf } from "./join.js";
 import { Observe } from "../../observe/index.js";
-import { reportOf, runReported } from "./reports.test-helper.js";
+import { catchOutOfBand, runReported } from "./outcomes.test-helper.js";
 
 // Observer systems on a joined thread, with the world and the thread on this one, joined through a MessageChannel.
 
@@ -23,33 +24,30 @@ declare module "@adobe/ecs" {
         [amount]: { type: number };
         [cell]: { type: number };
         [tagged]: { type: true };
-        [label]: { type: { readonly text: string }; thread: "observerJoinedTest" };
-        [name]: { type: string };
+        [label]: { type: Label; thread: "observerJoinedTest" };
+        [name]: { type: string; default: "" };
     }
     interface Resources {
         [level]: { type: number };
     }
 }
-Component.register(amount, { type: { type: "number" } });
-Component.register(cell, { type: { type: "number" } });
-Component.register(tagged, { type: { const: true } });
 /** The label's start, which a command here gives it by this value. */
-const blank = { text: "" };
-Component.register(label, { type: { type: "object", properties: { text: { type: "string" } }, default: blank }, thread: "observerJoinedTest" });
-Component.register(name, { type: { type: "string", default: "" } });
-Resource.register(level, { type: { type: "number", default: 0 } });
+const blank = { text: "" } as const;
+/** A label, which starts as `blank`, the value commands on other threads give it by identity. */
+type Label = { readonly text: string };
+const Label = { default: blank };
 
-const byCell = Index.create({ name: "observerJoinedTest/byCell", key: [cell], components: { has: [amount] } });
-const allTagged = Index.create({ name: "observerJoinedTest/allTagged", key: [], components: { has: [tagged] } });
+const byCell = Index.create({ key: [cell], components: { with: [amount] } });
+const allTagged = Index.create({ key: [], components: { with: [tagged] } });
 
-const raise = System.create({ name: "observerJoinedTest/raise", resources: { write: [level] } }, ({ resources }) => { resources[level] += 1; });
-const nothing = System.create({ name: "observerJoinedTest/nothing" }, () => {});
-const spawn = System.create({ name: "observerJoinedTest/spawn", input: { type: "object", properties: { at: { type: "number" } } } }, ({ input, commands }) => {
+const raise = System.create({}, ({ resources }) => { resources[level] += 1; });
+const nothing = System.create({}, () => {});
+const spawn = System.create({}, ({ commands }, input: { readonly at: number }) => {
     commands.spawn([amount, cell, tagged])({ [amount]: input.at, [cell]: input.at });
 });
-const spawnLabelled = System.create({ name: "observerJoinedTest/spawnLabelled" }, ({ commands }) => { commands.spawn([amount, label])({ [amount]: 4, [label]: blank }); });
-const grow = System.create({ name: "observerJoinedTest/grow", components: { write: [amount] } }, row => { row[amount] += 1; });
-const move = System.create({ name: "observerJoinedTest/move", components: { write: [cell] } }, row => { row[cell] += 10; });
+const spawnLabelled = System.create({}, ({ commands }) => { commands.spawn([amount, label])({ [amount]: 4, [label]: blank }); });
+const grow = System.create({ components: { with: [amount] } }, row => { row[amount] += 1; });
+const move = System.create({ components: { with: [cell] } }, row => { row[cell] += 10; });
 
 /** What the joined thread's observer bodies saw, reset by each test. */
 const seen: { levels: number[]; amounts: number[][]; looked: (number | boolean)[][]; tagged: number[]; labels: string[]; calls: number } = { levels: [], amounts: [], looked: [], tagged: [], labels: [], calls: 0 };
@@ -61,35 +59,47 @@ const reset = (): void => {
 /** The entities the tests look up, by the joined thread's systems. */
 const watched: Entity[] = [];
 
-const watchLevel = System.create({ name: "observerJoinedTest/watchLevel", observer: true, resources: { read: [level], changed: [level] } }, ({ resources }) => {
+const watchLevel = System.create({ observer: true, resources: { changed: [level] } }, ({ resources }) => {
     seen.calls++;
     seen.levels.push(resources[level]);
 });
-const watchAmounts = System.create({ name: "observerJoinedTest/watchAmounts", observer: true, components: { read: [amount], changed: [amount] } }, row => {
+const watchAmounts = System.create({ observer: true, components: { with: [amount], changed: [amount] } }, row => {
     (seen.amounts[seen.amounts.length - 1] ??= []).push(row[amount]);
 });
-const startAmounts = System.create({ name: "observerJoinedTest/startAmounts", observer: true }, () => { seen.amounts.push([]); });
+const startAmounts = System.create({ observer: true }, () => { seen.amounts.push([]); });
 const amountsPass = System.create([startAmounts, watchAmounts]);
-const lookChanged = System.create({ name: "observerJoinedTest/lookChanged", observer: true, lookup: { found: { read: [amount], changed: [amount] } } }, ({ lookup }) => {
+const lookChanged = System.create({ observer: 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({ name: "observerJoinedTest/countTagged", observer: true, lookup: { all: { index: allTagged } } }, ({ lookup }) => {
+const countTagged = System.create({ observer: true, lookup: { all: { index: allTagged } } }, ({ lookup }) => {
     seen.tagged.push(lookup.all().length);
 });
-const inCell = System.create({ name: "observerJoinedTest/inCell", observer: true, lookup: { found: { index: byCell, read: [amount] } } }, ({ lookup }) => {
+const inCell = System.create({ observer: 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({ name: "observerJoinedTest/failing", observer: true, resources: { read: [level] } }, ({ resources }) => {
+const failing = System.create({ observer: true }, ({ resources }) => {
     if (resources[level] > 1) throw new Error("observer joined failure");
 });
-const readLabels = System.create({ name: "observerJoinedTest/readLabels", observer: true, components: { read: [label, amount] } }, row => {
+const readLabels = System.create({ observer: 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 }) =>
+    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 }) => {
+    if (lookup.labelled(Entity.none) === null) throw new Error("observerJoinedTest failure there");
+    return 0;
+});
+
 /** Resolves once `done` holds, between turns of the event loop, which the joined thread's work needs. */
 const settled = async (done: () => boolean): Promise<void> => {
     for (let turn = 0; turn < 2000 && !done(); turn++) await new Promise(resolve => setTimeout(resolve, 0));
@@ -102,16 +112,9 @@ const turns = async (count = 20): Promise<void> => {
 const joined = async (threads: readonly "observerJoinedTest"[] = []): Promise<{ readonly world: CreatedWorld; readonly remote: World; readonly close: () => Promise<void> }> => {
     const world = createWorld({ [workers]: 0 });
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    const remote = join(channel.port2, { threads });
-    for (let turn = 0; turn < 2000; turn++) {
-        let status = "";
-        world.threads(progress => { status = progress.at(-1)?.status ?? ""; })();
-        if (status === "joined") break;
-        await new Promise(resolve => setTimeout(resolve, 0));
-    }
-    // A run's round trip: the thread's claims are made, and it's set up.
-    await remote.run(nothing);
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads });
+    await shared;
     return {
         world, remote,
         close: async () => {
@@ -210,54 +213,49 @@ describe("observer systems on a joined thread", () => {
         await world.run(spawn, { at: 1 });
         await world.run(spawn, { at: 11 });
         // Made in a function, so the build gives them no id.
-        const made = (): readonly [Index<{ readonly key: readonly []; readonly components: { readonly has: readonly [typeof tagged, typeof cell] } }>, Index<{ readonly key: readonly [typeof cell]; readonly sorted: true; readonly components: { readonly has: readonly [typeof amount] } }>] => [
-            Index.create({ name: "observerJoinedTest/madeTagged", key: [], components: { has: [tagged, cell] } }),
-            Index.create({ name: "observerJoinedTest/madeByCell", key: [cell], sorted: true, components: { has: [amount] } }),
+        const made = (): readonly [Index<{ readonly key: readonly []; readonly components: { readonly with: readonly [typeof tagged, typeof cell] } }>, Index<{ readonly key: readonly [typeof cell]; readonly sorted: true; readonly components: { readonly with: readonly [typeof amount] } }>] => [
+            Index.create({ key: [], components: { with: [tagged, cell] } }),
+            Index.create({ key: [cell], sorted: true, components: { with: [amount] } }),
         ];
         const [madeTagged, madeByCell] = made();
-        const sizes = System.create({ name: "observerJoinedTest/sizes", observer: true, lookup: { all: { index: madeTagged, changed: [cell] }, cells: { index: madeByCell, read: [amount] } } }, ({ lookup }) => {
+        const sizes = System.create({ observer: 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 });
             seen.tagged.push(all.length * 1000 + high.length * 100 + (high.at(0)?.[amount] ?? 0));
         });
-        expect(await reportOf(world, await remote.run(sizes))).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
+        await remote.run(sizes);
         await world.run(move);
-        expect(await reportOf(world, await remote.run(sizes))).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
+        await remote.run(sizes);
         // Two tagged; then one cell at 11 or more, holding 11, then both, the first holding 1.
         expect(seen.tagged).toEqual([2111, 2201]);
         expect(seen.looked).toEqual([[true], [true]]);
         await close();
     });
 
-    it("run from the joined thread, resolving once its body ran there, with its failure in a later run's report", async () => {
+    it("run from the joined thread, resolving once its body ran there, and rejecting with what it threw", async () => {
         reset();
         const { world, remote, close } = await joined();
         await world.run(raise);
-        expect(await reportOf(world, await remote.run(watchLevel))).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
+        await remote.run(watchLevel);
         expect(seen.levels).toEqual([1]);
         await world.run(raise);
-        await remote.run(failing);
-        // Its failure reaches the world by message, in time for a later run.
-        let report = await runReported(world, nothing);
-        for (let k = 0; k < 100 && report.failures.length === 0; k++) {
-            await new Promise(resolve => setTimeout(resolve, 1));
-            report = await runReported(world, nothing);
-        }
-        expect(report.failures.map(failure => [failure.kind, failure.message])).toEqual([["system", "observer joined failure"]]);
+        await expect(remote.run(failing)).rejects.toThrow("observer joined failure");
         await close();
     });
 
-    it("report what added ones throw in a later run's report", async () => {
+    it("are reported out of band on the world's thread when added ones throw, once while they keep failing", async () => {
         reset();
+        using reported = catchOutOfBand();
         const { world, remote, close } = await joined();
         remote.add(failing);
         await turns();
         await world.run(raise);
         await world.run(raise);
+        await reported.until(error => error.message.includes("observer joined failure"));
+        await world.run(raise);
         await turns();
-        const report = await runReported(world, nothing);
-        expect(report.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["system", "observerJoinedTest/failing", "observer joined failure"]]);
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "failing" .*failed: observer joined failure$/)]);
         await close();
     });
 
@@ -311,23 +309,41 @@ 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({ name: "observerJoinedTest/madeLabels", observer: true, components: { read: [label, amount] } }, row => {
+        const made = () => System.create({ observer: true, components: { with: [label, amount] } }, row => {
             seen.labels.push(`${row[label].text}${row[amount]}`);
         });
         const madeLabels = made();
-        await expect(world.run(madeLabels)).rejects.toThrow(`System "observerJoinedTest/madeLabels" runs on thread "observerJoinedTest", which a joined thread fills, and has no id, so that thread can't name it`);
-        // Another of that name, numbered.
+        await expect(world.run(madeLabels)).rejects.toThrow(`runs on thread "observerJoinedTest", which a joined thread fills, and has no id, so that thread can't name it`);
+        // Another made there, labeled the same, fails to register when added, reported out of band.
+        using reported = catchOutOfBand();
         const added = made();
         world.add(added);
         await turns();
-        const report = await runReported(world, nothing);
-        expect(report.failures.map(failure => [failure.kind, failure.name])).toEqual([["system", "observerJoinedTest/madeLabels#2"]]);
+        await world.run(nothing);
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "made" failed: .*has no id/)]);
         world.remove(added);
         await turns();
         expect(seen.labels).toEqual([]);
         await close();
     });
 
+    it("run there for the world's run of them, which resolves to what they returned there, or rejects with what they threw", async () => {
+        reset();
+        using reported = catchOutOfBand();
+        const { world, close } = await joined(["observerJoinedTest"]);
+        await world.run(spawnLabelled);
+        watched.length = 0;
+        watched.push(...await Observe.toPromise(Observe.select(world, { required: [amount] })));
+        expect(await world.run(labelsThere)).toEqual(["4"]);
+        await expect(world.run(failsThere)).rejects.toThrow(/^System "failsThere" .*failed: observerJoinedTest failure there$/);
+        // One holding rows ran there before its run resolved.
+        await world.run(readLabels);
+        expect(seen.labels).toEqual(["4"]);
+        await turns();
+        expect(reported.errors).toEqual([]);
+        await close();
+    });
+
     it("run on the joined thread filling their objects when the world runs them, then here once it's gone", async () => {
         reset();
         const { world, remote } = await joined(["observerJoinedTest"]);

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

@@ -1,37 +1,37 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Index } from "../../interface/indexes/index-type.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
 import { gpuDevice } from "../../interface/resources/gpu-device.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { F32 } from "../../interface/math/index.js";
+import { gpu } from "./gpu.test-helper.js";
 
 const heat = Symbol("observerGpuTest/heat");
 const rate = Symbol("observerGpuTest/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 } });
 
-const spawn = System.create({ name: "observerGpuTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     for (let i = 0; i < 100; i++) commands.spawn([heat, rate])({ [heat]: i, [rate]: 1 });
 });
-const warm = System.create({ name: "observerGpuTest/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;
 });
 
 let total = 0;
-const sum = System.create({ name: "observerGpuTest/sum", observer: true, components: { read: [heat] } }, row => { total += row[heat]; });
+const sum = System.create({ observer: true, components: { with: [heat] } }, row => { total += row[heat]; });
 
-const byHeat = Index.create({ name: "observerGpuTest/byHeat", key: [heat], sorted: true });
+const byHeat = Index.create({ key: [heat], sorted: true });
 let hot = 0;
-const countHot = System.create({ name: "observerGpuTest/countHot", observer: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
+const countHot = System.create({ observer: true, lookup: { hot: { index: byHeat } } }, ({ lookup }) => {
     hot = lookup.hot({ ">=": 150 }).length;
 });
 
@@ -42,7 +42,7 @@ const device = async (): Promise<GPUDevice> => {
 };
 
 describe("observer systems over GPU kernels' writes", () => {
-    it("read what a GPU kernel wrote in the run, read back for them", async () => {
+    it.runIf(gpu)("read what a GPU kernel wrote in the run, read back for them", async () => {
         const world = createWorld({ [workers]: 0, [gpuDevice]: await device() });
         await world.run(spawn);
         world.add(sum);
@@ -55,7 +55,7 @@ describe("observer systems over GPU kernels' writes", () => {
         await world.dispose();
     });
 
-    it("look up through indexes kept by what a GPU kernel wrote in the run, read back before they're refreshed", async () => {
+    it.runIf(gpu)("look up through indexes kept by what a GPU kernel wrote in the run, read back before they're refreshed", async () => {
         const world = createWorld({ [workers]: 0, [gpuDevice]: await device() });
         await world.run(spawn);
         world.add(countHot);
@@ -66,7 +66,7 @@ describe("observer systems over GPU kernels' writes", () => {
         await world.dispose();
     });
 
-    it("look up on a joined thread through indexes kept by what a GPU kernel wrote in the run, read back before they're refreshed", async () => {
+    it.runIf(gpu)("look up on a joined thread through indexes kept by what a GPU kernel wrote in the run, read back before they're refreshed", async () => {
         const fixture = await import("./observer-joined.fixture.js");
         expect(await fixture.gpuLookups(await device())).toEqual([50, 100]);
     });