@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/world/thread-tasks.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { lineWords } from './protocol.js';
 
 // What the world's thread and a joined thread filling objects share to run that thread's systems (threads.md, "Systems
@@ -31,21 +32,23 @@ export const taskBlockWords = 4 * lineWords;
 /**
  * A task's payload, f64 words: its sequence; the sync the thread replays through before it runs; how many systems it
  * runs; whether its input comes by message; then per system, in schedule order, its index on the thread, the tick it
- * takes when it runs, its `lastRun`, its tier within the task, where its folds start in the completion, and for a
- * tail the byte offset of its block (`tail-blocks.ts`), else 0. A task is all tails or none.
+ * takes when it runs, its `lastRun`, its tier within the task, where its folds start in the completion, for a
+ * tail the byte offset of its block (`tail-blocks.ts`), else 0, and 1 when the run resolves to its body's value, which
+ * it then gives back, else 0. A task is all tails or none.
  */
 export const payloadSequence = 0;
 export const payloadSync = 1;
 export const payloadCount = 2;
 export const payloadInput = 3;
 export const payloadSystems = 4;
-export const systemFields = 6;
+export const systemFields = 7;
 export const systemIndex = 0;
 export const systemTick = 1;
 export const systemLastRun = 2;
 export const systemTier = 3;
 export const systemFolds = 4;
 export const systemTail = 5;
+export const systemValued = 6;
 
 /** f64 words of a payload for `count` systems. */
 export const payloadWords = (count: number): number => payloadSystems + count * systemFields;
@@ -67,9 +70,11 @@ export const completionWords = (count: number, folds: number): number => complet
 
 /**
  * A system's result flags: it took its tick, its conditions holding; it ran its rows, so its folds count; it failed,
- * its error in the message; its segment is in the message, past the ring's size.
+ * its error in the message; its segment is in the message, past the ring's size; its body returned a value, in the
+ * message.
  */
 export const executedFlag = 1;
 export const ranFlag = 2;
 export const failedFlag = 4;
 export const spilledFlag = 8;
+export const valuedFlag = 16;

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { workersCases } from "./workers.cases.js";
 import { layoutDirectoryCases } from "./layout-directory.cases.js";
 import { poolCases } from "./pool.cases.js";
@@ -5,6 +6,7 @@ import { poolSizeCases } from "./pool-size.cases.js";
 import { dispatchCases } from "./dispatch.cases.js";
 import { reductionsCases } from "./reductions.cases.js";
 import { observedWorkersCases } from "./observed-workers.cases.js";
+import { changeBlocksCases } from "./change-blocks.cases.js";
 import { upWorkersCases } from "./up-workers.cases.js";
 import { portsCases } from "./ports.cases.js";
 import { commandRingsCases } from "./command-rings.cases.js";
@@ -20,6 +22,7 @@ import { indexWorkersCases } from "./index-workers.cases.js";
 import { indexBuildCases } from "./index-build.cases.js";
 import { entityLookupWorkersCases } from "./entity-lookup-workers.cases.js";
 import { observerJoinedCases } from "./observer-joined.cases.js";
+import { sharedWorkersCases } from "./shared-workers.cases.js";
 
 // Real workers in chromium: the cases over the fixtures' sources, as node runs them built.
 workersCases(() => import("./workers.fixture.js"));
@@ -29,6 +32,7 @@ poolSizeCases(() => import("./pool-size.fixture.js"));
 dispatchCases(() => import("./dispatch.fixture.js"));
 reductionsCases(() => import("./reductions.fixture.js"));
 observedWorkersCases(() => import("./observed-workers.fixture.js"));
+changeBlocksCases(() => import("./change-blocks.fixture.js"));
 upWorkersCases(() => import("./up-workers.fixture.js"));
 portsCases(() => import("./ports.fixture.js"));
 commandRingsCases(() => import("./command-rings.fixture.js"));
@@ -44,3 +48,4 @@ indexWorkersCases(() => import("./index-workers.fixture.js"));
 indexBuildCases(() => import("./index-build.fixture.js"));
 entityLookupWorkersCases(() => import("./entity-lookup-workers.fixture.js"));
 observerJoinedCases(() => import("./observer-joined.fixture.js"));
