@adobe/ecs 0.1.0 → 0.2.1

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

@@ -1,7 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it, vi } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import type { 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 { Observe } from "../../observe/index.js";
@@ -9,7 +8,7 @@ import type { World } from "../../interface/world/world.js";
 import { createWorld, join, type CreatedWorld } from "./create.js";
 import { tablesOf } from "./join.js";
 import { settle } from "./observe.test-helper.js";
-import { runReported } from "./reports.test-helper.js";
+import { catchOutOfBand } from "./outcomes.test-helper.js";
 
 // How the internal factories of `src/observe` run: systems shared by shape, first values batched or given at once, warm
 // reads, and what they hold released once idle.
@@ -26,22 +25,19 @@ declare module "@adobe/ecs" {
         [level]: { type: number };
     }
 }
-Component.register(amount, { type: { type: "number" } });
-Component.register(other, { type: { type: "number" } });
-Resource.register(level, { type: { type: "number", default: 0 } });
 
 let spawned: Entity[] = [];
-const seed = System.create({ name: "observeFactoriesTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     spawned = [];
     for (let i = 0; i < input.count; i++) spawned.push(commands.spawn([amount])({ [amount]: i }));
 });
-const grow = System.create({ name: "observeFactoriesTest/grow", components: { write: [amount] } }, row => { row[amount] += 1; });
-const raise = System.create({ name: "observeFactoriesTest/raise", resources: { write: [level] } }, ({ resources }) => { resources[level] += 1; });
-const nothing = System.create({ name: "observeFactoriesTest/nothing" }, () => {});
+const grow = System.create({ components: { with: [amount] } }, row => { row[amount] += 1; });
+const raise = System.create({}, ({ resources }) => { resources[level] += 1; });
+const nothing = System.create({}, () => {});
 
 /** Counts passes: the observer passes after each run's sync point. */
 const passes = { count: 0 };
