@adobe/ecs 0.1.0 → 0.2.1

package/src/perftest/filters.ts

@@ -0,0 +1,124 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { I32 } from "../interface/math/i32/index.js";
+import { workers } from "../interface/resources/workers.js";
+import { System } from "../interface/system/system.js";
+import type { World } from "../interface/world/world.js";
+import { createWorld } from "../implementation/index.js";
+import type { Benchmark } from "./benchmark.js";
+import type { U32 } from "../interface/math/index.js";
+
+// Change filters over one archetype of 100K rows after a writer changed one row, a few, or every one: what finding the
+// rows that pass costs each system that filters, apart from running them.
+
+const value = Symbol("filters/value");
+const other = Symbol("filters/other");
+const at = Symbol("filters/at");
+const out0 = Symbol("filters/out0");
+const out1 = Symbol("filters/out1");
+const out2 = Symbol("filters/out2");
+const out3 = Symbol("filters/out3");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [value]: { type: number };
+        [other]: { type: number };
+        [at]: { type: U32 };
+        [out0]: { type: number };
+        [out1]: { type: number };
+        [out2]: { type: number };
+        [out3]: { type: number };
+    }
+}
+
+const rows = 100_000;
+const filtered = [value, other, at, out0, out1, out2, out3] as const;
+
+const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
+    for (let i = 0; i < input.count; i++) commands.spawn(filtered)({ [value]: 0, [other]: 0, [at]: i, [out0]: 0, [out1]: 0, [out2]: 0, [out3]: 0 });
+});
+
+/** Writes the value of the rows whose `at` is `first` plus a multiple of `stride`. */
+const write = System.create({
+    kernel: true,
+    components: { with: [at, value] },
+}, (row, _context, input: { readonly first: I32; readonly stride: I32 }) => {
+    const offset = row[at] - input.first;
+    if (offset >= 0 && offset % input.stride === 0) row[value] += 1;
+});
+
+let seen = 0;
+/** Main-thread systems each filtering on `value`'s changes. */
+const readers = System.create({
+    systems: Array.from({ length: 8 }, (_, i) => System.create({ components: { with: [value], changed: [value] } }, row => {
+        seen += row[value];
+    })),
+});
+/** The same filtering on `value`'s or `other`'s changes, of which only `value` is written. */
+const readersOfTwo = System.create({
+    systems: Array.from({ length: 8 }, (_, i) => System.create({ components: { with: [value], changed: [value, other] } }, row => {
+        seen += row[value];
+    })),
+});
+/** Kernels each filtering on `value`'s changes, writing an output of its own. */
+const kernels = System.create({
+    systems: [
+        System.create({ kernel: true, components: { with: [value, out0], changed: [value] } }, row => { row[out0] = row[value] * 2; }),
+        System.create({ kernel: true, components: { with: [value, out1], changed: [value] } }, row => { row[out1] = row[value] * 3; }),
+        System.create({ kernel: true, components: { with: [value, out2], changed: [value] } }, row => { row[out2] = row[value] * 4; }),
+        System.create({ kernel: true, components: { with: [value, out3], changed: [value] } }, row => { row[out3] = row[value] * 5; }),
+    ],
+});
+
+/** The fastest run of `measured` right after a write of every `stride`th row from a moving first row. */
+const afterWrites = async (measured: System, stride: number): Promise<number> => {
+    const world: World = createWorld({ [workers]: 0 });
+    await world.run(seed, { count: rows });
+    await world.run(measured);
+    let best = Infinity;
+    const warm = 20;
+    for (let i = 0; i < warm + 200; i++) {
+        await world.run(write, { first: (i * 7919) % Math.min(stride, rows), stride });
+        const start = performance.now();
+        await world.run(measured);
+        if (i >= warm) best = Math.min(best, performance.now() - start);
+    }
+    await world.dispose();
+    return best;
+};
+
+const cases = [
+    { name: "one", stride: rows * 2, said: "one row changed" },
+    { name: "few", stride: 10_000, said: "ten rows changed, 10,000 apart" },
+    { name: "all", stride: 1, said: "every row changed" },
+] as const;
+
+export const filterBenchmarks: readonly Benchmark[] = [
+    ...cases.map(({ name, stride, said }): Benchmark => ({
+        name: `changed ${name} 100K`,
+        operation: `Eight main-thread systems filtering on \`changed\` over 100K rows after ${said}: views and derived values reacting to edits.`,
+        per: "systems",
+        n: 8,
+        typical: [1, 100],
+        best: { bytes: 0, basis: "Finding the changed rows could cost nothing beyond running them." },
+        run: () => afterWrites(readers, stride),
+    })),
+    {
+        name: "changed one 100K two filters",
+        operation: "Eight main-thread systems filtering on `changed` of two components over 100K rows after one row's first component changed.",
+        per: "systems",
+        n: 8,
+        typical: [1, 100],
+        best: { bytes: 0, basis: "Finding the changed row could cost nothing beyond running it." },
+        run: () => afterWrites(readersOfTwo, rows * 2),
+    },
+    ...cases.map(({ name, stride, said }): Benchmark => ({
+        name: `changed ${name} 100K kernels`,
+        operation: `Four kernels filtering on \`changed\` over 100K rows after ${said}, on the world's thread: derived columns kept current.`,
+        per: "systems",
+        n: 4,
+        typical: [1, 100],
+        best: { bytes: 0, basis: "Finding the changed rows could cost nothing beyond running them." },
+        run: () => afterWrites(kernels, stride),
+    })),
+];
+
+export const seenTotal = (): number => seen;

