@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/remote-finalizers.test-helper.ts

@@ -1,9 +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 { Finalizer } from "../../interface/finalizer/finalizer.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
+import type { Schema } from "../../interface/schema/schema.js";
+import type { Vec3 } from "../../interface/math/index.js";
 
 // Keys, systems and a finalizer both threads of the remote finalizers tests import: a finalizer on thread
 // "remoteFinalizersTest", which a joined thread fills, reading structs, a constant, that thread's objects and its
@@ -17,35 +18,54 @@ export const widget = Symbol("remoteFinalizersTest/widget");
 export const label = Symbol("remoteFinalizersTest/label");
 export const tone = Symbol("remoteFinalizersTest/tone");
 export const title = Symbol("remoteFinalizersTest/title");
+export const headed = Symbol("remoteFinalizersTest/headed");
+export const heading = Symbol("remoteFinalizersTest/heading");
+export const subheading = Symbol("remoteFinalizersTest/subheading");
+export const level = Symbol("remoteFinalizersTest/level");
+export const origin = Symbol("remoteFinalizersTest/origin");
+export const caption = Symbol("remoteFinalizersTest/caption");
+export const lit = Symbol("remoteFinalizersTest/lit");
+export const tint = Symbol("remoteFinalizersTest/tint");
+export const sample = Symbol("remoteFinalizersTest/sample");
+export const material = Symbol("remoteFinalizersTest/material");
 declare module "@adobe/ecs" {
     export interface Threads {
         remoteFinalizersTest: true;
     }
     export interface Components {
-        [serial]: { type: number };
+        [serial]: { type: Schema.Type<{ type: "integer" }> };
         [place]: { type: readonly [number, number] };
         [marked]: { type: true };
         [flagged]: { type: true };
         [widget]: { type: Widget | null; thread: "remoteFinalizersTest" };
-        [label]: { type: { readonly text: string } | null; thread: "remoteFinalizersTest" };
+        [label]: { type: { readonly text: string } | null; thread: "remoteFinalizersTest"; default: { text: "none" } };
         [title]: { type: string };
+        [headed]: { type: true };
     }
     export interface Resources {
-        [tone]: { type: { readonly text: string }; thread: "remoteFinalizersTest" };
+        [tone]: { type: { readonly text: string }; thread: "remoteFinalizersTest"; default: { text: "quiet" } };
+        [heading]: { type: string; default: "h" };
+        [subheading]: { type: string; default: "s" };
+        [level]: { type: number; default: -1 };
+        [origin]: { type: readonly [number, number]; default: [-1, -1] };
+        [caption]: { type: string; default: "c" };
+        [lit]: { type: boolean };
+        [tint]: { type: Vec3; default: [-1, -1, -1] };
+        [sample]: { type: Schema.Type<{ type: "object"; properties: { on: { type: "boolean" }; count: { type: "integer"; minimum: 0; maximum: 4294967295 }; weight: { type: "number" }; ratio: { type: "number"; precision: 1 } } }>; default: { on: false; count: 0; weight: -1; ratio: -1 } };
+        [material]: { type: Schema.Type<{ type: "object"; properties: { alpha: { type: "number"; precision: 1 }; color: { type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }; glossy: { type: "boolean" } }; layout: "storage" }>; default: { alpha: -1; color: [-1, -1, -1]; glossy: false } };
     }
 }
 /** A value that isn't data, which only its thread holds. */
 type Widget = { readonly tag: string; readonly draw: () => string };