-const counter = System.create({ name: "observeFactoriesTest/counter", observer: true }, () => { passes.count++; });
+const counter = System.create({ observer: true }, () => { passes.count++; });
 
 /**
  * A world of `count` entities, each amount its index and one more, at level 1: the runs below registered, so runners
@@ -119,7 +115,7 @@ describe("observer factories", () => {
         const stop = Observe.entity(world, spawned[0], { required: [amount] })(value => entities.push(value?.[amount]));
         await settle(world);
         await world.run(grow);
-        await world.run(System.create({ name: "observeFactoriesTest/growOthers", components: { write: [amount] } }, row => {
+        await world.run(System.create({ components: { with: [amount] } }, row => {
             if (row.entity !== spawned[0]) row[amount] += 1;
         }));
         expect(entities).toEqual([4, 5]);
@@ -174,7 +170,7 @@ describe("observer factories", () => {
 
     it("read only what they list, so a write elsewhere notifies nothing", async () => {
         await using world = await seeded(3);
-        const writeOther = System.create({ name: "observeFactoriesTest/writeOther", components: { write: [other] } }, row => { row[other] = 1; });
+        const writeOther = System.create({ components: { with: [other] } }, row => { row[other] = 1; });
         let notified = 0;
         Observe.entity(world, spawned[0], { required: [amount] })(() => notified++);
         Observe.select(world, { required: [amount], order: { [amount]: false }, page: { offset: 0, limit: 2 } })(() => notified++);
@@ -186,8 +182,9 @@ describe("observer factories", () => {
     });
 
     it("rethrow only their own systems' failures from their runs, not those of observer systems the world added", async () => {
+        using reported = catchOutOfBand();
         await using world = await seeded(3);
-        const failing = System.create({ name: "observeFactoriesTest/failing", observer: true }, () => { throw new Error("added failed"); });
+        const failing = System.create({ observer: true }, () => { throw new Error("added failed"); });
         world.add(failing);
         const caught: unknown[] = [];
         const original = globalThis.queueMicrotask;
@@ -209,8 +206,9 @@ describe("observer factories", () => {
             vi.restoreAllMocks();
         }
         expect(caught).toEqual([]);
-        // The world's runs still report it.
-        expect((await runReported(world, nothing)).failures.map(failure => failure.name)).toEqual(["observeFactoriesTest/failing"]);
+        // The world reports it out of band, once.
+        await world.run(nothing);
+        expect(reported.messages()).toEqual([`System "failing" failed: added failed`]);
     });
 });
 
@@ -218,9 +216,9 @@ describe("observer factories", () => {
 const seededJoined = async (count: number): Promise<{ readonly world: CreatedWorld; readonly remote: World; readonly close: () => Promise<void> }> => {
     const world = await seeded(count);
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    const remote = join(channel.port2, { threads: [] });
-    await remote.run(nothing);
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads: [] });
+    await shared;
     return {
         world, remote,
         close: async () => {

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

@@ -1,13 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { 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 type { World } from "../../interface/world/world.js";
 import { createWorld, join, type CreatedWorld } from "./create.js";
 import { Observe } from "../../observe/index.js";
-import { reportOf } from "./reports.test-helper.js";
+import { catchOutOfBand } from "./outcomes.test-helper.js";
 
 // The observer factories of `src/observe` on a joined thread's world, with the world and the thread on this one,
 // joined through a MessageChannel. Each case waits for the value it expects, so it holds whenever values come.
@@ -30,46 +29,41 @@ declare module "@adobe/ecs" {
         [label]: { type: string };
         [marked]: { type: true };
         [place]: { type: number };
-        [caption]: { type: { readonly text: string } | null; thread: "observeJoinedTest" };
+        [caption]: { type: Caption; thread: "observeJoinedTest" };
         [widget]: { type: { readonly draw: () => string } | null; thread: "observeJoinedTest" };
         [kept]: { type: string };
     }
     export interface Resources {
         [total]: { type: number };
-        [names]: { type: readonly string[] };
+        [names]: { type: readonly string[]; default: [] };
     }
 }
-Component.register(point, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
-Component.register(label, { type: { type: "string" } });
-Component.register(marked, { type: { const: true } });
-Component.register(place, { type: { type: "number" } });
 /** The caption's start, which a command here gives it by this value. */
-const none = { text: "none" };
-Component.register(caption, { type: { anyOf: [{ type: "object", properties: { text: { type: "string" } } }, { type: "null" }], default: none }, thread: "observeJoinedTest" });
-Component.register(widget, { thread: "observeJoinedTest" });
-Component.register(kept, { type: { type: "string" } });
-Resource.register(total, { type: { type: "number", default: 0 } });
-Resource.register(names, { type: { type: "array", items: { type: "string" }, default: [] } });
+const none = { text: "none" } as const;
+/** A caption, which starts as `none`, the value commands on other threads give it by identity. */
+type Caption = { readonly text: string } | null;
+const Caption = { default: none };
 