package/src/perftest/finalized.ts

@@ -1,45 +1,81 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
-import { Component } from "../interface/component/component.js";
 import { Finalizer } from "../interface/finalizer/finalizer.js";
 import { workers } from "../interface/resources/workers.js";
 import { System } from "../interface/system/system.js";
 import { createWorld, type CreatedWorld } from "../implementation/index.js";
 import type { Benchmark } from "./benchmark.js";
-import { runReported } from "../implementation/world/reports.test-helper.js";
+import { runReported } from "../implementation/world/outcomes.test-helper.js";
+import type { Vec3 } from "../interface/math/index.js";
 
 // Despawning entities whose objects a joined thread fills, with a finalizer on that thread: the world's thread writes
 // each stop's declared struct reads into the thread's stop list and doesn't wait for it. The joined thread is
-// `joined.ts`, which imports this module, so it runs the finalizer.
+// `joined.ts`, which imports this module, so it runs the finalizers. A second finalizer, over other entities, reads a
+// string resource too, and a third two linear resources, which each sync point's stop list holds copies of.
 
 const spot = Symbol("finalized/spot");
 const handle = Symbol("finalized/handle");
+const noted = Symbol("finalized/noted");
+const note = Symbol("finalized/note");
+const measured = Symbol("finalized/measured");
+const scale = Symbol("finalized/scale");
+const offset = Symbol("finalized/offset");
 declare module "@adobe/ecs" {
     export interface Threads {
         finalizedBenchmark: true;
     }
     export interface Components {
-        [spot]: { type: readonly [number, number, number] };
+        [spot]: { type: Vec3 };
         [handle]: { type: { readonly release: () => void } | null; thread: "finalizedBenchmark" };
+        [noted]: { type: { readonly release: () => void } | null; thread: "finalizedBenchmark" };
+        [measured]: { type: { readonly release: () => void } | null; thread: "finalizedBenchmark" };
+    }
+    export interface Resources {
+        [note]: { type: string; default: "released" };
+        [scale]: { type: number; default: 1 };
+        [offset]: { type: Vec3 };
     }
 }
-Component.register(spot, { type: { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } });
 /** An object of the joined thread, as a DOM node or a GPU handle is. */
-Component.register(handle, { thread: "finalizedBenchmark" });
 
 /** Entities each timed sync point despawns. */
 export const despawnedObjects = 10_000;
 
 /** On the joined thread: what the finalizer released. */
 export const releases = { count: 0 };
