@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/remote-systems.ts

@@ -1,12 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Leaf } from '../../interface/system/leaf.js';
 import { entityWatchesOf, lookupComponentsOf } from './lookup-keys.js';
 import type { Leaf as FinalizerLeaf } from '../../interface/finalizer/created.js';
-import type { Warning } from '../../interface/report/failure.js';
-import { declarationOf, idOfItem, idOfKey, indexOfLookup, labelOf, labelOfItem, threadOf, watchedBy, watchesEntries } from '../../interface/registry/index.js';
+import type { Warning } from './failures.js';
+import { declarationOf, idOfItem, idOfKey, idOrNull, indexOfLookup, labelOf, threadOf, watchedBy, watchesEntries } from '../../interface/registry/index.js';
 import { unsharedKeyOf } from './index-keys.js';
 import { layoutOf } from '../../interface/registry/layout.js';
-import type { Archetype } from './archetype.js';
-import { chunkShift } from './kernel.js';
+import { raiseRange, type Archetype } from './archetype.js';
 import type { LocalIds, Segment } from './command-ring.js';
 import type { ToJoined } from './joining.js';
 import { lineWords, type WorkerError } from './protocol.js';
@@ -20,22 +20,24 @@ import { logBoundedWord, logBoundWord, logSyncWord, type MoveLog } from './move-
 import { createStopWriter, freeStops, type StopWriter } from './stop-lists.js';
 import { freeTail, stampWritten, type Tail } from './tails.js';
 import { isHeld } from './transfers.js';
+import { requiredOf } from './required.js';
 import {
     completionCapacityWord, completionMessage, completionOffsetWord, completionSystems, completionWords, executedFlag, failedFlag,
     payloadCapacityWord, payloadCount, payloadInput, payloadOffsetWord, payloadSequence, payloadSync, payloadSystems, payloadWords, ranFlag,
     resultEnd, resultFields, resultFlags, resultStart, ringBaseWord, ringCapacityWord, ringCursorWord, ringNeededWord, spilledFlag, systemFields,
-    systemFolds, systemIndex, systemLastRun, systemTail, systemTick, systemTier, taskBlockWords, taskDoneWord, taskFailedWord, taskPostedWord,
+    systemFolds, systemIndex, systemLastRun, systemTail, systemTick, systemTier, systemValued, taskBlockWords, taskDoneWord, taskFailedWord, taskPostedWord, valuedFlag,
 } from './thread-tasks.js';
 
 // The world's side of systems on joined threads (threads.md, "Systems on other threads"): a runner standing for each
 // system placed on a thread a joined thread fills, and that thread's task block and command ring, through which a
 // tier, or consecutive tiers all on that thread, run as one task.
 
-/** What a task of a joined thread's gave back for one of its systems. */
+/** What a task of a joined thread's gave back for one of its systems: for one without components, its body's value too. */
 export type RemoteResult = {
     flags: number;
     segment: Segment | undefined;
     error: unknown;
+    value: unknown;
 };
 
 /** A system placed on a joined thread: its channel, its index there, and what its last task gave back. */