-const add = System.create({ name: "observeJoinedTest/add", input: { type: "object", properties: { amount: { type: "number" } } }, resources: { write: [total] } }, ({ input, resources }) => {
+const add = System.create({}, ({ resources }, input: { readonly amount: number }) => {
     resources[total] = resources[total] * 10 + input.amount;
 });
-const spawn = System.create({ name: "observeJoinedTest/spawn", input: { type: "object", properties: { x: { type: "number" } } } }, ({ input, commands }) => {
+const spawn = System.create({}, ({ commands }, input: { readonly x: number }) => {
     commands.spawn([point, label, marked])({ [point]: [input.x, -input.x], [label]: `p${input.x}` });
 });
-const spawnPlaced = System.create({ name: "observeJoinedTest/spawnPlaced", input: { type: "object", properties: { x: { type: "number" } } } }, ({ input, commands }) => {
+const spawnPlaced = System.create({}, ({ commands }, input: { readonly x: number }) => {
     commands.spawn([place, caption, widget, kept])({ [place]: input.x, [widget]: null, [kept]: `k${input.x}` });
 });
-const nullCaptions = System.create({ name: "observeJoinedTest/nullCaptions", components: { has: [caption, place] } }, (row, { commands }) => { commands.add(row.entity, caption, null); });
-const restartCaptions = System.create({ name: "observeJoinedTest/restartCaptions", components: { has: [caption, place] } }, (row, { commands }) => { commands.add(row.entity, caption, none); });
-const dropCaptions = System.create({ name: "observeJoinedTest/dropCaptions", components: { has: [caption] } }, (row, { commands }) => { commands.remove(row.entity, caption); });
+const nullCaptions = System.create({ components: { with: [caption, place] } }, (row, { commands }) => { commands.add(row.entity, caption, null); });
+const restartCaptions = System.create({ components: { with: [caption, place] } }, (row, { commands }) => { commands.add(row.entity, caption, none); });
+const dropCaptions = System.create({ components: { with: [caption] } }, (row, { commands }) => { commands.remove(row.entity, caption); });
 
-/** A world shared with a thread joined through a channel claiming `threads`, and the joined world. */
-const joined = (threads: readonly "observeJoinedTest"[] = []): { readonly world: CreatedWorld; readonly remote: World } => {
+/** A world shared with a thread joined through a channel claiming `threads`, and the joined world, once it joined. */
+const joined = async (threads: readonly "observeJoinedTest"[] = []): Promise<{ readonly world: CreatedWorld; readonly remote: World }> => {
     const world = createWorld({ [workers]: 0 });
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    const remote = join(channel.port2, { threads });
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads });
+    await shared;
     return { world, remote };
 };
 
@@ -107,9 +101,6 @@ const catching = async (run: () => Promise<void>): Promise<unknown[]> => {
     return caught;
 };
 
-/** Once the thread shared last is joined, its claims made. */
-const joinedStatus = (world: CreatedWorld) => until(world.threads, threads => threads.at(-1)?.status === "joined");
-
 /** The entity a run of `spawnPlaced` spawned. */
 const spawnOne = async (world: World, x: number): Promise<Entity> => {
     await world.run(spawnPlaced, { x });
@@ -119,7 +110,7 @@ const spawnOne = async (world: World, x: number): Promise<Entity> => {
 
 describe("observer factories on a joined thread", () => {
     it("read the strings the world's thread writes, which live in shared memory", async () => {
-        const { world, remote } = joined();
+        const { world, remote } = await joined();
         await world.run(spawn, { x: 3 });
         const [entity] = await until(Observe.select(remote, { required: [point], where: { [point]: [3, -3] } }), entities => entities.length === 1);
         expect(await until(Observe.entity(remote, entity, { required: [label] }), value => value !== null)).toEqual({ [label]: "p3" });
@@ -127,7 +118,7 @@ describe("observer factories on a joined thread", () => {
         await world.dispose();
     });
     it("give values of resources, entities, select and count, then each newer one", async () => {
-        const { world, remote } = joined();
+        const { world, remote } = await joined();
         const first: unknown[] = [];
         const stop = Observe.resource(remote, total)(value => first.push(value));
         // Never during the subscribing call: the thread holds nothing yet.
@@ -147,7 +138,7 @@ describe("observer factories on a joined thread", () => {
     });
 
     it("stop notifying once stopped", async () => {
-        const { world, remote } = joined();
+        const { world, remote } = await joined();
         const seen: number[] = [];
         const stop = Observe.resource(remote, total)(value => seen.push(value));
         await until(Observe.resource(remote, total), value => value === 0);
@@ -160,7 +151,7 @@ describe("observer factories on a joined thread", () => {
     });
 
     it("give one that fell behind the newest value", async () => {
-        const { world, remote } = joined();
+        const { world, remote } = await joined();
         const seen: number[] = [];
         Observe.resource(remote, total)(value => seen.push(value));
         await until(Observe.resource(remote, total), value => value === 0);
@@ -174,7 +165,7 @@ describe("observer factories on a joined thread", () => {
     });
 
     it("throw for one that reads objects of the world's thread, or looks up by its keys of strings", async () => {
-        const { world, remote } = joined();
+        const { world, remote } = await joined();
         const ignore = (): void => {};
         // The factories make nothing until subscribed, so they throw when subscribed.
         const made = <T>(make: () => (notify: (value: T) => void) => () => void) => () => make()(ignore);
@@ -187,8 +178,7 @@ describe("observer factories on a joined thread", () => {
     });
 
     it("read the objects of the threads the thread fills, at their starts or null as the world's commands give them", async () => {
-        const { world, remote } = joined(["observeJoinedTest"]);
-        await joinedStatus(world);
+        const { world, remote } = await joined(["observeJoinedTest"]);
         const entity = await spawnOne(world, 1);
         const listed = Observe.entity(remote, entity, { required: [place, caption], optional: [widget] });
         expect(await until(listed, value => value !== null)).toEqual({ [place]: 1, [caption]: none, [widget]: null });
@@ -204,26 +194,25 @@ describe("observer factories on a joined thread", () => {
     });
 
     it("fail on the world's thread for one that reads objects a joined thread fills", async () => {
-        const { world, remote } = joined(["observeJoinedTest"]);
-        await joinedStatus(world);
+        const { world, remote } = await joined(["observeJoinedTest"]);
         const entity = await spawnOne(world, 3);
         const values: unknown[] = [];
         const observe = (): void => {
             Observe.entity(world, entity, { required: [caption] })(value => values.push(value));
             Observe.select(world, { required: [place, caption], where: { [caption]: none } })(() => {});
         };
-        const reported: string[] = [];
+        using outOfBand = catchOutOfBand();
         const caught = await catching(async () => {
             observe();
-            const runs: number[] = [];
-            for (let k = 4; k < 6; k++) runs.push(await world.run(spawnPlaced, { x: k }));
+            for (let k = 4; k < 6; k++) await world.run(spawnPlaced, { x: k });
             await new Promise(resolve => setTimeout(resolve, 10));
-            for (const run of runs) for (const failure of (await reportOf(world, run)).failures) reported.push(failure.message);
         });
-        // The entity observer's system, added, fails in a run's report; the selection's scan, run, rejects, rethrown.
-        expect([...reported, ...caught.map(String)]).toEqual([
-            expect.stringMatching(/^System "Observe\.entity\(observeJoinedTest\/caption\).*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
-            expect.stringMatching(/System "Observe\.select\(observeJoinedTest\/place, observeJoinedTest\/caption\).*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
+        // The observers' systems, added, fail to register, which the world reports out of band; the selection's scan,
+        // run, rejects, which the factories rethrow.
+        expect([...outOfBand.messages(), ...caught.map(String)]).toEqual([
+            expect.stringMatching(/^System "Observe\.entity\(observeJoinedTest\/caption\)" failed: .*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
+            expect.stringMatching(/^System "Observe\.select\(observeJoinedTest\/place, observeJoinedTest\/caption\)" failed: .*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
+            expect.stringMatching(/^Error: System "Observe\.select\(observeJoinedTest\/place, observeJoinedTest\/caption\).*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
         ]);
         expect(values).toEqual([]);
         await remote.dispose();

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

@@ -1,9 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component, Resource, System, always, cadence, clock, wake, workers } from "../../index.js";
+import { always, cadence, clock, type F32, System, wake, workers } from "../../index.js";
 import type { World } from "../../interface/world/world.js";
 import { createWorld } from "./create.js";
 import { Observe } from "../../observe/index.js";
-import { followReports, reportOf, runReported } from "./reports.test-helper.js";
+import { catchOutOfBand, followTicks } from "./outcomes.test-helper.js";
 
 // Ticks and tick stamps, read through the observer factories of `src/observe`.
 
@@ -15,52 +16,47 @@ const flag = Symbol("observeTicksCasesTest/flag");
 declare module "@adobe/ecs" {
     interface Resources {
         [frames]: { type: number };
-        [seen]: { type: number };
+        [seen]: { type: number; default: -1 };
     }
     interface Components {
-        [value]: { type: number };
-        [watched]: { type: number };
+        [value]: { type: F32 };
+        [watched]: { type: F32 };
         [flag]: { type: true };
     }
 }
-Resource.register(frames, { type: { type: "number", default: 0 } });
-Resource.register(seen, { type: { type: "number", default: -1 } });
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(watched, { type: { type: "number", precision: 1 } });
-Component.register(flag, { type: { const: true } });
-
-const count = System.create({ name: "observeTicksCasesTest/count", resources: { write: [frames] } }, ({ resources }) => { resources[frames] += 1; });
-const watch = System.create({ name: "observeTicksCasesTest/watch", resources: { read: [clock], write: [seen] } }, ({ resources }) => { resources[seen] = resources[clock].tick; });
-const fail = System.create({ name: "observeTicksCasesTest/fail" }, () => { throw new Error("tick failed"); });
-const nothing = System.create({ name: "observeTicksCasesTest/nothing" }, () => {});
-const idle = System.create({ name: "observeTicksCasesTest/idle", observer: true }, () => {});
-const fast = System.create({ name: "observeTicksCasesTest/fast", resources: { write: [cadence, always] } }, ({ resources }) => {
+
+const count = System.create({}, ({ resources }) => { resources[frames] += 1; });
+const watch = System.create({}, ({ resources }) => { resources[seen] = resources[clock].tick; });
+const fail = System.create({}, () => { throw new Error("tick failed"); });
+const nothing = System.create({}, () => {});
+const idle = System.create({ observer: true }, () => {});
+const fast = System.create({}, ({ resources }) => {
     resources[cadence] = { kind: "fixed", step: 1 };
     resources[always] = true;
 });
-const calm = System.create({ name: "observeTicksCasesTest/calm", resources: { write: [always] } }, ({ resources }) => { resources[always] = false; });
-const later = System.create({ name: "observeTicksCasesTest/later", resources: { read: [clock] }, reduce: { [wake]: "min" } }, ({ resources, reduce }) => {
+const calm = System.create({}, ({ resources }) => { resources[always] = false; });
+const later = System.create({}, ({ resources, reduce }) => {
     if (resources[clock].tick === 0) reduce[wake](resources[clock].now + 20);
 });
 
-const seed = System.create({ name: "observeTicksCasesTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let i = 0; i < 3000; i++) commands.spawn([value, watched])({ [value]: i, [watched]: 0 });
 });
 /** Writes every value: until something observes `value`, its stamps are muted. */
-const bump = System.create({ name: "observeTicksCasesTest/bump", kernel: "cpu", components: { write: [value] } }, row => {
+const bump = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] + 1;
 });
-const watchChanged = System.create({ name: "observeTicksCasesTest/watchChanged", kernel: "cpu", components: { write: [watched], changed: [value] }, after: [bump] }, row => {
+const watchChanged = System.create({ kernel: true, components: { with: [watched], changed: [value] }, after: [bump] }, row => {
     row[watched] = row[watched] + 1;
 });
 /** Counts rows whose `value` was added since it last ran. */
-const fresh = System.create({ name: "observeTicksCasesTest/fresh", components: { write: [watched], added: [value] } }, row => {
+const fresh = System.create({ components: { with: [watched], added: [value] } }, row => {
     row[watched] = row[watched] + 1;
 });
-const flagAll = System.create({ name: "observeTicksCasesTest/flagAll", components: { has: [value] } }, (row, { commands }) => {
+const flagAll = System.create({ components: { with: [value] } }, (row, { commands }) => {
     commands.add(row.entity, flag, true);
 });
-const spawnOne = System.create({ name: "observeTicksCasesTest/spawnOne" }, ({ commands }) => {
+const spawnOne = System.create({}, ({ commands }) => {
     commands.spawn([value, watched])({ [value]: -1, [watched]: 0 });
 });
 
@@ -139,18 +135,21 @@ describe("ticks", () => {
         expect(await toPromise(resource(world, frames))).toBe(2);
     });
 
-    it("spawn a failing tick's report", async () => {
+    it("report a failing tick's system out of band", async () => {
+        using reported = catchOutOfBand();
         await using world = createWorld({ [workers]: 0 });
-        const reports = followReports(world);
+        const ticks = followTicks(world);
         world.add(fail);
         await world.run(nothing);
-        const last = await reports.until(next => next.failures.length > 0);
-        expect(last.failures.map(({ kind, name, message }) => [kind, name, message])).toEqual([["system", "observeTicksCasesTest/fail", "tick failed"]]);
+        const last = await ticks.until(next => next.failures.length > 0);
+        expect(last.failures.map(({ kind, name, message }) => [kind, name, message])).toEqual([["system", "fail", "tick failed"]]);
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "fail" .*failed: tick failed$/)]);
+        ticks.stop();
     });
 
-    it("put what an observer throws on a tick's values in a later run's report, once", async () => {
+    it("report what an observer throws on a tick's values out of band, once", async () => {
+        using reported = catchOutOfBand();
         await using world = createWorld({ [workers]: 0 });
-        const reports = followReports(world);
         world.add(count);
         let counts = 0;
         const stopFrames = resource(world, frames)(() => {
@@ -158,12 +157,11 @@ describe("ticks", () => {
         });
         await world.run(nothing);
         await until(resource(world, frames), next => next === 1);
-        // A run of observer systems alone, which ticks nothing, so its report holds what the tick's pass threw.
         await world.run(idle);
-        const thrown = await reports.until(report => report.failures.length > 0);
-        expect(thrown.failures.map(({ kind, message }) => [kind, message])).toEqual([["system", "frames observer failed"]]);
+        const thrown = await reported.until(error => error.message.includes("frames observer failed"));
+        expect(thrown.message).toMatch(/^System "Observe\.resource\(observeTicksCasesTest\/frames\)" failed: frames observer failed$/);
         await world.run(idle);
-        expect(reports.seen.filter(report => report.failures.length > 0)).toHaveLength(1);
+        expect(reported.errors).toHaveLength(1);
         stopFrames();
     });
 

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

@@ -1,7 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
 
-const settled = System.create({ name: "observeTest/settled", observer: true }, () => {});
+const settled = System.create({ observer: true }, () => {});
 
 /**
  * Resolves once every observer factory subscribed before it had its first value: after the factories' flush, which the

package/src/implementation/world/observed-workers.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 "./observed-workers.fixture.js";
 

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

@@ -1,8 +1,9 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../../interface/system/system.js";
 import { readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { F32 } from "../../interface/math/index.js";
 
 /** Scenarios of tick stamps on workers, run built in node and from source in chromium. */
 
@@ -11,24 +12,22 @@ const seen = Symbol("observedWorkersTest/seen");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
-        [seen]: { type: number };
+        [value]: { type: F32 };
+        [seen]: { type: F32 };
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(seen, { type: { type: "number", precision: 1 } });
 
-const seed = System.create({ name: "observedWorkersTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let i = 0; i < 3000; i++) commands.spawn([value, seen])({ [value]: i, [seen]: 0 });
 });
 
 /** Writes every value: until something observes `value`, its stamps are muted. */
-const bump = System.create({ name: "observedWorkersTest/bump", kernel: "cpu", components: { write: [value] } }, row => {
+const bump = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] + 1;
 });
 
-const watch = System.create({ name: "observedWorkersTest/watch", kernel: "cpu", components: { write: [seen], changed: [value] }, after: [bump] }, row => {
+const watch = System.create({ kernel: true, components: { with: [seen], changed: [value] }, after: [bump] }, row => {
     row[seen] = row[seen] + 1;
 });
 

package/src/implementation/world/observer-contained-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 { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
@@ -23,12 +24,12 @@ export type FromContainedWorker =
 
 const channel = scopeChannel<FromContainedWorker, ToContainedWorker>();
 let remote: World | null = null;
-const placed = System.create({ name: "observerContainedTest/placed", observer: true }, () => {});
+const placed = System.create({ observer: true }, () => {});
 
-channel.onMessage(message => {
+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-contained.browser.test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { observerContainedCases } from "./observer-contained.cases.js";
 
 // A real worker in chromium, over the fixture's source.

package/src/implementation/world/observer-contained.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-contained.fixture.js";
 

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { workers } from "../../interface/resources/workers.js";
 import { createWorld, type CreatedWorld } from "./create.js";
@@ -45,15 +46,10 @@ const later = (milliseconds = 0): Promise<void> => new Promise(resolve => setTim
 
 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]);
-    for (let turn = 0; turn < 2000; turn++) {
-        let status = "";
-        world.threads(progress => { status = progress.at(-1)?.status ?? ""; })();
-        if (status === "joined") break;
-        await later();
-    }
+    await shared;
     return worker;
 };
 

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

@@ -1,5 +1,6 @@
-import { Resource } from "../../interface/resource/resource.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../../interface/system/system.js";
+import type { Schema } from "../../interface/schema/schema.js";
 
 // Keys and systems both threads of the observer-contained fixtures import: a counter the world bumps, and an observer
 // system reading only resources that a joined thread adds, which can hold its run until the world's thread releases it.
@@ -8,13 +9,11 @@ export const tally = Symbol("observerContainedTest/tally");
 export const holding = Symbol("observerContainedTest/holding");
 declare module "@adobe/ecs" {
     export interface Resources {
-        [tally]: { type: number };
+        [tally]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
         [holding]: { type: number };
     }
 }
-Resource.register(tally, { type: { type: "integer", default: 0 } });
 /** While negative, each run of the watcher says it reached its value and waits until the world's thread releases it. */
-Resource.register(holding, { type: { type: "number", default: 0 } });
 
 /** Shared words: the value a held run reached, and the value the world's thread released runs through. */
 export const reachedWord = 0;
@@ -26,14 +25,14 @@ export const gate: { words: Int32Array | null } = { words: null };
 /** What the watcher's runs saw, in order. */
 export const tallies: number[] = [];
 
-export const bump = System.create({ name: "observerContainedTest/bump", resources: { write: [tally] } }, ({ resources }) => { resources[tally] += 1; });
-export const nothing = System.create({ name: "observerContainedTest/nothing" }, () => {});
-export const setHolding = System.create({ name: "observerContainedTest/setHolding", input: { type: "object", properties: { holding: { type: "number" } } }, resources: { write: [holding] } }, ({ input, resources }) => {
+export const bump = System.create({}, ({ resources }) => { resources[tally] += 1; });
+export const nothing = System.create({}, () => {});
+export const setHolding = System.create({}, ({ resources }, input: { readonly holding: number }) => {
     resources[holding] = input.holding;
 });
 
 /** After each sync point that changed the tally: notes it, and, while `holding` says so, waits there to be released. */
-export const watchTally = System.create({ name: "observerContainedTest/watchTally", observer: true, resources: { read: [tally, holding], changed: [tally] } }, ({ resources }) => {
+export const watchTally = System.create({ observer: true, resources: { changed: [tally] } }, ({ resources }) => {
     const value = resources[tally];
     tallies.push(value);
     const { words } = gate;