-export const release = Finalizer.create({ name: "finalized/release", components: { read: [handle, spot] } }, row => {
+export const release = Finalizer.create({ components: { with: [handle, spot] } }, row => {
     row[handle]?.release();
     if (row[spot][0] >= 0) releases.count++;
 });
 
-const spawn = System.create({ name: "finalized/spawn" }, ({ commands }) => {
+/** On the joined thread: the same, reading the world's string resource too. */
+export const releaseNoted = Finalizer.create({ components: { with: [noted, spot] } }, (row, { resources }) => {
+    row[noted]?.release();
+    if (row[spot][0] >= 0 && resources[note].length > 0) releases.count++;
+});
+
+/** On the joined thread: the same, reading two linear resources of the world's too. */
+export const releaseMeasured = Finalizer.create({ components: { with: [measured, spot] } }, (row, { resources }) => {
+    row[measured]?.release();
+    if (row[spot][0] * resources[scale] + resources[offset][0] >= 0) releases.count++;
+});
+
+const spawn = System.create({}, ({ commands }) => {
     for (let k = 0; k < despawnedObjects; k++) commands.spawn([spot, handle])({ [spot]: [k, 0, 0], [handle]: null });
 });
-const despawn = System.create({ name: "finalized/despawn", components: { has: [handle, spot] } }, (row, { commands }) => {
+const despawn = System.create({ kernel: false, components: { with: [handle, spot] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+const spawnNoted = System.create({}, ({ commands }) => {
+    for (let k = 0; k < despawnedObjects; k++) commands.spawn([spot, noted])({ [spot]: [k, 0, 0], [noted]: null });
+});
+const spawnMeasured = System.create({}, ({ commands }) => {
+    for (let k = 0; k < despawnedObjects; k++) commands.spawn([spot, measured])({ [spot]: [k, 0, 0], [measured]: null });
+});
+const despawnMeasured = System.create({ kernel: false, components: { with: [measured, spot] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+const despawnNoted = System.create({ kernel: false, components: { with: [noted, spot] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 
@@ -49,9 +85,10 @@ const joinedFile = "./joined.js";
 const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate: () => Promise<void> }> => {
     const message = (port: unknown) => ({ kind: "port", port, threads: ["finalizedBenchmark"] });
     let terminate: () => Promise<void>;
+    let shared: Promise<void>;
     if (typeof globalThis.Worker === "function") {
         const { port1, port2 } = new MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new globalThis.Worker(new URL("./joined.js", import.meta.url), { type: "module" });
         await new Promise(resolve => {
             worker.onmessage = resolve;
@@ -62,7 +99,7 @@ const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate:
     else {
         const threads = globalThis.process.getBuiltinModule("node:worker_threads");
         const { port1, port2 } = new threads.MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new threads.Worker(new URL(joinedFile, import.meta.url));
         await new Promise(resolve => {
             worker.once("message", resolve);
@@ -70,15 +107,7 @@ const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate:
         });
         terminate = async () => { await worker.terminate(); };
     }
-    await new Promise<void>(resolve => {
-        let done = false;
-        const stop = world.threads(threads => {
-            if (done || threads.at(-1)?.status !== "joined") return;
-            done = true;
-            queueMicrotask(() => stop());
-            resolve();
-        });
-    });
+    await shared;
     return { terminate };
 };
 
@@ -86,15 +115,15 @@ const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate:
  * The fastest of `rounds` sync points despawning `despawnedObjects` entities holding the joined thread's objects,
  * timed on the world's thread, each after a spawn and a pause in which the thread finalizes the last.
  */
-const despawnObjects = async (rounds = 30): Promise<number> => {
+const despawnObjects = async (spawning: typeof spawn = spawn, despawning: typeof despawn = despawn, rounds = 30): Promise<number> => {
     const world = createWorld({ [workers]: 0 });
     const joined = await startClaiming(world);
     let best = Infinity;
     try {
         for (let round = 0; round < rounds; round++) {
-            await world.run(spawn);
+            await world.run(spawning);
             const start = performance.now();
-            const report = await runReported(world, despawn);
+            const report = await runReported(world, despawning);
             const time = performance.now() - start;
             if (report.failures.length > 0) throw new Error(`despawn objects: ${report.failures[0].message}`);
             if (round > 1) best = Math.min(best, time);
@@ -103,8 +132,9 @@ const despawnObjects = async (rounds = 30): Promise<number> => {
         }
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
     }
     return best;
 };
@@ -119,4 +149,22 @@ export const finalizedBenchmarks: readonly Benchmark[] = [
         best: { bytes: 56, basis: "Each despawn frees its 8-byte location and entity, and writes its stop: its entity, archetype, row and tag, 20 bytes, and its 12-byte vec3, read and written." },
         run: () => despawnObjects(),
     },
+    {
+        name: "despawn objects 10K string resource",
+        operation: "`despawn objects 10K` with the finalizer reading a string resource too, whose record the sync point's stop list holds a copy of, so the thread reads it as it was before apply.",
+        per: "despawns",
+        n: despawnedObjects,
+        typical: [1, 10_000],
+        best: { bytes: 56, basis: "As `despawn objects 10K`: the resource's copy is once per sync point." },
+        run: () => despawnObjects(spawnNoted, despawnNoted),
+    },
+    {
+        name: "despawn objects 10K linear resource",
+        operation: "`despawn objects 10K` with the finalizer reading a number and a vec3 resource too, which the sync point's stop list holds copies of, so the thread reads them as they were before apply.",
+        per: "despawns",
+        n: despawnedObjects,
+        typical: [1, 10_000],
+        best: { bytes: 56, basis: "As `despawn objects 10K`: the resources' copies are once per sync point." },
+        run: () => despawnObjects(spawnMeasured, despawnMeasured),
+    },
 ];

package/src/perftest/flat.ts

@@ -1,6 +1,6 @@
-import { Component } from "../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../interface/system/system.js";
-import { Archetype } from '../interface/archetype/archetype.js';
+import type { F32, U32 } from '../interface/math/index.js';
 
 // Mirrors adobe/data's ecs2 `create` perftest (packages/data/src/perftest/ecs2-perf.ts): 1M particles of eight scalar
 // components, interleaved over four archetypes by visible/enabled, each with its own values.
@@ -18,48 +18,38 @@ export const enabled = Symbol("flat/enabled");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [color]: { type: number };
-        [mass]: { type: number };
-        [positionX]: { type: number };
-        [positionY]: { type: number };
-        [positionZ]: { type: number };
-        [velocityX]: { type: number };
-        [velocityY]: { type: number };
-        [velocityZ]: { type: number };
+        [color]: { type: U32 };
+        [mass]: { type: F32 };
+        [positionX]: { type: F32 };
+        [positionY]: { type: F32 };
+        [positionZ]: { type: F32 };
+        [velocityX]: { type: F32 };
+        [velocityY]: { type: F32 };
+        [velocityZ]: { type: F32 };
         [visible]: { type: true };
         [enabled]: { type: true };
     }
 }
 
-Component.register(color, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
-Component.register(mass, { type: { type: "number", precision: 1 } });
-Component.register(positionX, { type: { type: "number", precision: 1 } });
-Component.register(positionY, { type: { type: "number", precision: 1 } });
-Component.register(positionZ, { type: { type: "number", precision: 1 } });
-Component.register(velocityX, { type: { type: "number", precision: 1 } });
-Component.register(velocityY, { type: { type: "number", precision: 1 } });
-Component.register(velocityZ, { type: { type: "number", precision: 1 } });
-Component.register(visible, { type: { const: true } });
-Component.register(enabled, { type: { const: true } });
 
 const scalars = [color, mass, positionX, positionY, positionZ, velocityX, velocityY, velocityZ] as const;
 /** Entity i goes to archetype i % 4, like ecs2's seedSingle. */
 const archetypes = [
-    Archetype.create([...scalars, visible, enabled]),
-    Archetype.create([...scalars, visible]),
-    Archetype.create([...scalars, enabled]),
-    Archetype.create(scalars),
+    [...scalars, visible, enabled] as const,
+    [...scalars, visible] as const,
+    [...scalars, enabled] as const,
+    scalars,
 ] as const;
 
 /** Spawns with values passed inline. */
-export const spawnFlat = System.create({ name: "flat/spawn", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const spawnFlat = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) {
         commands.spawn(archetypes[i % 4])({ [color]: 0xff00ff, [mass]: 10, [positionX]: i + 1, [positionY]: i + 1, [positionZ]: i + 1, [velocityX]: -i, [velocityY]: -i, [velocityZ]: -i });
     }
 });
 
 /** The same spawns with each value object built first, as values from data or from another system's results are. */
-export const spawnFlatDynamic = System.create({ name: "flat/dynamic", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const spawnFlatDynamic = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) {
         const values = { [color]: 0xff00ff, [mass]: 10, [positionX]: i + 1, [positionY]: i + 1, [positionZ]: i + 1, [velocityX]: -i, [velocityY]: -i, [velocityZ]: -i };
         commands.spawn(archetypes[i % 4])(values);

package/src/perftest/growth.ts

@@ -1,6 +1,6 @@
-import { Archetype } from "../interface/archetype/archetype.js";
-import { Component } from "../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../interface/system/system.js";
+import type { F32 } from "../interface/math/index.js";
 
 // A hundred archetypes, each grown at once: what a sync point costs where every archetype it touches grows.
 
@@ -15,7 +15,7 @@ const g6 = Symbol("growth/g6");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
+        [value]: { type: F32 };
         [g0]: { type: true };
         [g1]: { type: true };
         [g2]: { type: true };
@@ -26,30 +26,22 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(g0, { type: { const: true } });
-Component.register(g1, { type: { const: true } });
-Component.register(g2, { type: { const: true } });
-Component.register(g3, { type: { const: true } });
-Component.register(g4, { type: { const: true } });
-Component.register(g5, { type: { const: true } });
-Component.register(g6, { type: { const: true } });
 
 const tags = [g0, g1, g2, g3, g4, g5, g6] as const;
 /** `value` with each of the first 100 sets of the seven tags, by their bits. */
-const hundred = Array.from({ length: 100 }, (_, bits) => Archetype.create([value, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)]));
+const hundred = Array.from({ length: 100 }, (_, bits) => [value, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)] as const);
 
 /** Spawns `count` entities into each of the hundred archetypes. */
-export const fillEach = System.create({ name: "growth/fillEach", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const fillEach = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (const archetype of hundred) for (let i = 0; i < input.count; i++) commands.spawn(archetype)({ [value]: i });
 });
 
 /** One spawn into each of the hundred archetypes. */
-export const spawnEach = System.create({ name: "growth/spawnEach" }, ({ commands }) => {
+export const spawnEach = System.create({}, ({ commands }) => {
     for (const archetype of hundred) commands.spawn(archetype)({ [value]: 0 });
 });
 
 /** A kernel over every row of the hundred archetypes. */
-export const bumpEach = System.create({ name: "growth/bumpEach", kernel: "cpu", components: { write: [value] } }, row => {
+export const bumpEach = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] + 1;
 });

package/src/perftest/handoff.ts

@@ -1,12 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
-import { Resource } from "../interface/resource/resource.js";
 import { always } from "../interface/resources/always.js";
 import { eachTick } from "./observer.js";
 import { workers } from "../interface/resources/workers.js";
 import { System } from "../interface/system/system.js";
 import { backToBack, createWorld, type CreatedWorld } from "../implementation/index.js";
 import type { Benchmark } from "./benchmark.js";
-import { runReported } from "../implementation/world/reports.test-helper.js";
+import { runReported } from "../implementation/world/outcomes.test-helper.js";
 
 // Benchmarks of systems on a joined thread, which claims "handoffBenchmark": tiers handing off between the world's
 // thread and the joined one, and consecutive tiers on the joined one, which run as one task. Their systems reach their
@@ -22,33 +22,32 @@ declare module "@adobe/ecs" {
     }
 }
 /** An object of the joined thread, which places the systems reading it there. */
-Resource.register(token, { thread: "handoffBenchmark" });
 
-const here0 = System.create({ name: "handoff/here0" }, () => {});
-const there0 = System.create({ name: "handoff/there0", resources: { read: [token] }, after: [here0] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here1 = System.create({ name: "handoff/here1", after: [there0] }, () => {});
-const there1 = System.create({ name: "handoff/there1", resources: { read: [token] }, after: [here1] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here2 = System.create({ name: "handoff/here2", after: [there1] }, () => {});
-const there2 = System.create({ name: "handoff/there2", resources: { read: [token] }, after: [here2] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here3 = System.create({ name: "handoff/here3", after: [there2] }, () => {});
-const there3 = System.create({ name: "handoff/there3", resources: { read: [token] }, after: [here3] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here4 = System.create({ name: "handoff/here4", after: [there3] }, () => {});
-const there4 = System.create({ name: "handoff/there4", resources: { read: [token] }, after: [here4] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here0 = System.create({}, () => {});
+const there0 = System.create({ after: [here0] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here1 = System.create({ after: [there0] }, () => {});
+const there1 = System.create({ after: [here1] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here2 = System.create({ after: [there1] }, () => {});
+const there2 = System.create({ after: [here2] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here3 = System.create({ after: [there2] }, () => {});
+const there3 = System.create({ after: [here3] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here4 = System.create({ after: [there3] }, () => {});
+const there4 = System.create({ after: [here4] }, ({ resources, commands }) => { void resources[token]; void commands; });
 /** Ten tiers alternating the world's thread and the joined one, empty systems. */
-export const handoff = System.create({ name: "handoff/ticks", systems: [here0, there0, here1, there1, here2, there2, here3, there3, here4, there4] });
+export const handoff = System.create({ systems: [here0, there0, here1, there1, here2, there2, here3, there3, here4, there4] });
 
-const fused0 = System.create({ name: "handoff/fused0", resources: { read: [token] } }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused1 = System.create({ name: "handoff/fused1", resources: { read: [token] }, after: [fused0] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused2 = System.create({ name: "handoff/fused2", resources: { read: [token] }, after: [fused1] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused3 = System.create({ name: "handoff/fused3", resources: { read: [token] }, after: [fused2] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused4 = System.create({ name: "handoff/fused4", resources: { read: [token] }, after: [fused3] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused5 = System.create({ name: "handoff/fused5", resources: { read: [token] }, after: [fused4] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused6 = System.create({ name: "handoff/fused6", resources: { read: [token] }, after: [fused5] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused7 = System.create({ name: "handoff/fused7", resources: { read: [token] }, after: [fused6] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused8 = System.create({ name: "handoff/fused8", resources: { read: [token] }, after: [fused7] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused9 = System.create({ name: "handoff/fused9", resources: { read: [token] }, after: [fused8] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused0 = System.create({}, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused1 = System.create({ after: [fused0] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused2 = System.create({ after: [fused1] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused3 = System.create({ after: [fused2] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused4 = System.create({ after: [fused3] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused5 = System.create({ after: [fused4] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused6 = System.create({ after: [fused5] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused7 = System.create({ after: [fused6] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused8 = System.create({ after: [fused7] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused9 = System.create({ after: [fused8] }, ({ resources, commands }) => { void resources[token]; void commands; });
 /** Ten consecutive tiers on the joined thread, empty systems. */
-export const fused = System.create({ name: "handoff/fused", systems: [fused0, fused1, fused2, fused3, fused4, fused5, fused6, fused7, fused8, fused9] });
+export const fused = System.create({ systems: [fused0, fused1, fused2, fused3, fused4, fused5, fused6, fused7, fused8, fused9] });
 
 /** Every system the joined thread runs, which it imports so the world can place them there. */
 export const handoffSystems: readonly System<void>[] = [handoff, fused];
@@ -65,9 +64,10 @@ const joinedFile = "./joined.js";
 const startClaiming = async (world: CreatedWorld): Promise<Joined> => {
     const message = (port: unknown) => ({ kind: "port", port, threads: ["handoffBenchmark"] });
     let joined: Joined;
+    let shared: Promise<void>;
     if (typeof globalThis.Worker === "function") {
         const { port1, port2 } = new MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new globalThis.Worker(new URL("./joined.js", import.meta.url), { type: "module" });
         await new Promise(resolve => {
             worker.onmessage = resolve;
@@ -78,7 +78,7 @@ const startClaiming = async (world: CreatedWorld): Promise<Joined> => {
     else {
         const threads = globalThis.process.getBuiltinModule("node:worker_threads");
         const { port1, port2 } = new threads.MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new threads.Worker(new URL(joinedFile, import.meta.url));
         await new Promise(resolve => {
             worker.once("message", resolve);
@@ -87,15 +87,7 @@ const startClaiming = async (world: CreatedWorld): Promise<Joined> => {
         joined = { terminate: async () => { await worker.terminate(); } };
     }
     // Its claims are active once it joined, so the systems run there from the first tick.
-    await new Promise<void>(resolve => {
-        let done = false;
-        const stop = world.threads(threads => {
-            if (done || threads.at(-1)?.status !== "joined") return;
-            done = true;
-            queueMicrotask(() => stop());
-            resolve();
-        });
-    });
+    await shared;
     return joined;
 };
 
@@ -125,8 +117,9 @@ const ticksBest = async (system: System<void>, stretches = 5): Promise<number> =
         if (report.failures.length > 0 || report.warnings.length === 0) throw new Error(`handoff: the joined thread didn't run its systems: ${report.failures[0]?.message ?? "none placed there"}.`);
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
         driver.close();
     }
     return best;