+sharedWorkersCases(() => import("./shared-workers.fixture.js"));

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { builtFixture } from "./fixtures.test-helper.js";
 import type * as Workers from "./workers.fixture.js";
 import { workersCases } from "./workers.cases.js";
@@ -13,6 +14,8 @@ import type * as Reductions from "./reductions.fixture.js";
 import { reductionsCases } from "./reductions.cases.js";
 import type * as ObservedWorkers from "./observed-workers.fixture.js";
 import { observedWorkersCases } from "./observed-workers.cases.js";
+import type * as ChangeBlocks from "./change-blocks.fixture.js";
+import { changeBlocksCases } from "./change-blocks.cases.js";
 import type * as UpWorkers from "./up-workers.fixture.js";
 import { upWorkersCases } from "./up-workers.cases.js";
 import type * as Ports from "./ports.fixture.js";
@@ -45,6 +48,10 @@ import type * as ObserverJoined from "./observer-joined.fixture.js";
 import { observerJoinedCases } from "./observer-joined.cases.js";
 import type * as ObserverContained from "./observer-contained.fixture.js";
 import { observerContainedCases } from "./observer-contained.cases.js";
+import type * as OptionalWorkers from "./optional-workers.fixture.js";
+import { optionalWorkersCases } from "./optional-workers.cases.js";
+import type * as SharedWorkers from "./shared-workers.fixture.js";
+import { sharedWorkersCases } from "./shared-workers.cases.js";
 
 // Real worker threads in node: the cases over fixtures `vitest.fixtures.ts` built, each typed as its source, which it's
 // built from.
@@ -55,6 +62,7 @@ poolSizeCases((): Promise<typeof PoolSize> => builtFixture("pool-size"));
 dispatchCases((): Promise<typeof Dispatch> => builtFixture("dispatch"));
 reductionsCases((): Promise<typeof Reductions> => builtFixture("reductions"));
 observedWorkersCases((): Promise<typeof ObservedWorkers> => builtFixture("observed-workers"));
+changeBlocksCases((): Promise<typeof ChangeBlocks> => builtFixture("change-blocks"));
 upWorkersCases((): Promise<typeof UpWorkers> => builtFixture("up-workers"));
 portsCases((): Promise<typeof Ports> => builtFixture("ports"));
 commandRingsCases((): Promise<typeof CommandRings> => builtFixture("command-rings"));
@@ -71,3 +79,5 @@ indexBuildCases((): Promise<typeof IndexBuild> => builtFixture("index-build"));
 entityLookupWorkersCases((): Promise<typeof EntityLookupWorkers> => builtFixture("entity-lookup-workers"));
 observerJoinedCases((): Promise<typeof ObserverJoined> => builtFixture("observer-joined"));
 observerContainedCases((): Promise<typeof ObserverContained> => builtFixture("observer-contained"));
+optionalWorkersCases((): Promise<typeof OptionalWorkers> => builtFixture("optional-workers"));
+sharedWorkersCases((): Promise<typeof SharedWorkers> => builtFixture("shared-workers"));

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Resource } from "../../interface/resource/resource.js";
 import { always } from "../../interface/resources/always.js";
 import { clock } from "../../interface/resources/clock.js";
 import { System } from "../../interface/system/system.js";
@@ -13,10 +13,9 @@ declare module "@adobe/ecs" {
         [frames]: { type: number };
     }
 }
-Resource.register(frames, { type: { type: "number", default: 0 } });
 
