@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/world/thread-systems.test-helper.ts

@@ -1,10 +1,10 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Entity } from "../../interface/entity/entity.js";
 import { Observe } from "../../observe/index.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
-import { runReported, type Reported } from "./reports.test-helper.js";
+import { runReported, type Reported } from "./outcomes.test-helper.js";
+import type { Schema } from "../../interface/schema/schema.js";
 
 // Keys and systems both threads of the thread systems fixtures import: systems on thread "threadSystemsTest", which a
 // joined thread fills, beside systems on the world's thread, and what each world holds after the same runs.
@@ -27,46 +27,33 @@ declare module "@adobe/ecs" {
         threadSystemsTest: true;
     }
     export interface Components {
-        [uid]: { type: number };
+        [uid]: { type: Schema.Type<{ type: "integer" }> };
         [position]: { type: readonly [number, number] };
         [velocity]: { type: number };
         [flagged]: { type: true };
-        [caption]: { type: { readonly text: string } | null; thread: "threadSystemsTest" };
+        [caption]: { type: { readonly text: string } | null; thread: "threadSystemsTest"; default: { text: "none" } };
         [note]: { type: Note | null; thread: "threadSystemsTest" };
         [kept]: { type: string };
     }
     export interface Resources {
         [total]: { type: number; reduce: "+" };
-        [changes]: { type: number };
-        [paint]: { type: { readonly text: string }; thread: "threadSystemsTest" };
-        [painted]: { type: number };
-        [enabled]: { type: boolean };
-        [nextUid]: { type: number };
+        [changes]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
+        [paint]: { type: { readonly text: string }; thread: "threadSystemsTest"; default: { text: "plain" } };
+        [painted]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
+        [enabled]: { type: boolean; default: true };
+        [nextUid]: { type: Schema.Type<{ type: "integer" }>; default: 1 };
     }
 }
 /** A value that isn't data, which only its thread holds. */
 type Note = { readonly text: string; readonly read: () => string };