@@ -43,7 +45,11 @@ export type RemoteSystem = {
     readonly channel: TaskChannel;
     readonly index: number;
     readonly label: string;
-    /** Its warning, listed in each run's report its tier blocks. */
+    /** Its system, whose body's value a run of it alone resolves to. */
+    readonly leaf: Leaf;
+    /** The id the plugin gave it, which failures give beside its label. */
+    readonly id: string | null;
+    /** Its warning, listed for each run its tier blocks. */
     readonly warning: Warning;
     readonly targets: readonly ReductionTarget[];
     /** Its folds' leaves, as the last task gave them, by target. */
@@ -195,6 +201,7 @@ export const createTaskChannel = (state: State, log: MoveLog, post: (message: To
             result.flags = flags;
             result.error = undefined;
             result.segment = undefined;
+            result.value = (flags & valuedFlag) === 0 ? undefined : message?.values?.find(([position]) => position === k)?.[1];
             const startByte = completionView[at + resultStart];
             const endByte = completionView[at + resultEnd];
             if ((flags & spilledFlag) !== 0) {
@@ -227,6 +234,7 @@ export const createTaskChannel = (state: State, log: MoveLog, post: (message: To
             const { result } = system;
             result.flags = failedFlag;
             result.segment = undefined;
+            result.value = undefined;
             result.error = failure === undefined ? new Error(`System "${system.label}" failed on thread "${label}".`) : errorOf(failure);
         }
     };
@@ -319,6 +327,7 @@ export const createTaskChannel = (state: State, log: MoveLog, post: (message: To
             payloadView[base + systemTier] = tiers[k];
             payloadView[base + systemFolds] = folds;
             payloadView[base + systemTail] = tails ? system.tail?.block ?? 0 : 0;
+            payloadView[base + systemValued] = state.wanted === system.leaf ? 1 : 0;
             folds += system.foldCount;
             if (system.indexes.length !== 0) writeRecords(system);
         }
@@ -346,11 +355,11 @@ export const createTaskChannel = (state: State, log: MoveLog, post: (message: To
     /** An item's setup there: its id, and the world's numbers for the keys it names, by their ids. Throws without them. */
     const setupOf = (state: State, item: Leaf | FinalizerLeaf, what: string, named: readonly symbol[]): { readonly id: string; readonly keys: readonly (readonly [number, string])[] } => {
         const id = idOfItem(item);
-        if (id === undefined) throw new Error(`${what} "${labelOfItem(item)}" runs on thread "${label}", which a joined thread fills, and has no id, so that thread can't name it; the build gives top-level ${what === "System" ? "systems" : "finalizers"} one.`);
+        if (id === undefined) throw new Error(`${what} "${item.name}" runs on thread "${label}", which a joined thread fills, and has no id, so that thread can't name it; the build gives top-level ${what === "System" ? "systems" : "finalizers"} one.`);
         const keys: (readonly [number, string])[] = [];
         for (const key of named) {
             const keyId = idOfKey(key);
-            if (keyId === undefined) throw new Error(`${what} "${labelOfItem(item)}" names "${labelOf(key)}", which has no id, so thread "${label}" can't name it; the build gives top-level keys one.`);
+            if (keyId === undefined) throw new Error(`${what} "${item.name}" names "${labelOf(key)}", which has no id, so thread "${label}" can't name it; the build gives top-level keys one.`);
             keys.push([idOf(state, key), keyId]);
         }
         return { id, keys };
@@ -471,13 +480,12 @@ export const createTaskChannel = (state: State, log: MoveLog, post: (message: To
 
 /** Every key a leaf names in its declaration, so the thread finds the world's numbers for them. */
 export const keysOf = (leaf: Leaf): readonly symbol[] => {
-    const { components, lookup, resources, reduce } = leaf.declaration;
+    const { components, lookup, resources } = leaf.declaration;
     const keys = new Set<Key>([
         ...components?.read ?? [], ...components?.write ?? [], ...components?.has ?? [], ...components?.not ?? [], ...components?.added ?? [], ...components?.changed ?? [],
-        ...resources?.read ?? [], ...resources?.write ?? [], ...resources?.changed ?? [], ...resources?.is ?? [], ...resources?.not ?? [],
+        ...resources?.read ?? [], ...resources?.write ?? [], ...resources?.changed ?? [], ...resources?.is ?? [], ...resources?.not ?? [], ...resources?.reduce ?? [],
     ]);
     for (const name in lookup) for (const key of lookupComponentsOf(lookup[name])) keys.add(key);
-    if (reduce !== undefined) for (const key of Object.getOwnPropertySymbols(reduce)) keys.add(key);
     return [...keys].filter((key): key is symbol => typeof key === "symbol");
 };
 
@@ -494,22 +502,22 @@ export const finalizerKeysOf = (finalizer: FinalizerLeaf): readonly symbol[] =>
  */
 /** Why a leaf with an index as a change filter can't run on a joined thread. */
 export const entriesOnJoined = (leaf: Leaf, thread: string, index: string): string =>
-    `System "${labelOfItem(leaf)}" runs on thread "${thread}", which a joined thread fills, and when index "${index}" changed, a lookup's changed being true, which runs only on the world's thread.`;
+    `System "${leaf.name}" runs on thread "${thread}", which a joined thread fills, and when index "${index}" changed, a lookup's changed being true, which runs only on the world's thread.`;
 
 export const unplaceable = (leaf: Leaf, thread: string): string | null => {
-    if (leaf.declaration.up !== undefined) return `System "${labelOfItem(leaf)}" runs on thread "${thread}", which a joined thread fills, and declares up, which runs only on the world's thread.`;
-    if (leaf.declaration.order !== undefined) return `System "${labelOfItem(leaf)}" runs on thread "${thread}", which a joined thread fills, and orders its rows by an index, which runs only on the world's thread.`;
-    if (leaf.declaration.target !== undefined) return `System "${labelOfItem(leaf)}" runs on thread "${thread}", which a joined thread fills, and on one entity, which runs only on the world's thread.`;
+    if (leaf.declaration.up !== undefined) return `System "${leaf.name}" runs on thread "${thread}", which a joined thread fills, and declares up, which runs only on the world's thread.`;
+    if (leaf.declaration.order !== undefined) return `System "${leaf.name}" runs on thread "${thread}", which a joined thread fills, and orders its rows by an index, which runs only on the world's thread.`;
+    if (leaf.declaration.target !== undefined) return `System "${leaf.name}" runs on thread "${thread}", which a joined thread fills, and on one entity, which runs only on the world's thread.`;
     const { components, resources } = leaf.declaration;
     const string = [...components?.write ?? [], ...resources?.write ?? []].find(key => layoutOf(declarationOf(key)?.type).kind === "string");
-    if (string !== undefined) return `System "${labelOfItem(leaf)}" runs on thread "${thread}", which a joined thread fills, and writes "${labelOf(string)}", a string, which only the world's thread writes.`;
+    if (string !== undefined) return `System "${leaf.name}" runs on thread "${thread}", which a joined thread fills, and writes "${labelOf(string)}", a string, which only the world's thread writes.`;
     for (const lookup of Object.values(leaf.declaration.lookup ?? {})) {
         const index = indexOfLookup(lookup);
         const object = index === undefined ? undefined : unsharedKeyOf(index.declaration.key);
         if (index !== undefined && object !== undefined) {
-            return `System "${labelOfItem(leaf)}" runs on thread "${thread}", which a joined thread fills, and looks up through index "${labelOfItem(index)}", whose key part "${labelOf(object.key)}" is ${object.what}, so it runs only on the world's thread.`;
+            return `System "${leaf.name}" runs on thread "${thread}", which a joined thread fills, and looks up through index "${index.name}", whose key part "${labelOf(object.key)}" is ${object.what}, so it runs only on the world's thread.`;
         }
-        if (index !== undefined && watchesEntries(lookup)) return entriesOnJoined(leaf, thread, labelOfItem(index));
+        if (index !== undefined && watchesEntries(lookup)) return entriesOnJoined(leaf, thread, index.name);
     }
     return null;
 };
@@ -545,38 +553,38 @@ export const createRemoteRunner = (state: State, leaf: Leaf, channel: TaskChanne
     const { declaration } = leaf;
     const { components: query } = declaration;
     const thread = threadOf(declaration, "System", leaf.name) ?? "world";
-    const label = labelOfItem(leaf);
+    const label = leaf.name;
     const problem = unplaceable(leaf, thread);
     if (problem !== null) throw new Error(problem);
     const lookups = remoteIndexesOf(state, declaration.lookup, acquireLookups(state, declaration.lookup));
     const index = channel.place(state, leaf, lookups.named);
-    const required = [...new Set([...query?.read ?? [], ...query?.write ?? [], ...query?.has ?? [], ...query?.added ?? [], ...query?.changed ?? []])].map(key => idOf(state, key));
+    const required = requiredOf(query).map(key => idOf(state, key));
     const excluded = (query?.not ?? []).map(key => idOf(state, key));
     const touches = [...new Set([...query?.read ?? [], ...query?.write ?? []])].map(key => idOf(state, key));
     const writes = (query?.write ?? []).map(key => idOf(state, key));
     const looks = [...new Set(Object.values(declaration.lookup ?? {}).flatMap(lookup => lookup.read ?? []))].map(key => idOf(state, key));
-    const targets = reductionTargets(state, declaration);
+    const targets = reductionTargets(state, label, declaration);
     const folds = targets.map(target => new Float64Array(target.leaves.length));
     const matches: Archetype[] = [];
     let checked = 0;
     const matched = (): readonly Archetype[] => {
         for (; checked < state.archetypes.length; checked++) {
             const archetype = state.archetypes[checked];
-            if (query !== undefined && !archetype.resource && !(archetype.meta && required.length === 0) && required.every(id => archetype.storageOf.has(id)) && !excluded.some(id => archetype.storageOf.has(id))) matches.push(archetype);
+            if (query !== undefined && !archetype.resource && required.every(id => archetype.storageOf.has(id)) && !excluded.some(id => archetype.storageOf.has(id))) matches.push(archetype);
         }
         return matches;
     };
     const remote: RemoteSystem = {
-        channel, index, label,
-        warning: { kind: "blocking", name: label, message: `System "${label}" runs on thread "${thread}", which a joined thread fills, so its tier waits for that thread.` },
+        channel, index, label, leaf, id: idOrNull(leaf),
+        warning: { kind: "blocking", name: label, id: idOrNull(leaf), message: `System "${label}" runs on thread "${thread}", which a joined thread fills, so its tier waits for that thread.` },
         targets, folds, foldCount: folds.reduce((sum, leaves) => sum + leaves.length, 0),
         changed: (query?.changed ?? []).map(key => idOf(state, key)),
         watched: entityWatchesOf(declaration.lookup).map(key => idOf(state, key)),
         archetypes: state.archetypes,
         writes,
-        declaresInput: declaration.input !== undefined,
+        declaresInput: leaf.input !== undefined,
         lastRun: since,
-        result: { flags: 0, segment: undefined, error: undefined },
+        result: { flags: 0, segment: undefined, error: undefined, value: undefined },
         tail: null,
         indexes: lookups.indexes,
     };
@@ -599,6 +607,12 @@ export const createRemoteRunner = (state: State, leaf: Leaf, channel: TaskChanne
         remote,
         joined: null,
         lastRun: () => remote.lastRun,
+        takeResult: () => {
+            const { value } = remote.result;
+            remote.result.value = undefined;
+            return value;
+        },
+        didRun: () => (remote.result.flags & ranFlag) !== 0,
         restart: null,
     };
 };
@@ -622,6 +636,6 @@ export const liftColumns = (archetype: Archetype, ids: readonly number[], since:
         if (storage === undefined || !storage.ticked || storage.columnChanged <= since) continue;
         const stamp = storage.columnChanged;
         for (let row = 0; row < archetype.count; row++) if (storage.changed[row] < stamp) storage.changed[row] = stamp;
-        for (let chunk = 0; chunk <= (archetype.count - 1) >> chunkShift; chunk++) if (storage.chunkChanged[chunk] < stamp) storage.chunkChanged[chunk] = stamp;
+        raiseRange(storage.chunkChanged, storage.blockChanged, 0, archetype.count, stamp);
     }
 };

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import type { Entity } from "../../interface/entity/entity.js";
 import { Finalizer } from "../../interface/finalizer/finalizer.js";
 import { Observe } from "../../observe/index.js";
@@ -7,7 +7,8 @@ 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 { runReported } from "./reports.test-helper.js";
+import { ownId } from "./package-id.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
 
 // Objects a joined thread fills, with the world and the thread on this one, joined through a MessageChannel.
 
@@ -24,7 +25,7 @@ declare module "@adobe/ecs" {
     }
     export interface Components {
         [point]: { type: number };
-        [caption]: { type: { readonly text: string } | null; thread: "remoteTest" };
+        [caption]: { type: Caption; thread: "remoteTest" };
         [widget]: { type: Widget | null; thread: "remoteTest" };
         [kept]: { type: string };
         [guarded]: { type: Widget | null; thread: "remoteTestFinalized" };
@@ -33,55 +34,53 @@ declare module "@adobe/ecs" {
 }
 /** A value that isn't data. */
 type Widget = { readonly draw: () => string };
-Component.register(point, { 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: "remoteTest" });
-Component.register(widget, { thread: "remoteTest" });
-Component.register(kept, { type: { type: "string" } });
+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 };
 /** A widget, or the number a kernel gives one, which only the world's thread could hold. */
-Component.register(handle, { thread: "remoteTest" });
-Component.register(guarded, { thread: "remoteTestFinalized" });
 
-const spawn = System.create({ name: "remoteTest/spawn", input: { type: "object", properties: { x: { type: "number" } } } }, ({ input, commands }) => {
+const spawn = System.create({}, ({ commands }, input: { readonly x: number }) => {
     commands.spawn([point, caption, widget, kept])({ [point]: input.x, [kept]: `k${input.x}`, [widget]: null });
 });
-const nullCaptions = System.create({ name: "remoteTest/nullCaptions", components: { has: [caption, point] } }, (row, { commands }) => {
+const nullCaptions = System.create({ components: { with: [caption, point] } }, (row, { commands }) => {
     commands.add(row.entity, caption, null);
 });
-const restartCaptions = System.create({ name: "remoteTest/restartCaptions", components: { has: [caption, point] } }, (row, { commands }) => {
+const restartCaptions = System.create({ components: { with: [caption, point] } }, (row, { commands }) => {
     commands.add(row.entity, caption, none);
 });
-const dropCaptions = System.create({ name: "remoteTest/dropCaptions", components: { has: [caption] } }, (row, { commands }) => {
+const dropCaptions = System.create({ components: { with: [caption] } }, (row, { commands }) => {
     commands.remove(row.entity, caption);
 });
-const giveCaption = System.create({ name: "remoteTest/giveCaption", components: { has: [point] } }, (row, { commands }) => {
+const giveCaption = System.create({ components: { with: [point] } }, (row, { commands }) => {
     commands.add(row.entity, caption, { text: "a caption only the thread gives" });
 });
-const spawnCaptioned = System.create({ name: "remoteTest/spawnCaptioned" }, ({ commands }) => {
+const spawnCaptioned = System.create({}, ({ commands }) => {
     commands.spawn([point, caption])({ [point]: 1, [caption]: { text: "a caption only the thread gives" } });
 });
 /** A kernel giving the thread's objects null, which they take, and a number, which they don't. */
-const nullCaptionsKernel = System.create({ name: "remoteTest/nullCaptionsKernel", kernel: "cpu", components: { has: [caption], read: [point] } }, (row, { commands }) => {
+const nullCaptionsKernel = System.create({ kernel: true, components: { with: [point, caption] } }, (row, { commands }) => {
     if (row[point] > 0) commands.add(row.entity, caption, null);
 });
-const numberHandlesKernel = System.create({ name: "remoteTest/numberHandlesKernel", kernel: "cpu", components: { read: [point] } }, (row, { commands }) => {
+const numberHandlesKernel = System.create({ kernel: true, components: { with: [point] } }, (row, { commands }) => {
     commands.add(row.entity, handle, row[point]);
 });
 /** Reaches its commands, so it isn't terminal: its tier blocks rather than running as a tail. */
-const readCaptions = System.create({ name: "remoteTest/readCaptions", components: { read: [caption] } }, (row, { commands }) => {
+const readCaptions = System.create({ components: { with: [caption] } }, (row, { commands }) => {
     if (row[caption]?.text === "never") commands.despawn(row.entity);
 });
-const idle = System.create({ name: "remoteTest/idle" }, () => {});
-const after = System.create({ name: "remoteTest/after" }, () => {});
-Finalizer.create({ name: "remoteTest/releaseGuarded", components: { read: [guarded] } }, () => {});
+const idle = System.create({}, () => {});
+const after = System.create({}, () => {});
+Finalizer.create({ components: { with: [guarded] } }, row => { void row[guarded]; });
 
 /** A world shared with a thread on this one, which claims `threads`. */
-const joined = (threads: readonly ("remoteTest" | "remoteTestFinalized")[] = ["remoteTest"]): { readonly world: CreatedWorld; readonly remote: World } => {
+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 });
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads: ["remoteTest"] });
+    await shared;
     return { world, remote };
 };
 
@@ -97,7 +96,7 @@ 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") =>
+const statusOf = (world: CreatedWorld, status: "gone") =>
     until(world.threads, threads => threads.at(-1)?.status === status);
 
 /** The entity a run of `spawn` spawned. */
@@ -110,8 +109,7 @@ const spawnOne = async (world: World, x: number): Promise<Entity> => {
 describe("objects a joined thread fills", () => {
     // The cases of observers reading them are in `observe-joined-cases.test.ts`.
     it("take from the world's thread only their start or null, in commands and spawns", async () => {
-        const { world, remote } = joined();
-        await statusOf(world, "joined");
+        const { world, remote } = await joined();
         await spawnOne(world, 2);
         const message = '"remoteTest/caption" lives on thread "remoteTest", which a joined thread fills, so a command here gives it only its start or null.';
         expect((await runReported(world, giveCaption)).failures.map(failure => failure.message)).toEqual([message]);
@@ -121,33 +119,30 @@ describe("objects a joined thread fills", () => {
         await world.dispose();
     });
     it("take from a kernel only their start or null, its command giving another dropping and its system failing", async () => {
-        const { world, remote } = joined();
-        await statusOf(world, "joined");
+        const { world, remote } = await joined();
         const entity = await spawnOne(world, 6);
         const listed = Observe.entity(remote, entity, { required: [caption, widget] });
         expect(await until(listed, value => value !== null)).toEqual({ [caption]: none, [widget]: null });
         expect((await runReported(world, nullCaptionsKernel)).failures).toEqual([]);
         expect(await until(listed, value => value?.[caption] === null)).toEqual({ [caption]: null, [widget]: null });
         const report = await runReported(world, numberHandlesKernel);
-        expect(report.failures.map(failure => [failure.name, failure.message])).toEqual([["remoteTest/numberHandlesKernel", '"remoteTest/handle" lives on thread "remoteTest", which a joined thread fills, so a command here gives it only its start or null.']]);
+        expect(report.failures.map(failure => [failure.name, failure.message])).toEqual([["numberHandlesKernel", '"remoteTest/handle" lives on thread "remoteTest", which a joined thread fills, so a command here gives it only its start or null.']]);
         expect(report.dropped).toBe(1);
         await remote.dispose();
         await world.dispose();
     });
     it("are read by systems that run on the thread, their tiers warned of", async () => {
-        const { world, remote } = joined();
-        await statusOf(world, "joined");
+        const { world, remote } = await joined();
         await spawnOne(world, 3);
         expect(await runReported(world, readCaptions)).toEqual({
             failures: [], skipped: [], dropped: 0,
-            warnings: [{ kind: "blocking", name: "remoteTest/readCaptions", message: 'System "remoteTest/readCaptions" runs on thread "remoteTest", which a joined thread fills, so its tier waits for that thread.' }],
+            warnings: [{ kind: "blocking", name: "readCaptions", id: ownId("src/implementation/world/remote.test.ts", "readCaptions"), message: 'System "readCaptions" runs on thread "remoteTest", which a joined thread fills, so its tier waits for that thread.' }],
         });
         await remote.dispose();
         await world.dispose();
     });
     it("come back to the world's thread when the thread that filled them is gone, as the start or null each held", async () => {
-        const { world, remote } = joined();
-        await statusOf(world, "joined");
+        const { world, remote } = await joined();
         const first = await spawnOne(world, 4);
         await world.run(nullCaptions);
         const second = await spawnOne(world, 5);
@@ -162,25 +157,28 @@ describe("objects a joined thread fills", () => {
     it("refuse a claim of a thread whose finalizers or systems the joined thread can't run, and take one whose systems it imported", async () => {
         const world = createWorld({ [workers]: 0 });
         await world.run(readCaptions);
-        const taken = joined();
-        await statusOf(taken.world, "joined");
-        expect((await runReported(taken.world, readCaptions)).warnings.map(warning => warning.name)).toEqual(["remoteTest/readCaptions"]);
+        const taken = await joined();
+        expect((await runReported(taken.world, readCaptions)).warnings.map(warning => warning.name)).toEqual(["readCaptions"]);
         await taken.remote.dispose();
         await taken.world.dispose();
         // Declared in a function, so the build gives it no id, and another thread can't name it.
-        const unnamed = System.create({ name: "remoteTest/unnamed", components: { read: [caption] } }, row => { void row[caption]; });
+        const unnamed = System.create({ components: { with: [caption] } }, row => { void row[caption]; });
         await world.run(unnamed);
+        // Both sides of a refused claim say why.
+        const refusedSystem = 'System "unnamed" runs on thread "remoteTest" and has no id, so a joined thread can\'t run it';
         const channel = new MessageChannel();
-        world.share(channel.port1);
-        const remote = join(channel.port2, { threads: ["remoteTest"] });
-        await expect(remote.run(idle)).rejects.toThrow('System "remoteTest/unnamed" runs on thread "remoteTest" and has no id, so a joined thread can\'t run it');
+        const shared = expect(world.share(channel.port1)).rejects.toThrow(refusedSystem);
+        await expect(join(channel.port2, { threads: ["remoteTest"] })).rejects.toThrow(refusedSystem);
+        await shared;
         await statusOf(world, "gone");
-        await remote.dispose();
-        const other = joined(["remoteTestFinalized"]);
         // Declared without a binding, so the build gives it no id.
-        await expect(other.remote.run(idle)).rejects.toThrow('Finalizer "remoteTest/releaseGuarded" runs on thread "remoteTestFinalized" and has no id, so a joined thread can\'t run it');
-        await other.remote.dispose();
-        await other.world.dispose();
+        const refusedFinalizer = /Finalizer "finalizer #\d+" runs on thread "remoteTestFinalized" and has no id, so a joined thread can't run it/;
+        const other = createWorld({ [workers]: 0 });
+        const otherChannel = new MessageChannel();
+        const otherShared = expect(other.share(otherChannel.port1)).rejects.toThrow(refusedFinalizer);
+        await expect(join(otherChannel.port2, { threads: ["remoteTestFinalized"] })).rejects.toThrow(refusedFinalizer);
+        await otherShared;
+        await other.dispose();
         await world.dispose();
     });
 });

package/src/implementation/world/remote.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { declarationOf, labelOf, threadOfDeclaration } from '../../interface/registry/index.js';
 import { makeLocal, makeRemote } from './archetype.js';
 import type { CommandBuffer } from './buffer.js';

package/src/implementation/world/removal-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 { join } from "./create.js";
 import { scopeChannel } from "./port.js";
@@ -13,8 +14,8 @@ export type ToRemovalWorker = { readonly kind: "join"; readonly port: Port };
 export type FromRemovalWorker = { readonly kind: "joined"; readonly systems: number };
 
 const channel = scopeChannel<FromRemovalWorker, ToRemovalWorker>();
-channel.onMessage(message => {
+channel.onMessage(async message => {
     if ("protocol" in message) return;
-    join(message.port, { threads: ["removeTest"] });
+    await join(message.port, { threads: ["removeTest"] });
     channel.post({ kind: "joined", systems: imported.length });
 });

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

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
@@ -60,10 +61,10 @@ const later = (milliseconds: number): Promise<void> => new Promise(resolve => se
 export const removedMidTask = async () => {
     const world: CreatedWorld = createWorld({ [workers]: 0, [always]: true });
     const { port1, port2 } = new MessageChannel();
-    world.share(port1);
+    const shared = world.share(port1);
     const worker = start();
     await worker.ask({ kind: "join", port: port2 }, [port2]);
-    await until(world.threads, threads => threads.at(-1)?.status === "joined");
+    await shared;
     try {
         world.add(first);
         world.add(second);

package/src/implementation/world/remove-joined.test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
@@ -54,9 +55,9 @@ const switchableFrames = (): { immediate: boolean; readonly frame: LoopPlatform[
 const joined = async (frames: Pick<LoopPlatform, "frame"> = timerFrames): Promise<{ readonly world: CreatedWorld; readonly remote: World; readonly ticks: (count: number) => Promise<void>; readonly close: () => Promise<void> }> => {
     const world = createWorld({ [workers]: 0, [always]: true }, { loop: frames });
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    const remote = join(channel.port2, { threads: ["removeTest"] });
-    await until(world.threads, threads => threads.at(-1)?.status === "joined");
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads: ["removeTest"] });
+    await shared;
     removal.world = world;
     world.add(ticking);
     const ticks = async (count: number): Promise<void> => {

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

@@ -1,6 +1,7 @@
-import { Resource } from "../../interface/resource/resource.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
+import type { Schema } from "../../interface/schema/schema.js";
 
 // Keys and systems both threads of the removal tests import: systems on thread "removeTest", which a joined thread
 // fills, the first of each pair removing the second from the task they run in.
@@ -13,17 +14,14 @@ declare module "@adobe/ecs" {
         removeTest: true;
     }
     export interface Resources {
-        [mark]: { type: { readonly text: string }; thread: "removeTest" };
+        [mark]: { type: { readonly text: string }; thread: "removeTest"; default: { text: "m" } };
         [pause]: { type: number };
-        [secondRuns]: { type: number };
+        [secondRuns]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
     }
 }
 /** An object resource of the thread, which places the systems reading it there. */
-Resource.register(mark, { type: { type: "object", properties: { text: { type: "string" } }, default: { text: "m" } }, thread: "removeTest" });
 /** How long, in milliseconds, `first` and `firstTail` spin before they return. */
-Resource.register(pause, { type: { type: "number", default: 0 } });
 /** How many times `second` ran, wherever it ran. */
-Resource.register(secondRuns, { type: { type: "integer", default: 0 } });
 
 /** How many times each system's body was called on this thread. */
 export const calls = { first: 0, second: 0, firstTail: 0, secondTail: 0 };
@@ -40,35 +38,35 @@ const spin = (milliseconds: number): void => {
 };
 
 /** Blocking, since its body reaches `commands`: a tier on the thread, and with `second`, one task. */
-export const first = System.create({ name: "removeTest/first", resources: { read: [mark, pause] } }, ({ resources, commands }) => {
+export const first = System.create({}, ({ resources, commands }) => {
     void commands;
     calls.first += resources[mark].text.length;
     spin(resources[pause]);
     if (removal.armed) removal.world?.remove(second);
 });
 
-export const second = System.create({ name: "removeTest/second", resources: { read: [mark], write: [secondRuns] }, after: [first] }, ({ resources, commands }) => {
+export const second = System.create({ after: [first] }, ({ resources, commands }) => {
     void commands;
     calls.second += resources[mark].text.length;
     resources[secondRuns] += 1;
 });
 
 /** Terminal, so a tail, run with `secondTail` as one task after the tick's sync point. */
-export const firstTail = System.create({ name: "removeTest/firstTail", resources: { read: [mark, pause] } }, ({ resources }) => {
+export const firstTail = System.create({}, ({ resources }) => {
     calls.firstTail += resources[mark].text.length;
     spin(resources[pause]);
     if (removal.armed) removal.world?.remove(secondTail);
 });
 
 /** Terminal, so a tail: removes `removal.target`, once, when it's set. */
-export const removerTail = System.create({ name: "removeTest/removerTail", resources: { read: [mark] } }, ({ resources }) => {
+export const removerTail = System.create({}, ({ resources }) => {
     void resources[mark];
     const { target } = removal;
     removal.target = null;
     if (target !== null) removal.world?.remove(target);
 });
 
-export const secondTail = System.create({ name: "removeTest/secondTail", resources: { read: [mark] }, after: [firstTail] }, ({ resources }) => {
+export const secondTail = System.create({ after: [firstTail] }, ({ resources }) => {
     calls.secondTail += resources[mark].text.length;
 });
 
@@ -76,9 +74,9 @@ export const secondTail = System.create({ name: "removeTest/secondTail", resourc
  * On the world's thread, added while the others come and go, so ticks go on; after `second`, so the tiers of `first` and
  * `second` are one task there.
  */
-export const ticking = System.create({ name: "removeTest/ticking", after: [second] }, () => {});
+export const ticking = System.create({ after: [second] }, () => {});
 
 /** Sets how long `first` and `firstTail` spin. */
-export const setPause = System.create({ name: "removeTest/setPause", input: { type: "object", properties: { milliseconds: { type: "number" } } }, resources: { write: [pause] } }, ({ input, resources }) => {
+export const setPause = System.create({}, ({ resources }, input: { readonly milliseconds: number }) => {
     resources[pause] = input.milliseconds;
 });