-const count = System.create({ name: "ticksBrowserTest/count", resources: { write: [frames] } }, ({ resources }) => { resources[frames] += 1; });
-const start = System.create({ name: "ticksBrowserTest/start", resources: { write: [always] } }, ({ resources }) => { resources[always] = true; });
+const count = System.create({}, ({ resources }) => { resources[frames] += 1; });
+const start = System.create({}, ({ resources }) => { resources[always] = true; });
 
 describe("a frame cadence", () => {
     it("ticks on animation frames, with their time", async () => {

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

@@ -1,5 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Resource, System, clock, workers } from "../../index.js";
+import { System, clock, workers } from "../../index.js";
 import { createWorld } from "./create.js";
 
 // The cases of ticks that read through observers are in `observe-ticks-cases.test.ts`.
@@ -10,14 +11,13 @@ declare module "@adobe/ecs" {
         [frames]: { type: number };
     }
 }
-Resource.register(frames, { type: { type: "number", default: 0 } });
 
-const count = System.create({ name: "ticksTest/count", resources: { write: [frames] } }, ({ resources }) => { resources[frames] += 1; });
+const count = System.create({}, ({ resources }) => { resources[frames] += 1; });
 
 describe("ticks", () => {
     it("reject a system that conflicts with one added with no order between them, and one with input", async () => {
-        const other = System.create({ name: "ticksTest/other", resources: { write: [frames] } }, ({ resources }) => { resources[frames] = 0; });
-        const withInput = System.create({ name: "ticksTest/withInput", input: { type: "object", properties: { by: { type: "number" } } } }, () => {});
+        const other = System.create({}, ({ resources }) => { resources[frames] = 0; });
+        const withInput = System.create({}, (_context, input: { readonly by: number }) => {});
         await using world = createWorld({ [workers]: 0 });
         world.add(count);
         expect(() => world.add(other)).toThrow('both access "ticksTest/frames"');

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import { count, read } from "./reads.test-helper.js";
@@ -20,15 +20,11 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(score, { type: { type: "number" } });
-Component.register(slot, { type: { type: "number", default: 0 }, derived: true });
-Component.register(ready, { type: { const: true }, within: slot });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
 
 describe("traits", () => {
     it("keep derived components out of commands, for untyped callers too", async () => {
         const errors: string[] = [];
-        const derived = System.create({ name: "traitsTest/derived" }, ({ commands }) => {
+        const derived = System.create({}, ({ commands }) => {
             const entity = commands.spawn([score])({ [score]: 1 });
             const attempts = [
                 // @ts-expect-error derived components are added only by rules
@@ -53,8 +49,8 @@ describe("traits", () => {
     it("leave index 0 to Entity.none, which no lookup finds", async () => {
         let first = Entity.none;
         let found: unknown = undefined;
-        const spawn = System.create({ name: "traitsTest/spawn" }, ({ commands }) => { first = commands.spawn([score])({ [score]: 1 }); });
-        const lookup = System.create({ name: "traitsTest/lookup", lookup: { scores: { read: [score] } } }, ({ lookup: { scores } }) => { found = scores(Entity.none); });
+        const spawn = System.create({}, ({ commands }) => { first = commands.spawn([score])({ [score]: 1 }); });
+        const lookup = System.create({ lookup: { scores: { with: [score] } } }, ({ lookup: { scores } }) => { found = scores(Entity.none); });
         const world = createWorld({ [workers]: 0 });
         await world.run(spawn);
         await world.run(lookup);

package/src/implementation/world/transfers-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 { requireDefinition } from "../../interface/registry/index.js";
 import type { World } from "../../interface/world/world.js";
@@ -26,17 +27,21 @@ export type FromTransfersWorker =
     | { readonly kind: "joined" }
     | { readonly kind: "blocking" }
     | { readonly kind: "stored"; readonly stored: readonly (readonly [number, number, number])[]; readonly widths: readonly number[] }
-    | { readonly kind: "moved"; readonly detached: number; readonly greeted: unknown; readonly runs: readonly number[] }
+    | { readonly kind: "moved"; readonly detached: number; readonly greeted: unknown; readonly failures: number }
     | { readonly kind: "posted"; readonly detached: boolean }
-    | { readonly kind: "settled"; readonly runs: readonly number[] }
-    | { readonly kind: "dropped"; readonly runs: readonly number[]; readonly closed: boolean; readonly widths: readonly number[] };
+    | { readonly kind: "settled"; readonly failures: number }
+    | { readonly kind: "dropped"; readonly closed: boolean; readonly widths: readonly number[] };
 
 const channel = scopeChannel<FromTransfersWorker, ToTransfersWorker>();
 let remote: World | null = null;
-let posted: Promise<number>[] = [];
+let posted: Promise<void>[] = [];
 
 const later = (milliseconds = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, milliseconds));
 
+/** How many of these runs rejected, as one whose system failed does. */
+const failuresOf = async (runs: readonly Promise<unknown>[]): Promise<number> =>
+    (await Promise.allSettled(runs)).filter(settled => settled.status === "rejected").length;
+
 const bufferOf = (first: number, bytes: number): ArrayBuffer => {
     const buffer = new ArrayBuffer(bytes);
     new Uint8Array(buffer)[0] = first;
@@ -57,7 +62,7 @@ const bitmap = async (): Promise<ImageBitmap | null> =>
 const respond = async (message: Exclude<ToTransfersWorker, { readonly kind: "block" }>): Promise<FromTransfersWorker> => {
     if (message.kind === "join") {
         for (const system of transferSystems) requireDefinition(system);
-        remote = join(message.port, { threads: message.threads });
+        remote = await join(message.port, { threads: message.threads });
         // Joined once the world gave it a channel to the other joined thread.
         while ((peersOf.get(remote)?.() ?? 0) === 0) await later(1);
         return { kind: "joined" };
@@ -76,10 +81,10 @@ const respond = async (message: Exclude<ToTransfersWorker, { readonly kind: "blo
             ports.port2.onmessage = event => resolve(event.data);
         });
         runs.push(world.run(greetThere, { port: ports.port1 }));
-        const numbers = await Promise.all(runs);
+        const failures = await failuresOf(runs);
         const greeting = await greeted;
         ports.port2.close();
-        return { kind: "moved", detached, greeted: greeting, runs: numbers };
+        return { kind: "moved", detached, greeted: greeting, failures };
     }
     if (message.kind === "late") {
         const buffer = bufferOf(9, 1 << 20);
@@ -87,22 +92,22 @@ const respond = async (message: Exclude<ToTransfersWorker, { readonly kind: "blo
         return { kind: "posted", detached: buffer.byteLength === 0 };
     }
     if (message.kind === "settled") {
-        return { kind: "settled", runs: await Promise.all(posted) };
+        return { kind: "settled", failures: await failuresOf(posted) };
     }
     // Commands giving a dead entity values: they drop, and each value is released on its thread.
     const dead = asEntity(123456);
     const ports = new MessageChannel();
     const closing = closed(ports.port2);
-    const runs = [await world.run(attachThere, { entity: dead, value: ports.port1 })];
+    await world.run(attachThere, { entity: dead, value: ports.port1 });
     const there = await bitmap();
     const here = await bitmap();
     if (there !== null && here !== null) {
-        runs.push(await world.run(attachThere, { entity: dead, value: there }));
-        runs.push(await world.run(attachHere, { entity: dead, value: here }));
+        await world.run(attachThere, { entity: dead, value: there });
+        await world.run(attachHere, { entity: dead, value: here });
     }
     // Moved, so detached here: zero wide.
     const widths = there === null || here === null ? [] : [there.width, here.width];
-    return { kind: "dropped", runs, closed: await closing, widths };
+    return { kind: "dropped", closed: await closing, widths };
 };
 
 channel.onMessage(async message => {

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

package/src/implementation/world/transfers.fixture.ts

@@ -1,10 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { Observe } from "../../observe/index.js";
 import { workers } from "../../interface/resources/workers.js";
-import { createWorld, type CreatedWorld } from "./create.js";
+import { createWorld, recorderOf, type CreatedWorld, type Outcome } from "./create.js";
 import type { FromTransfersWorker, ToTransfersWorker } from "./transfers-worker.fixture.js";
 import { idle, kept, marks, order, stored } from "./transfers.test-helper.js";
-import { reportOf } from "./reports.test-helper.js";
 
 /**
  * Scenarios of transfers between joined workers, run built in node and from source in chromium: the world here, a
@@ -38,16 +38,14 @@ const start = (): Worker => {
     };
 };
 
-/** A port of a channel this world shares the other end of. */
+/** A port of a channel this world shares the other end of, and what its share resolves to once a thread joined through it. */
 const shared = (world: CreatedWorld) => {
     if (typeof globalThis.Worker === "function") {
         const { port1, port2 } = new MessageChannel();
-        world.share(port1);
-        return port2;
+        return { port: port2, joined: world.share(port1) };
     }
     const { port1, port2 } = new (globalThis.process.getBuiltinModule("node:worker_threads").MessageChannel)();
-    world.share(port1);
-    return port2;
+    return { port: port2, joined: world.share(port1) };
 };
 
 /** The world, its filler and its loader, each with a channel to the other. */
@@ -56,11 +54,13 @@ const joined = async () => {
     const world = createWorld({ [workers]: 0 });
     const filler = start();
     const loader = start();
-    const loaderPort = shared(world);
-    const fillerPort = shared(world);
+    const loaderShared = shared(world);
+    const fillerShared = shared(world);
     await Promise.all([
-        loader.ask({ kind: "join", port: loaderPort, threads: [] }, [loaderPort]),
-        filler.ask({ kind: "join", port: fillerPort, threads: ["transfersTest"] }, [fillerPort]),
+        loader.ask({ kind: "join", port: loaderShared.port, threads: [] }, [loaderShared.port]),
+        filler.ask({ kind: "join", port: fillerShared.port, threads: ["transfersTest"] }, [fillerShared.port]),
+        loaderShared.joined,
+        fillerShared.joined,
     ]);
     const end = async (): Promise<void> => {
         await world.dispose();
@@ -77,22 +77,15 @@ const storedOf = async (worker: Worker) => {
 
 /** The loader moving `count` buffers of `bytes` each, and a MessagePort, to the filler, whose systems take them. */
 export const moves = async (count: number, bytes: number) => {
-    const { world, filler, loader, end } = await joined();
+    const { filler, loader, end } = await joined();
     const reply = await loader.ask({ kind: "moves", count, bytes });
     if (reply.kind !== "moved") throw new Error("transfers: the loader didn't say what moved.");
-    const { runs, ...moved } = reply;
-    const failures = await failuresOf(world, runs);
+    const { failures, ...moved } = reply;
     const { stored: received } = await storedOf(filler);
     await end();
     return { moved: { ...moved, failures }, received };
 };
 
-/** How many failures the reports of a joined thread's runs list, read on the world's thread, which holds them. */
-const failuresOf = async (world: CreatedWorld, runs: readonly number[]): Promise<number> => {
-    let failures = 0;
-    for (const run of runs) failures += (await reportOf(world, run)).failures.length;
-    return failures;
-};
 
 /** Resolves with what `promise` does, or `otherwise` after `milliseconds`. */
 const within = <T>(promise: Promise<T>, milliseconds: number, otherwise: T): Promise<T> => new Promise((resolve, reject) => {
@@ -125,7 +118,7 @@ export const late = async () => {
     Atomics.notify(block, 0);
     const reply = await loader.ask({ kind: "settled" });
     if (reply.kind !== "settled") throw new Error("transfers: the loader didn't say how its runs settled.");
-    const settled = { kind: reply.kind, failures: await failuresOf(world, reply.runs) };
+    const settled = { kind: reply.kind, failures: reply.failures };
     const { stored: received } = await storedOf(filler);
     await end();
     return { posted, worldRun, orderWhileBlocked, settled, stores: received.map(([, , seen]) => seen), marks: marks.map(({ value, order }) => [value, order]) };
@@ -134,12 +127,12 @@ export const late = async () => {
 /** Commands giving values the loader moved to a dead entity, on the filler and here: each released on its thread. */
 export const drops = async () => {
     const { world, filler, loader, end } = await joined();
+    // The loader's runs, the world's only ones meanwhile, as the world's thread gathered them.
+    const outcomes: Outcome[] = [];
+    recorderOf(world).each.push(outcome => outcomes.push(outcome));
     const reply = await loader.ask({ kind: "drops" });
     if (reply.kind !== "dropped") throw new Error("transfers: the loader didn't say what dropped.");
-    const { runs, ...rest } = reply;
-    const counts: number[] = [];
-    for (const run of runs) counts.push((await reportOf(world, run)).dropped);
-    const dropped = { ...rest, dropped: counts };
+    const dropped = { ...reply, dropped: outcomes.map(outcome => outcome.dropped) };
     const { widths } = await storedOf(filler);
     const here = kept.map(value => typeof ImageBitmap === "function" && value instanceof ImageBitmap ? value.width : -1);
     await end();

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

@@ -1,7 +1,7 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Entity } from "../../interface/entity/entity.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
+import type { Schema } from "../../interface/schema/schema.js";
 
 // Keys and systems every thread of the transfer tests imports: systems on thread "transfersTest", which a joined thread
 // fills, and on the world's, taking Transferable values in their input, and `transfer` components holding them.
@@ -28,20 +28,12 @@ declare module "@adobe/ecs" {
         [depth]: { type: number };
     }
     export interface Resources {
-        [anchor]: { type: { readonly text: string }; thread: "transfersTest" };
-        [order]: { type: number };
+        [anchor]: { type: { readonly text: string }; thread: "transfersTest"; default: { text: "anchor" } };
+        [order]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
     }
 }
 /** An object resource of "transfersTest", which places the systems reading it there. */
-Resource.register(anchor, { type: { type: "object", properties: { text: { type: "string" } }, default: { text: "anchor" } }, thread: "transfersTest" });
 /** Counts the runs that read it, in the order they ran. */
-Resource.register(order, { type: { type: "integer", default: 0 } });
-Component.register(port, { thread: "transfersTest", transfer: true });
-Component.register(bitmap, { thread: "transfersTest", transfer: true });
-Component.register(portHere, { transfer: true });
-Component.register(bitmapHere, { transfer: true });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Component.register(depth, { type: { type: "number" } });
 
 const any = { allOf: [] } as const;
 
@@ -51,46 +43,44 @@ export const stored: Stored[] = [];
 /** The values systems gave components, on the thread they ran on. */
 export const kept: unknown[] = [];
 
-const store = (value: unknown, resources: { [order]: number }): void => {
+const store = (value: unknown, at: number): void => {
     const bytes = value instanceof ArrayBuffer ? value.byteLength : -1;
-    stored.push({ bytes, first: bytes > 0 && value instanceof ArrayBuffer ? new Uint8Array(value)[0] : -1, order: resources[order]++, value });
+    stored.push({ bytes, first: bytes > 0 && value instanceof ArrayBuffer ? new Uint8Array(value)[0] : -1, order: at, value });
 };
 
 /** On "transfersTest": records the buffer it's given. */
-export const storeThere = System.create({ name: "transfersTest/storeThere", input: { type: "object", properties: { buffer: any } }, resources: { read: [anchor], write: [order] } }, ({ input, resources }) => {
-    if (resources[anchor].text === "anchor") store(input.buffer, resources);
+export const storeThere = System.create({}, ({ resources }, input: { readonly buffer: unknown }) => {
+    if (resources[anchor].text === "anchor") store(input.buffer, resources[order]++);
 });
 /** On the world's thread: records the buffer it's given. */
-export const storeHere = System.create({ name: "transfersTest/storeHere", input: { type: "object", properties: { buffer: any } }, resources: { write: [order] } }, ({ input, resources }) => {
-    store(input.buffer, resources);
+export const storeHere = System.create({}, ({ resources }, input: { readonly buffer: unknown }) => {
+    store(input.buffer, resources[order]++);
 });
 /** On the world's thread: what a run from a joined thread saw of the order, by its value. */
 export const marks: { readonly value: number; readonly order: number }[] = [];
-export const mark = System.create({ name: "transfersTest/mark", input: { type: "object", properties: { value: { type: "number" } } }, resources: { write: [order] } }, ({ input, resources }) => {
+export const mark = System.create({}, ({ resources }, input: { readonly value: number }) => {
     marks.push({ value: input.value, order: resources[order]++ });
 });
 /** On "transfersTest": gives an entity the port or bitmap it's given. */
-export const attachThere = System.create({
-    name: "transfersTest/attachThere", input: { type: "object", properties: { entity: Entity.schema, value: any } }, resources: { read: [anchor] },
-}, ({ input, resources, commands }) => {
+export const attachThere = System.create({}, ({ resources, commands }, input: { readonly entity: Entity; readonly value: unknown }) => {
     if (resources[anchor].text !== "anchor") return;
     kept.push(input.value);
     if (input.value instanceof MessagePort) commands.add(input.entity, port, input.value);
     else if (typeof ImageBitmap === "function" && input.value instanceof ImageBitmap) commands.add(input.entity, bitmap, input.value);
 });
 /** On the world's thread: gives an entity the port or bitmap it's given. */
-export const attachHere = System.create({ name: "transfersTest/attachHere", input: { type: "object", properties: { entity: Entity.schema, value: any } } }, ({ input, commands }) => {
+export const attachHere = System.create({}, ({ commands }, input: { readonly entity: Entity; readonly value: unknown }) => {
     kept.push(input.value);
     if (input.value instanceof MessagePort) commands.add(input.entity, portHere, input.value);
     else if (typeof ImageBitmap === "function" && input.value instanceof ImageBitmap) commands.add(input.entity, bitmapHere, input.value);
 });
 /** On "transfersTest": says hello through the port it's given, which only moving it there, not copying it, gives. */
-export const greetThere = System.create({ name: "transfersTest/greetThere", input: { type: "object", properties: { port: any } }, resources: { read: [anchor] } }, ({ input, resources }) => {
+export const greetThere = System.create({}, ({ resources }, input: { readonly port: unknown }) => {
     if (input.port instanceof MessagePort) input.port.postMessage(resources[anchor].text);
 });
 
 /** On the world's thread: spawns an entity holding the port it's given. */
-export const spawnHere = System.create({ name: "transfersTest/spawnHere", input: { type: "object", properties: { value: any } } }, ({ input, commands }) => {
+export const spawnHere = System.create({}, ({ commands }, input: { readonly value: unknown }) => {
     if (input.value instanceof MessagePort) commands.spawn([portHere])({ [portHere]: input.value });
 });
 
@@ -99,13 +89,13 @@ export const spawnHere = System.create({ name: "transfersTest/spawnHere", input:
  * "transfersTest", it fails to register, so a run of it never runs.
  */
 export const unregistered = System.create({
-    name: "transfersTest/unregistered", input: { type: "object", properties: { value: any } }, components: { read: [port], write: [depth] }, up: { through: parent, read: [depth] },
-}, (row, { input, up }) => {
+    components: { with: [port, depth] }, up: { through: parent },
+}, (row, { up }, input: { readonly value: unknown }) => {
     row[depth] = (up === null ? 0 : up[depth]) + (row[port] === input.value ? 1 : 0);
 });
 
 /** On the world's thread: nothing, a run of its own. */
-export const idle = System.create({ name: "transfersTest/idle" }, () => {});
+export const idle = System.create({}, () => {});
 
 /** Every system the joined threads run or place, which they import so the world can place them there. */
 export const transferSystems: readonly { readonly name: string }[] = [storeThere, storeHere, mark, attachThere, attachHere, spawnHere, greetThere, unregistered];

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

@@ -1,26 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import type { Observe } from "../../observe/index.js";
 import { workers } from "../../interface/resources/workers.js";
 import type { World } from "../../interface/world/world.js";
 import { createWorld, join, type CreatedWorld } from "./create.js";
 import { asEntity } from "./entities.js";
 import { peersOf } from "./join.js";
 import { attachHere, attachThere, greetThere, kept, mark, marks, spawnHere, storeHere, storeThere, stored, unregistered } from "./transfers.test-helper.js";
-import { reportOf, runReported } from "./reports.test-helper.js";
+import { followRuns, runReported } from "./outcomes.test-helper.js";
 
 // Transfers, with the world, the thread filling "transfersTest" and a thread filling none on this one, joined through
 // MessageChannels: a run's Transferable input moves to the thread its system runs on.
 
-const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T> => new Promise(resolve => {
-    let done = false;
-    const stop = observe(value => {
-        if (done || !accept(value)) return;
-        done = true;
-        queueMicrotask(() => stop());
-        resolve(value);
-    });
-});
-
 const later = (milliseconds = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, milliseconds));
 
 /** Resolves once `remote` has a channel to another joined thread. */
@@ -28,19 +18,20 @@ const peered = async (remote: World): Promise<void> => {
     while ((peersOf.get(remote)?.() ?? 0) === 0) await later();
 };
 
-const sharedWith = (world: CreatedWorld, threads: readonly "transfersTest"[]): World => {
+/** A thread on this one joined to `world` claiming `threads`, once both sides say it joined. */
+const sharedWith = async (world: CreatedWorld, threads: readonly "transfersTest"[]): Promise<World> => {
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    return join(channel.port2, { threads });
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads });
+    await shared;
+    return remote;
 };
 
 /** A world here, `filler` claiming "transfersTest", and `loader` claiming nothing, each with a channel to the other. */
 const joined = async (): Promise<{ readonly world: CreatedWorld; readonly filler: World; readonly loader: World }> => {
     stored.length = marks.length = kept.length = 0;
     const world = createWorld({ [workers]: 0 });
-    const loader = sharedWith(world, []);
-    const filler = sharedWith(world, ["transfersTest"]);
-    await until(world.threads, threads => threads.length === 2 && threads.every(thread => thread.status === "joined"));
+    const [loader, filler] = await Promise.all([sharedWith(world, []), sharedWith(world, ["transfersTest"])]);
     await peered(loader);
     await peered(filler);
     return { world, filler, loader };
@@ -64,11 +55,12 @@ const clean = { failures: [], skipped: [], dropped: 0, warnings: [] };
 describe("transfers", () => {
     it("move a run's Transferable input straight to the joined thread its system runs on, in call order with that thread's other runs", async () => {
         const { world, filler, loader } = await joined();
+        const reports = followRuns(world);
         const buffers = [bufferOf(1), bufferOf(2)];
         const runs = [loader.run(storeThere, { buffer: buffers[0] }), loader.run(mark, { value: 1 }), loader.run(storeThere, { buffer: buffers[1] }), loader.run(mark, { value: 2 })];
         // Moved, not copied: the loader's are detached as soon as it runs them.
         expect(buffers.map(buffer => buffer.byteLength)).toEqual([0, 0]);
-        const reports = await Promise.all((await Promise.all(runs)).map(run => reportOf(world, run)));
+        await Promise.all(runs);
         expect(reports.map(report => report.warnings.map(warning => warning.kind))).toEqual([["blocking"], [], ["blocking"], []]);
         expect(stored.map(({ bytes, first, order }) => [bytes, first, order])).toEqual([[1024, 1, 0], [1024, 2, 2]]);
         expect(marks).toEqual([{ value: 1, order: 1 }, { value: 2, order: 3 }]);
@@ -82,7 +74,7 @@ describe("transfers", () => {
         const greeted = new Promise<unknown>(resolve => {
             channel.port2.onmessage = event => resolve(event.data);
         });
-        expect((await reportOf(world, await loader.run(greetThere, { port: channel.port1 }))).failures).toEqual([]);
+        await loader.run(greetThere, { port: channel.port1 });
         expect(await greeted).toBe("anchor");
         channel.port2.close();
         await loader.dispose();
@@ -92,9 +84,11 @@ describe("transfers", () => {
     it("move one to the world's thread where its system runs there", async () => {
         const { world, filler, loader } = await joined();
         const buffer = bufferOf(3);
+        const reports = followRuns(world);
         const ran = loader.run(storeHere, { buffer });
         expect(buffer.byteLength).toBe(0);
-        expect(await reportOf(world, await ran)).toEqual(clean);
+        await ran;
+        expect(reports).toEqual([clean]);
         expect(stored.map(({ bytes, first }) => [bytes, first])).toEqual([[1024, 3]]);
         await loader.dispose();
         await filler.dispose();
@@ -127,8 +121,10 @@ describe("transfers", () => {
         const here = new MessageChannel();
         const closes = [closed(there.port2), closed(here.port2)];
         const dead = asEntity(123456);
-        expect((await reportOf(world, await loader.run(attachThere, { entity: dead, value: there.port1 }))).dropped).toBe(1);
-        expect((await reportOf(world, await loader.run(attachHere, { entity: dead, value: here.port1 }))).dropped).toBe(1);
+        const reports = followRuns(world);
+        await loader.run(attachThere, { entity: dead, value: there.port1 });
+        await loader.run(attachHere, { entity: dead, value: here.port1 });
+        expect(reports.map(report => report.dropped)).toEqual([1, 1]);
         expect(await Promise.all(closes)).toEqual([true, true]);
         await loader.dispose();
         await filler.dispose();

package/src/implementation/world/transfers.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { TaskChannel } from './remote-systems.js';
 
 // Transfers (threads.md, "Transfers"): a run's input holding Transferable values moves them to the thread its system