-Component.register(uid, { type: { type: "integer" } });
-Component.register(position, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
-Component.register(velocity, { type: { type: "number" } });
-Component.register(flagged, { type: { const: true } });
 const text = { type: "object", properties: { text: { type: "string" } } } as const;
-Component.register(caption, { type: { anyOf: [text, { type: "null" }], default: { text: "none" } }, thread: "threadSystemsTest" });
-Component.register(note, { thread: "threadSystemsTest" });
 /** An object of the world's thread. */
-Component.register(kept, { type: { type: "string" } });
-Resource.register(total, { type: { type: "number", default: 0 }, reduce: "+" });
-Resource.register(changes, { type: { type: "integer", default: 0 } });
 /** An object resource of the thread, which only systems there read and write. */
-Resource.register(paint, { type: { ...text, default: { text: "plain" } }, thread: "threadSystemsTest" });
-Resource.register(painted, { type: { type: "integer", default: 0 } });
-Resource.register(enabled, { type: { type: "boolean", default: true } });
-Resource.register(nextUid, { type: { type: "integer", default: 1 } });
 
 const makeNote = (text: string): Note => ({ text, read: () => text });
 
 /** Spawns from the world's thread: structs and its own object, the thread's objects at their starts. */
-export const seed = System.create({ name: "threadSystemsTest/seed", input: { type: "object", properties: { count: { type: "integer" } } }, resources: { write: [nextUid] } }, ({ input, resources, commands }) => {
+export const seed = System.create({}, ({ resources, commands }, input: { readonly count: number }) => {
     for (let k = 0; k < input.count; k++) {
         const id = resources[nextUid]++;
         commands.spawn([uid, position, velocity, caption, kept])({ [uid]: id, [position]: [id, -id], [velocity]: id % 3, [kept]: `k${id}` });
@@ -74,18 +61,18 @@ export const seed = System.create({ name: "threadSystemsTest/seed", input: { typ
 });
 
 /** On the world's thread: positions move by their velocity. */
-export const move = System.create({ name: "threadSystemsTest/move", components: { read: [velocity], write: [position] } }, row => {
+export const move = System.create({ components: { with: [velocity, position] } }, row => {
     const [x, y] = row[position];
     row[position] = [x + row[velocity], y - row[velocity]];
 });
 
 /** On the thread: captions written in place, from the structs it reads. */
-export const describe = System.create({ name: "threadSystemsTest/describe", components: { read: [position, velocity], write: [caption] }, after: [move] }, row => {
+export const describe = System.create({ components: { with: [position, velocity, caption] }, after: [move] }, row => {
     if (row[velocity] !== 0) row[caption] = { text: `at ${row[position][0]}` };
 });
 
 /** On the thread: commands giving its objects values it stages, struct values and tags, and despawns. */
-export const relabel = System.create({ name: "threadSystemsTest/relabel", components: { read: [uid, caption, position], has: [velocity] }, after: [describe] }, (row, { commands }) => {
+export const relabel = System.create({ components: { with: [uid, caption, position, velocity] }, after: [describe] }, (row, { commands }) => {
     const id = row[uid];
     if (row[position][0] > 40) {
         commands.despawn(row.entity);
@@ -98,58 +85,58 @@ export const relabel = System.create({ name: "threadSystemsTest/relabel", compon
 });
 
 /** On the thread, reading its object resource: spawns giving its objects values, with a struct resource's next uid. */
-export const breed = System.create({ name: "threadSystemsTest/breed", resources: { read: [paint], write: [nextUid] }, after: [relabel] }, ({ resources, commands }) => {
+export const breed = System.create({ after: [relabel] }, ({ resources, commands }) => {
     const id = resources[nextUid]++;
     commands.spawn([uid, position, velocity, caption, note])({ [uid]: id, [position]: [0, id], [velocity]: 1, [caption]: { text: `${resources[paint].text} ${id}` }, [note]: makeNote(`bred ${id}`) });
 });
 
 /** On the thread: a reduction over its objects and structs. */
-export const tally = System.create({ name: "threadSystemsTest/tally", components: { read: [caption, position] }, reduce: { [total]: "+" }, after: [breed] }, (row, { reduce }) => {
+export const tally = System.create({ components: { with: [caption, position] }, after: [breed] }, (row, { reduce }) => {
     reduce[total]((row[caption]?.text.length ?? 0) + row[position][1]);
 });
 
 /** On the thread: a change filter on its own objects, writing a struct resource. */
-export const watchCaptions = System.create({ name: "threadSystemsTest/watchCaptions", components: { changed: [caption] }, resources: { write: [changes] }, after: [tally] }, (_row, { resources }) => {
+export const watchCaptions = System.create({ components: { changed: [caption] }, after: [tally] }, (_row, { resources }) => {
     resources[changes] += 1;
 });
 
 /** On the thread, while `enabled` holds: writes its object resource, and a struct resource from it. */
-export const repaint = System.create({ name: "threadSystemsTest/repaint", resources: { write: [paint, painted], is: [enabled] }, after: [watchCaptions] }, ({ resources }) => {
+export const repaint = System.create({ resources: { is: [enabled] }, after: [watchCaptions] }, ({ resources }) => {
     resources[paint] = { text: `${resources[paint].text}+` };
     resources[painted] = resources[paint].text.length;
 });
 
 /** On the thread: a lookup reading an entity's structs and this thread's objects. */
-export const peek = System.create({ name: "threadSystemsTest/peek", components: { has: [uid, note] }, lookup: { self: { read: [position, caption] } }, after: [repaint] }, (row, { lookup, commands }) => {
+export const peek = System.create({ components: { with: [uid, note] }, lookup: { self: { with: [position, caption] } }, after: [repaint] }, (row, { lookup, commands }) => {
     const self = lookup.self(row.entity);
     if (self !== null && ((self[caption]?.text.length ?? 0) + self[position][1]) % 2 === 1) commands.add(row.entity, flagged);
 });
 
 /** On the world's thread, beside `tally`: a world object from the structs. */
-export const keep = System.create({ name: "threadSystemsTest/keep", components: { read: [uid], write: [kept], added: [kept] }, after: [breed], before: [watchCaptions] }, row => {
+export const keep = System.create({ components: { with: [uid, kept], added: [kept] }, after: [breed], before: [watchCaptions] }, row => {
     row[kept] = `${row[kept]}.${row[uid] % 10}`;
 });
 
 /** On the thread, failing after its commands: later tiers are skipped, and its commands still apply. */
-export const fail = System.create({ name: "threadSystemsTest/fail", components: { read: [uid, caption] } }, (row, { commands }) => {
+export const fail = System.create({ components: { with: [uid, caption] } }, (row, { commands }) => {
     commands.add(row.entity, flagged);
     if (row[uid] === 3 && row[caption] !== undefined) throw new Error("threadSystemsTest failure");
 });
-export const afterFail = System.create({ name: "threadSystemsTest/afterFail", components: { read: [caption] }, after: [fail] }, (row, { commands }) => {
+export const afterFail = System.create({ components: { with: [caption] }, after: [fail] }, (row, { commands }) => {
     if (row[caption] !== undefined) commands.despawn(row.entity);
 });
-export const failing = System.create({ name: "threadSystemsTest/failing", systems: [fail, afterFail] });
+export const failing = System.create({ systems: [fail, afterFail] });
 
 /** A tick's systems, on both threads, in tiers some of which run on the joined thread alone, one after another. */
-export const tick = System.create({ name: "threadSystemsTest/tick", systems: [move, describe, relabel, breed, tally, keep, watchCaptions, repaint, peek] });
+export const tick = System.create({ systems: [move, describe, relabel, breed, tally, keep, watchCaptions, repaint, peek] });
 
 /** On the thread, with input, which comes to it by message. */
-export const stamp = System.create({ name: "threadSystemsTest/stamp", input: { type: "object", properties: { text: { type: "string" } } }, components: { read: [uid], write: [caption] } }, (row, { input }) => {
+export const stamp = System.create({ components: { with: [uid, caption] } }, (row, _context, input: { readonly text: string }) => {
     if (row[uid] === 1) row[caption] = { text: input.text };
 });
 
 /** Disables `repaint`, from the world's thread. */
-export const disable = System.create({ name: "threadSystemsTest/disable", resources: { write: [enabled] } }, ({ resources }) => {
+export const disable = System.create({}, ({ resources }) => {
     resources[enabled] = false;
 });
 
@@ -185,9 +172,8 @@ const reading: { entities: readonly Entity[]; objects: readonly { readonly [name
 
 /** Each entity's objects of the thread, as data, a note by its text: none for an entity that's dead or has no uid. */
 const readObjects = System.create({
-    name: "threadSystemsTest/readObjects",
     observer: true,
-    lookup: { ids: { has: [uid] }, captions: { read: [caption] }, notes: { read: [note] } },
+    lookup: { ids: { with: [uid] }, captions: { with: [caption] }, notes: { with: [note] } },
 }, ({ lookup }) => {
     reading.objects = reading.entities.map(entity => {
         const objects: { [name: string]: unknown } = {};
@@ -255,40 +241,40 @@ export const scenario = async (world: World, objects: Objects = objectsThere(wor
 };
 
 /** Spawns entities with captions, from the world's thread. */
-export const crowd = System.create({ name: "threadSystemsTest/crowd", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const crowd = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let k = 0; k < input.count; k++) commands.spawn([uid, caption])({ [uid]: 1000 + k });
 });
 /** On the world's thread: every crowd entity but uid 1000 moves archetype, flagged on one run and not on the next. */
-export const flagCrowd = System.create({ name: "threadSystemsTest/flagCrowd", components: { read: [uid], has: [caption], not: [flagged] } }, (row, { commands }) => {
+export const flagCrowd = System.create({ components: { with: [uid, caption], not: [flagged] } }, (row, { commands }) => {
     if (row[uid] !== 1000) commands.add(row.entity, flagged);
 });
-export const unflagCrowd = System.create({ name: "threadSystemsTest/unflagCrowd", components: { has: [caption, flagged] } }, (row, { commands }) => {
+export const unflagCrowd = System.create({ components: { with: [caption, flagged] } }, (row, { commands }) => {
     commands.remove(row.entity, flagged);
 });
 /** On the thread: writes uid 1000's caption in place. */
-export const write = System.create({ name: "threadSystemsTest/write", components: { read: [uid], write: [caption] } }, row => {
+export const write = System.create({ components: { with: [uid, caption] } }, row => {
     if (row[uid] === 1000) row[caption] = { text: "written" };
 });
 /** On the thread: counts captions it holds that the thread wrote, into a struct resource. */
-export const countWritten = System.create({ name: "threadSystemsTest/countWritten", components: { read: [caption] }, resources: { write: [changes] } }, (row, { resources }) => {
+export const countWritten = System.create({ components: { with: [caption] } }, (row, { resources }) => {
     if (row[caption]?.text === "written") resources[changes] += 1;
 });
 
 /** On the thread: gives an object of the world's thread a value, which can't cross, so its command drops and it fails. */
-export const giveKept = System.create({ name: "threadSystemsTest/giveKept", components: { read: [caption] } }, (row, { commands }) => {
+export const giveKept = System.create({ components: { with: [caption] } }, (row, { commands }) => {
     if (row[caption] !== undefined) commands.add(row.entity, kept, "given there");
 });
 /** On the thread: spawns giving an object of the world's thread a value, which throws when it's issued. */
-export const spawnKept = System.create({ name: "threadSystemsTest/spawnKept", resources: { read: [paint] } }, ({ resources, commands }) => {
+export const spawnKept = System.create({}, ({ resources, commands }) => {
     commands.spawn([uid, kept])({ [uid]: resources[paint].text.length, [kept]: "spawned there" });
 });
 
 /** On the thread: runs until its thread ends, so its task never completes. */
-export const stall = System.create({ name: "threadSystemsTest/stall", resources: { read: [paint] } }, ({ resources }) => {
+export const stall = System.create({}, ({ resources }) => {
     while (resources[paint].text !== "never") { /* until the thread ends */ }
 });
 /** On the world's thread: counts its runs, ticking with nothing on the thread. */
-export const count = System.create({ name: "threadSystemsTest/count", resources: { write: [changes] } }, ({ resources }) => {
+export const count = System.create({}, ({ resources }) => {
     resources[changes] += 1;
 });
 /**
@@ -308,12 +294,12 @@ const setQueued = (task: () => void): void => {
     ranHere.atDue = -1;
 };
 /** On the thread: counts its runs, so the world's ticks post it a task each. */
-export const countThere = System.create({ name: "threadSystemsTest/countThere", resources: { read: [paint], write: [changes] } }, ({ resources }) => {
+export const countThere = System.create({}, ({ resources }) => {
     if (resources[paint].text !== "never") resources[changes] += 1;
 });
 
 /** On the thread: counts its runs there in `ranHere`; it reaches its commands, so it blocks its tier, a task a tick. */
-export const counted = System.create({ name: "threadSystemsTest/counted", resources: { read: [paint] } }, ({ resources, commands }) => {
+export const counted = System.create({}, ({ resources, commands }) => {
     void resources[paint];
     void commands;
     ranHere.runs++;
@@ -323,3 +309,22 @@ export const counted = System.create({ name: "threadSystemsTest/counted", resour
     }
     if (ranHere.atDue < 0 && performance.now() >= ranHere.due) ranHere.atDue = ranHere.runs;
 });
+
+/** On the thread, a tail, as its body is proven to reach no commands: the thread's paint, which its run resolves to. */
+export const paintThere = System.create(({ resources }) => resources[paint].text);
+/** On the thread, a blocking tier, as its body takes its commands: the length of the thread's paint. */
+export const paintLengthThere = System.create(({ resources, commands }) => {
+    void commands;
+    return resources[paint].text.length;
+});
+/** On the thread: a function, a value that can't be posted to the world's thread. */
+export const paintReader = System.create(({ resources }) => () => resources[paint].text);
+/** A composite of systems on the thread returning values, which no run resolves to. */
+export const paintsTogether = System.create([paintReader, paintLengthThere]);
+/** An observer system on the thread, as it reads the thread's paint: what a run of it resolves to. */
+export const paintObserved = System.create({ observer: true }, ({ resources }) => resources[paint].text);
+/** An observer system on the thread, throwing there. */
+export const paintObservedFails = System.create({ observer: true }, ({ resources }) => {
+    if (resources[paint].text !== "never") throw new Error("threadSystemsTest observer failure there");
+    return 0;
+});

package/src/implementation/world/thread-systems.test.ts

@@ -1,11 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { workers } from "../../interface/resources/workers.js";
 import type { World } from "../../interface/world/world.js";
-import { createWorld, join, type CreatedWorld } from "./create.js";
+import { createWorld, join, recorderOf, type CreatedWorld } from "./create.js";
 import { pageBytes } from "./memory.js";
 import { Observe } from "../../observe/index.js";
-import { caption, changes, countWritten, crowd, flagCrowd, giveKept, kept, objectsThere, scenario, spawnKept, uid, unflagCrowd, write } from "./thread-systems.test-helper.js";
-import { reportOf, runReported } from "./reports.test-helper.js";
+import { caption, changes, countWritten, crowd, flagCrowd, giveKept, kept, objectsThere, paintLengthThere, paintReader, paintThere, paintsTogether, scenario, spawnKept, uid, unflagCrowd, write } from "./thread-systems.test-helper.js";
+import { catchOutOfBand, followTicks, reportOf, runOutcome, runReported } from "./outcomes.test-helper.js";
 
 // Systems on a joined thread, with the world and the thread on this one, joined through a MessageChannel.
 
@@ -20,17 +21,13 @@ const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T
     });
 });
 
-/** Once the thread shared last has status `status`. */
-const statusOf = (world: CreatedWorld, status: "joined" | "gone") =>
-    until(world.threads, threads => threads.at(-1)?.status === status);
-
 /** A world shared with a thread on this one, which claims the systems' thread. */
 const joined = async (): 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: ["threadSystemsTest"] });
-    await statusOf(world, "joined");
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads: ["threadSystemsTest"] });
+    await shared;
     return { world, remote };
 };
 
@@ -45,7 +42,7 @@ describe("systems on a joined thread", () => {
         expect(actual.reports).toEqual(expected.reports);
         expect(expected.warnings.every(names => names.length === 0)).toBe(true);
         // Every tick waits for the joined thread's tiers.
-        expect(actual.warnings[1]).toEqual(["threadSystemsTest/describe", "threadSystemsTest/relabel", "threadSystemsTest/breed", "threadSystemsTest/tally", "threadSystemsTest/watchCaptions", "threadSystemsTest/repaint", "threadSystemsTest/peek"]);
+        expect(actual.warnings[1]).toEqual(["describe", "relabel", "breed", "tally", "watchCaptions", "repaint", "peek"]);
         await remote.dispose();
         await world.dispose();
     });
@@ -64,14 +61,43 @@ describe("systems on a joined thread", () => {
         const { world, remote } = await joined();
         await world.run(crowd, { count: 1 });
         const given = await runReported(world, giveKept);
-        expect(given.failures.map(failure => [failure.name, failure.message])).toEqual([["threadSystemsTest/giveKept", '"threadSystemsTest/kept" is a string, which only the world\'s thread writes, so a command on another thread gives it only its start.']]);
+        expect(given.failures.map(failure => [failure.name, failure.message])).toEqual([["giveKept", '"threadSystemsTest/kept" is a string, which only the world\'s thread writes, so a command on another thread gives it only its start.']]);
         expect(given.dropped).toBe(1);
         const spawned = await runReported(world, spawnKept);
-        expect(spawned.failures.map(failure => [failure.name, failure.message])).toEqual([["threadSystemsTest/spawnKept", '"threadSystemsTest/kept" is a string, which only the world\'s thread writes, so a command on another thread gives it only its start.']]);
+        expect(spawned.failures.map(failure => [failure.name, failure.message])).toEqual([["spawnKept", '"threadSystemsTest/kept" is a string, which only the world\'s thread writes, so a command on another thread gives it only its start.']]);
         expect(await Observe.toPromise(Observe.count(world, { required: [kept] }))).toBe(0);
         await remote.dispose();
         await world.dispose();
     });
+    it("resolve a run to what a body there returned, as a tail and in a task, and reject one whose value can't be posted", async () => {
+        const { world, remote } = await joined();
+        const tail = await runOutcome(world, paintThere);
+        expect([tail.value, tail.outcome.warnings]).toEqual(["plain", []]);
+        const blocking = await runOutcome(world, paintLengthThere);
+        expect([blocking.value, blocking.outcome.warnings.map(warning => warning.name)]).toEqual([5, ["paintLengthThere"]]);
+        await expect(world.run(paintReader)).rejects.toThrow(/^System "paintReader" .*failed: Its value can't be posted to the world's thread/);
+        expect(await world.run(paintThere)).toBe("plain");
+        await remote.dispose();
+        await world.dispose();
+    });
+    it("never post the values of composites' and ticks' members, which nothing resolves to", async () => {
+        using reported = catchOutOfBand();
+        const { world, remote } = await joined();
+        expect(await world.run(paintsTogether)).toBeUndefined();
+        const ticks = followTicks(world);
+        world.add(paintReader);
+        // Each run makes the next beat tick.
+        for (let k = 0; k < 3; k++) {
+            await world.run(paintThere);
+            await ticks.until(() => ticks.seen.length > k);
+        }
+        world.remove(paintReader);
+        ticks.stop();
+        expect(ticks.seen.flatMap(report => report.failures.map(failure => failure.message))).toEqual([]);
+        expect(reported.errors).toEqual([]);
+        await world.dispose();
+        await remote.dispose();
+    });
     it("are skipped with a \"thread\" failure once their thread is gone, and run here once its claims are released", async () => {
         const { world, remote } = await joined();
         await world.run(crowd, { count: 1 });
@@ -79,8 +105,8 @@ describe("systems on a joined thread", () => {
         const leaving = remote.dispose();
         const report = await runReported(world, write);
         await leaving;
-        expect(report.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["thread", "threadSystemsTest/write", 'Thread "threadSystemsTest" is gone, so its systems don\'t run.']]);
-        expect(report.skipped).toEqual(["threadSystemsTest/write"]);
+        expect(report.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["thread", "write", 'Thread "threadSystemsTest" is gone, so its systems don\'t run.']]);
+        expect(report.skipped).toEqual(["write"]);
         const [entity] = await Observe.toPromise(Observe.select(world, { required: [uid] }));
         expect(await runReported(world, write)).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
         expect(await Observe.toPromise(Observe.entity(world, entity, { required: [caption] }))).toEqual({ [caption]: { text: "written" } });
@@ -96,24 +122,23 @@ describe("systems on a joined thread", () => {
                 if (memory instanceof WebAssembly.Memory) resolve(memory);
             });
         });
-        world.share(channel.port1);
-        const remote = join(channel.port2, { threads: ["threadSystemsTest"] });
-        await statusOf(world, "joined");
+        const shared = world.share(channel.port1);
+        const remote = await join(channel.port2, { threads: ["threadSystemsTest"] });
+        await shared;
         await world.run(crowd, { count: 1 });
         const header = new Uint32Array((await given).buffer, 0, 1);
         const pages = Atomics.load(header, 0);
-        /** A run of `write` while the world says the memory is a page longer than it is: its number, or null once it never settles. */
+        recorderOf(world);
+        const failuresOf = async (running: Promise<unknown>) => (await reportOf(world, running)).failures.map(failure => [failure.kind, failure.name, failure.message]);
+        /** A run of `write` while the world says the memory is a page longer than it is: its failures, or null once it never settles. */
         const short = async () => {
             Atomics.store(header, 0, pages + 1);
-            const ran = await Promise.race([world.run(write), new Promise<null>(resolve => setTimeout(() => resolve(null), 5000))]);
+            const failures = await Promise.race([failuresOf(world.run(write)), new Promise<null>(resolve => setTimeout(() => resolve(null), 5000))]);
             Atomics.store(header, 0, pages);
-            return ran;
+            return failures;
         };
-        const failuresOf = async (ran: number | null) => ran === null ? null : (await reportOf(world, ran)).failures.map(failure => [failure.kind, failure.name, failure.message]);
-        const failed = [["system", "threadSystemsTest/write", `This thread's memory is ${pages * pageBytes} bytes, short of the ${(pages + 1) * pageBytes} the world stored.`]];
-        // Read once every run ran, as the thread saw them.
-        const runs = [await short(), await world.run(write), await short(), await world.run(write)];
-        expect(await Promise.all(runs.map(failuresOf))).toEqual([failed, [], failed, []]);
+        const failed = [["system", "write", `This thread's memory is ${pages * pageBytes} bytes, short of the ${(pages + 1) * pageBytes} the world stored.`]];
+        expect([await short(), await failuresOf(world.run(write)), await short(), await failuresOf(world.run(write))]).toEqual([failed, [], failed, []]);
         await remote.dispose();
         await world.dispose();
     });