-Component.register(serial, { type: { type: "integer" } });
-Component.register(place, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
-Component.register(marked, { type: { const: true } });
-Component.register(flagged, { type: { const: true } });
-Component.register(widget, { thread: "remoteFinalizersTest" });
 const text = { type: "object", properties: { text: { type: "string" } } } as const;
-Component.register(label, { type: { anyOf: [text, { type: "null" }], default: { text: "none" } }, thread: "remoteFinalizersTest" });
-Resource.register(tone, { type: { ...text, default: { text: "quiet" } }, thread: "remoteFinalizersTest" });
 /** A string, in shared memory, which the world's thread writes and the finalizer on the thread reads. */
-Component.register(title, { type: { type: "string" } });
+/** A string resource, which the world's thread writes and the finalizer on the thread reads. */
+/** Linear resources, a number and a struct, which the world's thread writes and the finalizer on the thread reads. */
+/** Resources of mixed widths: a string, a boolean (1 byte), an f32 vec3 (12), a padded CPU struct (24) and a storage struct (32). */
+type Sample = { readonly on: boolean; readonly count: number; readonly weight: number; readonly ratio: number };
+type Material = { readonly alpha: number; readonly color: readonly [number, number, number]; readonly glossy: boolean };
+const f32 = { type: "number", precision: 1 } as const;
+const vec3 = { type: "array", items: f32, minItems: 3, maxItems: 3 } as const;
 
 /** A stop as the finalizer saw it, on the thread it ran on. */
 export type Released = { readonly serial: number; readonly place: readonly number[]; readonly marked: boolean; readonly widget: string | null; readonly label: string | null; readonly tone: string };
@@ -57,9 +77,9 @@ export const finalized: Entity[] = [];
 export const throwing = new Set<number>();
 
 /** On the finalizers' thread: what each stop held there, its structs before the sync point applied. */
-export const release = Finalizer.create({ name: "remoteFinalizersTest/release", components: { read: [serial, place, marked, widget, label] }, resources: { read: [tone] } }, (row, { resources }) => {
+export const release = Finalizer.create({ components: { with: [serial, place, marked, widget, label] } }, (row, { resources }) => {
     finalized.push(row.entity);
-    released.push({ serial: row[serial], place: [...row[place]], marked: row[marked], widget: row[widget]?.tag ?? null, label: row[label]?.text ?? null, tone: resources[tone]?.text });
+    released.push({ serial: row[serial], place: [...row[place]], marked: row[marked], widget: row[widget]?.tag ?? null, label: row[label]?.text ?? null, tone: resources[tone].text });
     if (throwing.has(row[serial])) throw new Error(`remoteFinalizersTest: ${row[serial]} throws`);
 });
 
@@ -67,54 +87,126 @@ export const release = Finalizer.create({ name: "remoteFinalizersTest/release",
 export const entitled: { readonly serial: number; readonly title: string }[] = [];
 
 /** On the finalizers' thread: what each titled stop's title was before its sync point applied. */
-export const entitle = Finalizer.create({ name: "remoteFinalizersTest/entitle", components: { read: [serial, title, widget] } }, row => {
+export const entitle = Finalizer.create({ components: { with: [serial, title, widget] } }, row => {
+    // Reading its widget places it on the widget's thread.
+    void row[widget];
     entitled.push({ serial: row[serial], title: row[title] });
 });
 
+/** Every headed stop finalized on this thread, in order, with the heading it read. */
+export const headlined: { readonly serial: number; readonly heading: string }[] = [];
+
+/** On the finalizers' thread: the heading as it was before each headed stop's sync point applied. */
+export const headline = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    headlined.push({ serial: row[serial], heading: resources[heading] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the heading and subheading it read. */
+export const headlinedBoth: { readonly serial: number; readonly heading: string; readonly subheading: string }[] = [];
+
+/** On the finalizers' thread: two string resources as they were before each headed stop's sync point applied. */
+export const headlines = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    headlinedBoth.push({ serial: row[serial], heading: resources[heading], subheading: resources[subheading] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the linear resources it read. */
+export const gauged: { readonly serial: number; readonly level: number; readonly origin: readonly number[] }[] = [];
+
+/** On the finalizers' thread: a number and a struct resource as they were before each headed stop's sync point applied. */
+export const gauge = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    gauged.push({ serial: row[serial], level: resources[level], origin: [...resources[origin]] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the resources of mixed widths it read. */
+export type Surveyed = { readonly serial: number; readonly caption: string; readonly lit: boolean; readonly tint: readonly number[]; readonly sample: Sample; readonly material: Material };
+export const surveyed: Surveyed[] = [];
+
+/** On the finalizers' thread: resources of mixed widths as they were before each headed stop's sync point applied. */
+export const survey = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    const { alpha, color, glossy } = resources[material];
+    surveyed.push({
+        serial: row[serial], caption: resources[caption], lit: resources[lit], tint: [...resources[tint]],
+        sample: { ...resources[sample] }, material: { alpha, color: [...color], glossy },
+    });
+});
+
+/** What `regauge` writes to the resources of mixed widths at a level. */
+export const surveyOf = (at: number): Omit<Surveyed, "serial"> => ({
+    caption: `c${at}`, lit: at > 3, tint: [at, at + 0.5, at * 2],
+    sample: { on: at > 3, count: at * 1000 + 1, weight: at + 0.25, ratio: at * 0.5 + 1 },
+    material: { alpha: at * 0.25 + 1, color: [at + 1, at + 2, at + 3], glossy: at > 3 },
+});
+
+/** From the world's thread: the level, the origin at it, and the resources of mixed widths at it. */
+export const regauge = System.create({}, ({ resources }, input: { readonly level: number }) => {
+    resources[level] = input.level;
+    resources[origin] = [input.level, input.level + 10];
+    const values = surveyOf(input.level);
+    resources[caption] = values.caption;
+    resources[lit] = values.lit;
+    resources[tint] = [values.tint[0], values.tint[1], values.tint[2]];
+    resources[sample] = values.sample;
+    resources[material] = values.material;
+});
+
+/** Spawns headed rows from the world's thread, with the thread's widget at null. */
+export const spawnHeaded = System.create({}, ({ commands }, input: { readonly from: number; readonly count: number }) => {
+    for (let k = input.from; k < input.from + input.count; k++) commands.spawn([serial, headed, widget])({ [serial]: k, [widget]: null });
+});
+/** From the world's thread: the heading and subheading. */
+export const rehead = System.create({}, ({ resources }, input: { readonly heading: string }) => {
+    resources[heading] = input.heading;
+    resources[subheading] = `s${input.heading}`;
+});
+
 /** Spawns titled rows from the world's thread, with the thread's widget at null. */
-export const spawnTitled = System.create({ name: "remoteFinalizersTest/spawnTitled", input: { type: "object", properties: { from: { type: "integer" }, count: { type: "integer" } } } }, ({ input, commands }) => {
+export const spawnTitled = System.create({}, ({ commands }, input: { readonly from: number; readonly count: number }) => {
     for (let k = input.from; k < input.from + input.count; k++) commands.spawn([serial, title, widget])({ [serial]: k, [title]: `t${k}`, [widget]: null });
 });
 /** From the world's thread: every title as another of the same size, so the records of titles let go are reused. */
-export const retitle = System.create({ name: "remoteFinalizersTest/retitle", input: { type: "object", properties: { round: { type: "integer" } } }, components: { write: [title] } }, (row, { input }) => {
+export const retitle = System.create({ components: { with: [title] } }, (row, _context, input: { readonly round: number }) => {
     row[title] = `r${input.round}`;
 });
 
 /** Spawns from the world's thread: structs, the thread's objects at null and their start. */
-export const spawn = System.create({ name: "remoteFinalizersTest/spawn", input: { type: "object", properties: { from: { type: "integer" }, count: { type: "integer" } } } }, ({ input, commands }) => {
+export const spawn = System.create({}, ({ commands }, input: { readonly from: number; readonly count: number }) => {
     for (let k = input.from; k < input.from + input.count; k++) commands.spawn([serial, place, marked, widget, label])({ [serial]: k, [place]: [k, -k], [widget]: null });
 });
 /** On the thread: widgets written in place. */
-export const attach = System.create({ name: "remoteFinalizersTest/attach", components: { read: [serial], write: [widget] } }, row => {
+export const attach = System.create({ components: { with: [serial, widget] } }, row => {
     const tag = `w${row[serial]}`;
     row[widget] = { tag, draw: () => tag };
 });
 /** On the thread: labels given by command, staged there, for odd serials. */
-export const relabel = System.create({ name: "remoteFinalizersTest/relabel", components: { read: [serial, label] } }, (row, { commands }) => {
+export const relabel = System.create({ components: { with: [serial, label] } }, (row, { commands }) => {
     const relabelled = { text: `l${row[serial]}${row[label]?.text === "none" ? "" : "+"}` };
     if (row[serial] % 2 === 1) commands.add(row.entity, label, relabelled);
 });
 /** On the thread: its object resource. */
-export const retone = System.create({ name: "remoteFinalizersTest/retone", input: { type: "object", properties: { tone: { type: "string" } } }, resources: { write: [tone] } }, ({ input, resources }) => {
+export const retone = System.create({}, ({ resources }, input: { readonly tone: string }) => {
     resources[tone] = { text: input.tone };
 });
 /** From the world's thread: places move, so a stop's values are those before the sync point applies. */
-export const shift = System.create({ name: "remoteFinalizersTest/shift", components: { write: [place] } }, row => {
+export const shift = System.create({ components: { with: [place] } }, row => {
     row[place] = [row[place][0] + 100, row[place][1]];
 });
 /** From the world's thread: despawns these serials. */
-export const despawn = System.create({ name: "remoteFinalizersTest/despawn", input: { type: "object", properties: { serials: { type: "array", items: { type: "integer" } } } }, components: { read: [serial] } }, (row, { input, commands }) => {
+export const despawn = System.create({ components: { with: [serial] } }, (row, { commands }, input: { readonly serials: readonly number[] }) => {
     if (input.serials.includes(row[serial])) commands.despawn(row.entity);
 });
 /** From the world's thread: removes widgets of these serials, a stop that despawns nothing. */
-export const strip = System.create({ name: "remoteFinalizersTest/strip", input: { type: "object", properties: { serials: { type: "array", items: { type: "integer" } } } }, components: { read: [serial], has: [widget] } }, (row, { input, commands }) => {
+export const strip = System.create({ components: { with: [serial, widget] } }, (row, { commands }, input: { readonly serials: readonly number[] }) => {
     if (input.serials.includes(row[serial])) commands.remove(row.entity, widget);
 });
 /** From the world's thread: every row moves archetype, flagged on one run and not on the next. */
-export const flag = System.create({ name: "remoteFinalizersTest/flag", components: { has: [serial], not: [flagged] } }, (row, { commands }) => {
+export const flag = System.create({ components: { with: [serial], not: [flagged] } }, (row, { commands }) => {
     commands.add(row.entity, flagged);
 });
-export const unflag = System.create({ name: "remoteFinalizersTest/unflag", components: { has: [serial, flagged] } }, (row, { commands }) => {
+export const unflag = System.create({ components: { with: [serial, flagged] } }, (row, { commands }) => {
     commands.remove(row.entity, flagged);
 });
 

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type { Entity } from "../../interface/entity/entity.js";
 import { Finalizer } from "../../interface/finalizer/finalizer.js";
@@ -9,7 +10,28 @@ import type { World } from "../../interface/world/world.js";
 import { createWorld, join, type CreatedWorld } from "./create.js";
 import { indexOf } from "./entities.js";
 import { attach, despawn, eventually, finalized, marked, place, released, retone, scenario, serial, sorted, spawn, throwing, tone, widget } from "./remote-finalizers.test-helper.js";
-import { runReported } from "./reports.test-helper.js";
+import { catchOutOfBand, runReported } from "./outcomes.test-helper.js";
+
+/** Resources of the world's thread, each added once the thread joined, so the resource entity moves to another archetype. */
+const later = Symbol("remoteFinalizersTest/later");
+const second = Symbol("remoteFinalizersTest/second");
+const third = Symbol("remoteFinalizersTest/third");
+declare module "@adobe/ecs" {
+    export interface Resources {
+        [later]: { type: number };
+        [second]: { type: number };
+        [third]: { type: number };
+    }
+}
+const bump = System.create({}, ({ resources }) => {
+    resources[later] += 1;
+});
+const bumpSecond = System.create({}, ({ resources }) => {
+    resources[second] += 1;
+});
+const bumpThird = System.create({}, ({ resources }) => {
+    resources[third] += 1;
+});
 
 // Finalizers on a joined thread, with the world and the thread on this one, joined through a MessageChannel.
 
@@ -25,16 +47,16 @@ 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);
 
 /** A world shared with a thread on this one, which claims the finalizers' 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: ["remoteFinalizersTest"] });
-    await statusOf(world, "joined");
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads: ["remoteFinalizersTest"] });
+    await shared;
     return { world, remote };
 };
 
@@ -49,7 +71,7 @@ describe("finalizers on a joined thread", () => {
         reset();
         const seen: (readonly symbol[] | null)[][] = [];
         let watching = false;
-        Finalizer.changes({ name: "remoteFinalizersTest/everything" }, changes => {
+        Finalizer.changes({}, changes => {
             if (watching) for (const group of changes.groups) seen.push([group.to, group.added]);
         });
         const { world, remote } = await joined();
@@ -88,7 +110,7 @@ describe("finalizers on a joined thread", () => {
         let reusedEarly = 0;
         let reused = 0;
         // Spawns check each entity they reserve: an index whose last entity stopped is reused only once it was finalized.
-        const check = System.create(identify({ name: "remoteFinalizersTest/check", input: { type: "object", properties: { serial: { type: "integer" } } } }, "remoteFinalizersTest#check"), ({ input, commands }) => {
+        const check = System.create(identify({}, "remoteFinalizersTest#check"), ({ commands }, input: { readonly serial: number }) => {
             const entity = commands.spawn([serial, place, marked, widget])({ [serial]: input.serial, [place]: [0, 0], [widget]: null });
             const before = stopped.get(indexOf(entity));
             if (before === undefined) return;
@@ -110,21 +132,19 @@ describe("finalizers on a joined thread", () => {
         await remote.dispose();
         await world.dispose();
     });
-    it("that throw are in a later run's report", async () => {
+    it("that throw are reported out of band on the world's thread, which hears of it by message", async () => {
         reset();
+        using reported = catchOutOfBand();
         const { world, remote } = await joined();
         await world.run(spawn, { from: 0, count: 3 });
         throwing.add(1);
         await world.run(despawn, { serials: [0, 1, 2] });
         expect(await eventually(() => released.length === 3)).toBe(true);
-        // Its failure reaches the world by message, in time for a later run.
-        let report = await runReported(world, despawn, { serials: [] });
-        for (let k = 0; k < 100 && report.failures.length === 0; k++) {
-            await new Promise(resolve => setTimeout(resolve, 1));
-            report = await runReported(world, despawn, { serials: [] });
-        }
-        expect(report.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["finalizer", "remoteFinalizersTest/release", "remoteFinalizersTest: 1 throws"]]);
+        const error = await reported.until(() => true);
+        expect(error.message).toMatch(/^Finalizer "release" .*failed: remoteFinalizersTest: 1 throws$/);
+        expect(error.cause instanceof Error && error.cause.message).toBe("remoteFinalizersTest: 1 throws");
         expect((await runReported(world, despawn, { serials: [] })).failures).toEqual([]);
+        expect(reported.errors).toHaveLength(1);
         await remote.dispose();
         await world.dispose();
     });
@@ -155,17 +175,63 @@ describe("finalizers on a joined thread", () => {
         await world.dispose();
         expect(released.map(stop => stop.serial)).toEqual([0, 1, 2]);
     });
+    it("read their thread's object resource as the thread holds it, from the first sync point after joining and once the resource entity moved before they ran", async () => {
+        reset();
+        const { world, remote } = await joined();
+        // Stops the thread runs as it first rebuilds, before it holds any row.
+        await world.run(spawn, { from: 0, count: 3 });
+        await world.run(despawn, { serials: [0] });
+        expect(await eventually(() => released.length === 1)).toBe(true);
+        await world.run(retone, { tone: "soft" });
+        // Not awaited: the resource entity moves to another archetype before the thread replays the stop's sync.
+        await Promise.all([world.run(despawn, { serials: [1] }), world.run(bump)]);
+        expect(await eventually(() => released.length === 2)).toBe(true);
+        expect(released.map(stop => [stop.serial, stop.tone])).toEqual([[0, "quiet"], [1, "soft"]]);
+        await remote.dispose();
+        await world.dispose();
+    });
+    it("read their thread's object resource where the resource entity moved since it was last found, before a later write applies", async () => {
+        reset();
+        const { world, remote } = await joined();
+        await world.run(spawn, { from: 0, count: 3 });
+        await world.run(despawn, { serials: [0] });
+        expect(await eventually(() => released.length === 1)).toBe(true);
+        // Replayed, not rebuilt: the resource entity is found in the mirror.
+        await world.run(despawn, { serials: [1] });
+        expect(await eventually(() => released.length === 2)).toBe(true);
+        await world.run(bump);
+        await world.run(retone, { tone: "soft" });
+        // The write after the stop's sync is a task the thread runs once it replayed that sync.
+        await Promise.all([world.run(despawn, { serials: [2] }), world.run(retone, { tone: "loud" })]);
+        expect(await eventually(() => released.length === 3)).toBe(true);
+        expect(released.map(stop => [stop.serial, stop.tone])).toEqual([[0, "quiet"], [1, "quiet"], [2, "soft"]]);
+        await remote.dispose();
+        await world.dispose();
+    });
+    it("read their thread's object resource once the resource entity moved twice before the thread replayed", async () => {
+        reset();
+        const { world, remote } = await joined();
+        await world.run(spawn, { from: 0, count: 2 });
+        await world.run(despawn, { serials: [0] });
+        expect(await eventually(() => released.length === 1)).toBe(true);
+        await world.run(retone, { tone: "soft" });
+        await Promise.all([world.run(despawn, { serials: [1] }), world.run(bumpSecond), world.run(bumpThird)]);
+        expect(await eventually(() => released.length === 2)).toBe(true);
+        expect(released.map(stop => [stop.serial, stop.tone])).toEqual([[0, "quiet"], [1, "soft"]]);
+        await remote.dispose();
+        await world.dispose();
+    });
     // Last: the finalizers it creates stay in the program.
     it("created after the claim run there; one the thread can't name doesn't activate, reported once", async () => {
         reset();
         const { world, remote } = await joined();
         await world.run(spawn, { from: 0, count: 2 });
         const late: string[] = [];
-        Finalizer.create(identify({ name: "remoteFinalizersTest/late", components: { read: [widget, serial] } }, "remoteFinalizersTest#late"), row => { late.push(`${row[serial]}:${String(row[widget])}`); });
+        Finalizer.create(identify({ components: { with: [widget, serial] } }, "remoteFinalizersTest#late"), row => { late.push(`${row[serial]}:${String(row[widget])}`); });
         // Declared in a function, so the build gives it no id.
-        Finalizer.create({ name: "remoteFinalizersTest/unnamed", components: { read: [widget] } }, () => {});
+        Finalizer.create({ components: { with: [widget] } }, row => { void row[widget]; });
         const first = await runReported(world, despawn, { serials: [0] });
-        expect(first.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["finalizer", "remoteFinalizersTest/unnamed", 'Finalizer "remoteFinalizersTest/unnamed" runs on thread "remoteFinalizersTest", which a joined thread fills, and has no id, so that thread can\'t name it; the build gives top-level finalizers one.']]);
+        expect(first.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["finalizer", expect.stringMatching(/^finalizer #\d+$/), expect.stringMatching(/^Finalizer "finalizer #\d+" runs on thread "remoteFinalizersTest", which a joined thread fills, and has no id, so that thread can't name it; the build gives top-level finalizers one\.$/)]]);
         expect(await eventually(() => late.length === 1)).toBe(true);
         expect((await runReported(world, despawn, { serials: [1] })).failures).toEqual([]);
         expect(await eventually(() => late.length === 2)).toBe(true);
@@ -173,8 +239,8 @@ describe("finalizers on a joined thread", () => {
         // Placed there by the thread's object resource alone: stops of rows holding none of its objects, which its log
         // has no entries for, run there too.
         const heard: string[] = [];
-        Finalizer.create(identify({ name: "remoteFinalizersTest/heard", components: { read: [serial], not: [widget] }, resources: { read: [tone] } }, "remoteFinalizersTest#heard"), (row, { resources }) => { heard.push(`${row[serial]}:${resources[tone].text}`); });
-        const plain = System.create({ name: "remoteFinalizersTest/plain" }, ({ commands }) => {
+        Finalizer.create(identify({ components: { with: [serial], not: [widget] } }, "remoteFinalizersTest#heard"), (row, { resources }) => { heard.push(`${row[serial]}:${resources[tone].text}`); });
+        const plain = System.create({}, ({ commands }) => {
             for (let k = 0; k < 3; k++) commands.spawn([serial, place])({ [serial]: 50 + k, [place]: [0, 0] });
         });
         await world.run(plain);

package/src/implementation/world/remote-objects-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 { asEntity } from "./entities.js";
 import { join } from "./create.js";
@@ -13,7 +14,7 @@ export type FromRemoteObjectsWorker = { readonly kind: "watched"; readonly watch
 const channel = scopeChannel<FromRemoteObjectsWorker, ToRemoteObjectsWorker>();
 channel.onMessage(async message => {
     if ("protocol" in message) return;
-    const remote = join(message.port, { threads: ["remoteObjects"] });
+    const remote = await join(message.port, { threads: ["remoteObjects"] });
     const watched = await watch(remote, asEntity(message.entity), message.count, message.observers);
     await remote.dispose();
     channel.post({ kind: "watched", watched });

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

package/src/implementation/world/remote-objects.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";
@@ -49,9 +50,10 @@ export const watchedWhileApplying = async (count: number, observers: Observers):
     const [entity] = await Observe.toPromise(Observe.select(world, { required: [serial], where: { [serial]: 0 } }));
     const worker = start();
     const { port1, port2 } = new MessageChannel();
-    world.share(port1);
+    const shared = world.share(port1);
     world.add(churn);
     const reply = await worker.ask({ kind: "watch", port: port2, entity, count, observers }, [port2]);
+    await shared;
     await worker.terminate();
     await world.dispose();
     driver.close();

package/src/implementation/world/remote-objects.test-helper.ts

@@ -1,4 +1,4 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
@@ -19,21 +19,20 @@ declare module "@adobe/ecs" {
         [serial]: { type: number };
         [phase]: { type: number };
         [flag]: { type: true };
-        [caption]: { type: { readonly text: string } | null; thread: "remoteObjects" };
+        [caption]: { type: Caption; thread: "remoteObjects" };
     }
 }
-Component.register(serial, { type: { type: "number" } });
-Component.register(phase, { type: { type: "number" } });
-Component.register(flag, { type: { const: true } });
 /** 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: "remoteObjects" });
+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 caption's text, null for none, as the watchers record it. */
 const textOf = (value: { readonly text: string } | null): string | null => value === null ? null : value.text;
 
 /** The watched entity, serial 0. */
-export const seed = System.create({ name: "remoteObjectsTest/seed" }, ({ commands }) => {
+export const seed = System.create({}, ({ commands }) => {
     commands.spawn([serial, phase, caption])({ [serial]: 0, [phase]: 0 });
 });
 
@@ -42,7 +41,7 @@ export const seed = System.create({ name: "remoteObjectsTest/seed" }, ({ command
  * flagged when it's odd, so it moves archetype every tick; the other entities despawn, and four more spawn into its
  * archetypes, so rows swap into the holes they leave.
  */
-export const churn = System.create({ name: "remoteObjectsTest/churn", components: { read: [serial], write: [phase] } }, (row, { commands }) => {
+export const churn = System.create({ components: { with: [serial, phase] } }, (row, { commands }) => {
     if (row[serial] !== 0) {
         commands.despawn(row.entity);
         return;
@@ -73,7 +72,7 @@ export type Observers = "factory" | "observer";
 const observer: { entity: Entity | null; seen: ((odd: boolean, held: boolean, text: string | null | undefined) => void) | null } = { entity: null, seen: null };
 
 /** After each sync point, on the joined thread: the watched entity's phase and caption, and whether it's flagged. */
-export const observerWatch = System.create({ name: "remoteObjectsTest/observerWatch", observer: true, lookup: { values: { read: [phase, caption] }, flagged: { has: [flag] } } }, ({ lookup }) => {
+export const observerWatch = System.create({ observer: true, lookup: { values: { with: [phase, caption] }, flagged: { with: [flag] } } }, ({ lookup }) => {
     if (observer.entity === null) return;
     const row = lookup.values(observer.entity);
     if (row === null) return;