@adobe/ecs 0.1.0 → 0.2.1

package/src/perftest/strings.ts

@@ -1,4 +1,4 @@
-import { Component } from "../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { workers } from "../interface/resources/workers.js";
 import { System } from "../interface/system/system.js";
 import type { World } from "../interface/world/world.js";
@@ -17,32 +17,34 @@ declare module "@adobe/ecs" {
         [boxed]: { type: { readonly text: string } };
     }
 }
-Component.register(text, { type: { type: "string" } });
-Component.register(boxed, { type: { type: "object", properties: { text: { type: "string" } } } });
 
 const rows = 10_000;
 
 /** A todo's label, of a typical length, different per row and round. */
 const labelOf = (row: number, round: number): string => `Buy milk and bread #${row}.${round}`;
 
-const seed = System.create({ name: "strings/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) commands.spawn([text, boxed])({ [text]: labelOf(i, 0), [boxed]: { text: labelOf(i, 0) } });
 });
 
 let total = 0;
 let round = 0;
 
-const readText = System.create({ name: "strings/readText", components: { read: [text] } }, row => { total += row[text].length; });
-const readBoxed = System.create({ name: "strings/readBoxed", components: { read: [boxed] } }, row => { total += row[boxed].text.length; });
-const writeText = System.create({ name: "strings/writeText", components: { write: [text] } }, row => { row[text] = labelOf(row.entity, round); });
-const writeBoxed = System.create({ name: "strings/writeBoxed", components: { write: [boxed] } }, row => { row[boxed] = { text: labelOf(row.entity, round) }; });
+const readText = System.create({ components: { with: [text] } }, row => { total += row[text].length; });
+const readBoxed = System.create({ components: { with: [boxed] } }, row => { total += row[boxed].text.length; });
+const writeText = System.create({ components: { with: [text] } }, row => { row[text] = labelOf(row.entity, round); });
+const writeBoxed = System.create({ components: { with: [boxed] } }, row => { row[boxed] = { text: labelOf(row.entity, round) }; });
 
 /** A seeded world, with a joined thread on this one when `shared`, which keeps records of its strings. */
 const seeded = async (shared = false): Promise<{ readonly world: World; readonly dispose: () => Promise<void> }> => {
     const world = createWorld({ [workers]: 0 });
-    const channel = new MessageChannel();
-    if (shared) world.share(channel.port1);
-    const remote = shared ? join(channel.port2, { threads: [] }) : null;
+    let remote: World | null = null;
+    if (shared) {
+        const channel = new MessageChannel();
+        const sharing = world.share(channel.port1);
+        remote = await join(channel.port2, { threads: [] });
+        await sharing;
+    }
     await world.run(seed, { count: rows });
     return {
         world,
@@ -78,7 +80,7 @@ const read = (system: System, name: string) => measure(system, async world => {
 /** Each row's text, as the last write left it. */
 const written = (name: string) => async (world: World): Promise<void> => {
     let wrong = 0;
-    await world.run(System.create({ observer: true, components: { read: [text, boxed] } }, row => {
+    await world.run(System.create({ observer: true, components: { with: [text, boxed] } }, row => {
         if (row[text] !== row[boxed].text && row[text] !== labelOf(row.entity, round) && row[boxed].text !== labelOf(row.entity, round)) wrong++;
     }));
     check(wrong === 0, `${name}: wrong text`);

package/src/perftest/structural.ts

@@ -1,7 +1,7 @@
-import { Archetype } from "../interface/archetype/archetype.js";
-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 { F32, U32 } from "../interface/math/index.js";
 
 // Structural changes one kind at a time: spawns, despawns, adds and removes, through main-thread systems and kernels,
 // each applied by the sync point that ends its run.
@@ -21,11 +21,11 @@ const t3 = Symbol("structural/t3");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [index]: { type: number };
-        [value]: { type: number };
+        [index]: { type: U32 };
+        [value]: { type: F32 };
         [flag]: { type: true };
-        [amount]: { type: number };
-        [extra]: { type: number };
+        [amount]: { type: F32 };
+        [extra]: { type: F32 };
         [spawned]: { type: true };
         [source1]: { type: true };
         [source2]: { type: true };
@@ -36,50 +36,36 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(index, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(amount, { type: { type: "number", precision: 1 } });
-Component.register(extra, { type: { type: "number", precision: 1 } });
-Component.register(flag, { type: { const: true } });
-Component.register(spawned, { type: { const: true } });
-Component.register(source1, { type: { const: true } });
-Component.register(source2, { type: { const: true } });
-Component.register(t0, { type: { const: true } });
-Component.register(t1, { type: { const: true } });
-Component.register(t2, { type: { const: true } });
-Component.register(t3, { type: { const: true } });
 
 const seeded = [
-    Archetype.create([index, value]),
-    Archetype.create([index, value, source1]),
-    Archetype.create([index, value, source2]),
-    Archetype.create([index, value, source1, source2]),
+    [index, value] as const,
+    [index, value, source1] as const,
+    [index, value, source2] as const,
+    [index, value, source1, source2] as const,
 ] as const;
-const made = Archetype.create([index, value, spawned]);
+const made = [index, value, spawned] as const;
 /** Every set of the four tags `t0` to `t3`, by its bits. */
 const tags = [t0, t1, t2, t3] as const;
-const sixteen = Array.from({ length: 16 }, (_, bits) => Archetype.create([index, value, spawned, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)]));
-const several = Archetype.create([flag, amount, extra]);
+const sixteen = Array.from({ length: 16 }, (_, bits) => [index, value, spawned, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)] as const);
+const several = [flag, amount, extra] as const;
 
 const counted = { type: "object", properties: { count: { type: "integer" } } } as const;
 
 /** `count` entities of one archetype, or with `sources: 4`, interleaved over four by two source tags. */
 export const seed = System.create({
-    name: "structural/seed",
-    input: { type: "object", properties: { count: { type: "integer" }, sources: { type: "integer" } } },
-}, ({ input, commands }) => {
+}, ({ commands }, input: { readonly count: number; readonly sources: number }) => {
     for (let i = 0; i < input.count; i++) {
         commands.spawn(seeded[input.sources === 1 ? 0 : i % 4])({ [index]: i, [value]: i });
     }
 });
 
 /** `count` spawns of one archetype. */
-export const spawnBulk = System.create({ name: "structural/spawnBulk", input: counted }, ({ input, commands }) => {
+export const spawnBulk = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) commands.spawn(made)({ [index]: i, [value]: i });
 });
 
 /** One spawn of each of four archetypes: a run's fixed cost per spawn. */
-export const spawnSingles = System.create({ name: "structural/spawnSingles" }, ({ commands }) => {
+export const spawnSingles = System.create({}, ({ commands }) => {
     commands.spawn(made)({ [index]: 0, [value]: 0 });
     commands.spawn(sixteen[1])({ [index]: 1, [value]: 1 });
     commands.spawn(sixteen[2])({ [index]: 2, [value]: 2 });
@@ -87,78 +73,78 @@ export const spawnSingles = System.create({ name: "structural/spawnSingles" }, (
 });
 
 /** `count` spawns over sixteen archetypes, entity i into archetype i % 16: more component sets than spawns cache. */
-export const spawnSixteen = System.create({ name: "structural/spawnSixteen", input: counted }, ({ input, commands }) => {
+export const spawnSixteen = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) {
         commands.spawn(sixteen[i % 16])({ [index]: i, [value]: i });
     }
 });
 
 /** A spawn per row, from a kernel. */
-export const spawnKernel = System.create({ name: "structural/spawnKernel", kernel: "cpu", components: { read: [index], not: [spawned] } }, (row, { commands }) => {
+export const spawnKernel = System.create({ kernel: true, components: { with: [index], not: [spawned] } }, (row, { commands }) => {
     commands.spawn(made)({ [index]: row[index], [value]: 0 });
 });
 
 /** Despawns every entity a spawn benchmark made. */
-export const despawnSpawned = System.create({ name: "structural/despawnSpawned", components: { has: [spawned] } }, (row, { commands }) => {
+export const despawnSpawned = System.create({ kernel: false, components: { with: [spawned] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 
 /** Despawns every seeded entity. */
-export const despawnAll = System.create({ name: "structural/despawnAll", components: { has: [index], not: [spawned] } }, (row, { commands }) => {
+export const despawnAll = System.create({ kernel: false, components: { with: [index], not: [spawned] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 
 /** The same, from a kernel. */
-export const despawnKernel = System.create({ name: "structural/despawnKernel", kernel: "cpu", components: { has: [index], not: [spawned] } }, (row, { commands }) => {
+export const despawnKernel = System.create({ kernel: true, components: { with: [index], not: [spawned] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 
 /** Entities `spawnOne` made, for `despawnOne`. */
 const pending: Entity[] = [];
 
-export const spawnOne = System.create({ name: "structural/spawnOne" }, ({ commands }) => {
+export const spawnOne = System.create({}, ({ commands }) => {
     pending.push(commands.spawn(made)({ [index]: 0, [value]: 0 }));
 });
 
 /** Despawns one entity: a run's fixed cost per despawn. */
-export const despawnOne = System.create({ name: "structural/despawnOne" }, ({ commands }) => {
+export const despawnOne = System.create({}, ({ commands }) => {
     const entity = pending.pop();
     if (entity !== undefined) commands.despawn(entity);
 });
 
-export const addFlag = System.create({ name: "structural/addFlag", components: { has: [index], not: [flag, spawned] } }, (row, { commands }) => {
+export const addFlag = System.create({ kernel: false, components: { with: [index], not: [flag, spawned] } }, (row, { commands }) => {
     commands.add(row.entity, flag);
 });
 
-export const removeFlag = System.create({ name: "structural/removeFlag", components: { has: [flag] } }, (row, { commands }) => {
+export const removeFlag = System.create({ kernel: false, components: { with: [flag] } }, (row, { commands }) => {
     commands.remove(row.entity, flag);
 });
 
-export const addFlagKernel = System.create({ name: "structural/addFlagKernel", kernel: "cpu", components: { has: [index], not: [flag, spawned] } }, (row, { commands }) => {
+export const addFlagKernel = System.create({ kernel: true, components: { with: [index], not: [flag, spawned] } }, (row, { commands }) => {
     commands.add(row.entity, flag);
 });
 
-export const removeFlagKernel = System.create({ name: "structural/removeFlagKernel", kernel: "cpu", components: { has: [flag] } }, (row, { commands }) => {
+export const removeFlagKernel = System.create({ kernel: true, components: { with: [flag] } }, (row, { commands }) => {
     commands.remove(row.entity, flag);
 });
 
-export const addAmount = System.create({ name: "structural/addAmount", components: { read: [index], not: [amount, spawned] } }, (row, { commands }) => {
+export const addAmount = System.create({ kernel: false, components: { with: [index], not: [amount, spawned] } }, (row, { commands }) => {
     commands.add(row.entity, amount, row[index]);
 });
 
-export const removeAmount = System.create({ name: "structural/removeAmount", components: { has: [amount] } }, (row, { commands }) => {
+export const removeAmount = System.create({ kernel: false, components: { with: [amount] } }, (row, { commands }) => {
     commands.remove(row.entity, amount);
 });
 
 /** Adds a value every row already has: no archetype moves, only values replaced and marked changed. */
-export const replaceAmount = System.create({ name: "structural/replaceAmount", components: { read: [amount] } }, (row, { commands }) => {
+export const replaceAmount = System.create({ kernel: false, components: { with: [amount] } }, (row, { commands }) => {
     commands.add(row.entity, amount, row[amount] + 1);
 });
 
-export const addSeveral = System.create({ name: "structural/addSeveral", components: { read: [index], not: [flag, spawned] } }, (row, { commands }) => {
+export const addSeveral = System.create({ kernel: false, components: { with: [index], not: [flag, spawned] } }, (row, { commands }) => {
     commands.add(row.entity, several, { [amount]: row[index], [extra]: 1 });
 });
 
-export const removeSeveral = System.create({ name: "structural/removeSeveral", components: { has: [flag, amount, extra] } }, (row, { commands }) => {
+export const removeSeveral = System.create({ kernel: false, components: { with: [flag, amount, extra] } }, (row, { commands }) => {
     commands.remove(row.entity, several);
 });

package/src/perftest/suite.perf-browser-test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { it } from "vitest";
 import { gpuDevice } from "../interface/resources/gpu-device.js";
 import { createWorld } from "../implementation/world/create.js";
@@ -17,6 +18,7 @@ import { indexBenchmarks } from "./indexes.js";
 import { structReplace, valueBenchmarks } from "./values.js";
 import { observedGpuBenchmarks } from "./observed-gpu.js";
 import { uploadBenchmarks } from "./uploads.js";
+import { renderOrderBenchmarks } from "./render-order.js";
 
 /** Every worker's copy bandwidth together, through browser workers running the calibration script. */
 const browserThreadsBandwidth = async (): Promise<Curve> => {
@@ -102,6 +104,7 @@ const benchmarks = (device: GPUDevice): readonly Benchmark[] => [
     ...transferBenchmarks,
     ...observedGpuBenchmarks(device, run => gpuFastest(device, run)),
     ...uploadBenchmarks(device, run => gpuFastest(device, run)),
+    ...renderOrderBenchmarks(device, run => gpuFastest(device, run)),
     ...[[100_000, 10, "100K chains of 10"], [1_000, 1_000, "1K chains of 1,000"]].map(([roots, depth, chains]): Benchmark => ({
         name: `up depth ${depth} gpu`,
         operation: upOperation(String(chains)),

package/src/perftest/suite.perf-test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { it } from "vitest";
 import { benchmarks } from "./benchmarks.js";
 import { report } from "./suite.js";

package/src/perftest/suite.ts

@@ -1,10 +1,10 @@
-import { Archetype } from "../interface/archetype/archetype.js";
-import { Component } from "../interface/component/component.js";
-import { Resource } from "../interface/resource/resource.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Entity } from "../interface/entity/entity.js";
+import type { I32 } from "../interface/math/i32/index.js";
 import type { Schema } from "../interface/schema/schema.js";
 import { System } from "../interface/system/system.js";
 import type { World } from "../interface/world/world.js";
+import type { F32, U32 } from "../interface/math/index.js";
 
 // One fixture per optimization area: structural changes, change filters, lookups, commands, dispatch and main-thread
 // paths.
@@ -22,13 +22,13 @@ export const hits = Symbol("suite/hits");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [position]: { type: readonly [number, number, number] };
-        [velocity]: { type: readonly [number, number, number] };
+        [position]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
+        [velocity]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
         [target]: { type: Entity };
-        [index]: { type: number };
+        [index]: { type: U32 };
         [tag]: { type: true };
         [unused]: { type: true };
-        [hits]: { type: number };
+        [hits]: { type: F32 };
     }
 }
 
@@ -40,22 +40,13 @@ declare module "@adobe/ecs" {
         [highest]: { type: number; reduce: "max" };
     }
 }
-Resource.register(indexSum, { type: { type: "number", default: 0 }, reduce: "+" });
-Resource.register(highest, { type: { type: "number", default: 0 }, reduce: "max" });
 
-Component.register(position, { type: vec3 });
-Component.register(velocity, { type: vec3 });
-Component.register(target, { type: Entity.schema });
-Component.register(index, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
-Component.register(tag, { type: { const: true } });
-Component.register(unused, { type: { const: true } });
-Component.register(hits, { type: { type: "number", precision: 1 } });
 
-const moving = Archetype.create([position, velocity, index]);
-const following = Archetype.create([position, velocity, index, target]);
+const moving = [position, velocity, index] as const;
+const following = [position, velocity, index, target] as const;
 
 /** `count` entities, each targeting the one spawned before it. */
-export const seed = System.create({ name: "suite/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     let previous = commands.spawn(moving)({ [position]: [0, 0, 0], [velocity]: [0, 0, 0], [index]: 0 });
     for (let i = 1; i < input.count; i++) {
         previous = commands.spawn(following)({ [position]: [i, i * 0.5, -i], [velocity]: [1, 0, 0], [index]: i, [target]: previous });
@@ -63,14 +54,14 @@ export const seed = System.create({ name: "suite/seed", input: { type: "object",
 });
 
 /** Despawns a tenth of the entities and spawns as many replacements. */
-export const churn = System.create({ name: "suite/churn", input: { type: "object", properties: { group: { type: "integer" } } }, components: { read: [index, position] } }, (row, { input, commands }) => {
+export const churn = System.create({ components: { with: [index, position] } }, (row, { commands }, input: { readonly group: number }) => {
     if (row[index] % 10 !== input.group) return;
     commands.despawn(row.entity);
     commands.spawn(moving)({ [position]: row[position], [velocity]: [0, 0, 0], [index]: row[index] });
 });
 
 /** Adds the tag to one tenth and removes it from another: a fifth of the entities move archetype. */
-export const retag = System.create({ name: "suite/retag", input: { type: "object", properties: { group: { type: "integer" } } }, components: { read: [index] } }, (row, { input, commands }) => {
+export const retag = System.create({ components: { with: [index] } }, (row, { commands }, input: { readonly group: number }) => {
     const group = row[index] % 10;
     if (group === input.group) commands.add(row.entity, tag);
     else if (group === (input.group + 5) % 10) commands.remove(row.entity, tag);
@@ -78,11 +69,9 @@ export const retag = System.create({ name: "suite/retag", input: { type: "object
 
 /** Writes 1% of positions. */
 export const poke = System.create({
-    name: "suite/poke",
-    kernel: "cpu",
-    input: { type: "object", properties: { group: { type: "integer" } } },
-    components: { read: [index], write: [position] },
-}, (row, { input }) => {
+    kernel: true,
+    components: { with: [index, position] },
+}, (row, _context, input: { readonly group: I32 }) => {
     if (row[index] % 100 === input.group) {
         const [x, y, z] = row[position];
         row[position] = [x + 1, y, z];
@@ -91,11 +80,9 @@ export const poke = System.create({
 
 /** Writes 1% of positions, clustered in one contiguous run of rows. */
 export const pokeCluster = System.create({
-    name: "suite/pokeCluster",
-    kernel: "cpu",
-    input: { type: "object", properties: { group: { type: "integer" } } },
-    components: { read: [index], write: [position] },
-}, (row, { input }) => {
+    kernel: true,
+    components: { with: [index, position] },
+}, (row, _context, input: { readonly group: I32 }) => {
     const group = row[index] - input.group * 10_000;
     if (group >= 0 && group < 10_000) {
         const [x, y, z] = row[position];
@@ -105,9 +92,8 @@ export const pokeCluster = System.create({
 
 /** Sees only what changed since it last ran. */
 export const observe = System.create({
-    name: "suite/observe",
-    kernel: "cpu",
-    components: { read: [position], write: [velocity], changed: [position] },
+    kernel: true,
+    components: { with: [position, velocity], changed: [position] },
 }, row => {
     const [x, y, z] = row[position];
     row[velocity] = [x * 0.5, y * 0.5, z * 0.5];
@@ -115,10 +101,9 @@ export const observe = System.create({
 
 /** Steers toward the target: one lookup per row. */
 export const follow = System.create({
-    name: "suite/follow",
-    kernel: "cpu",
-    components: { read: [position, target], write: [velocity] },
-    lookup: { targets: { read: [position] } },
+    kernel: true,
+    components: { with: [position, target, velocity] },
+    lookup: { targets: { with: [position] } },
 }, (row, { lookup: { targets } }) => {
     const other = targets(row[target]);
     if (other !== null) {
@@ -130,9 +115,8 @@ export const follow = System.create({
 
 /** Issues commands from a kernel: a tenth of the rows record a hit. */
 export const emit = System.create({
-    name: "suite/emit",
-    kernel: "cpu",
-    components: { read: [index, position] },
+    kernel: true,
+    components: { with: [index, position] },
 }, (row, { commands }) => {
     if (row[index] % 10 === 0) {
         const [x] = row[position];
@@ -141,37 +125,36 @@ export const emit = System.create({
 });
 
 /** Six dependent kernels: one tier each, so dispatch cost shows. */
-export const chain1 = System.create({ name: "suite/chain1", kernel: "cpu", components: { write: [velocity] } }, row => {
+export const chain1 = System.create({ kernel: true, components: { with: [velocity] } }, row => {
     const [x, y, z] = row[velocity];
     row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
 });
-export const chain2 = System.create({ name: "suite/chain2", kernel: "cpu", components: { write: [velocity] }, after: [chain1] }, row => {
+export const chain2 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain1] }, row => {
     const [x, y, z] = row[velocity];
     row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
 });
-export const chain3 = System.create({ name: "suite/chain3", kernel: "cpu", components: { write: [velocity] }, after: [chain2] }, row => {
+export const chain3 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain2] }, row => {
     const [x, y, z] = row[velocity];
     row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
 });
-export const chain4 = System.create({ name: "suite/chain4", kernel: "cpu", components: { write: [velocity] }, after: [chain3] }, row => {
+export const chain4 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain3] }, row => {
     const [x, y, z] = row[velocity];
     row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
 });
-export const chain5 = System.create({ name: "suite/chain5", kernel: "cpu", components: { write: [velocity] }, after: [chain4] }, row => {
+export const chain5 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain4] }, row => {
     const [x, y, z] = row[velocity];
     row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
 });
-export const chain6 = System.create({ name: "suite/chain6", kernel: "cpu", components: { write: [velocity] }, after: [chain5] }, row => {
+export const chain6 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain5] }, row => {
     const [x, y, z] = row[velocity];
     row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
 });
-export const chain = System.create({ name: "suite/chain", systems: [chain1, chain2, chain3, chain4, chain5, chain6] });
+export const chain = System.create({ systems: [chain1, chain2, chain3, chain4, chain5, chain6] });
 
 /** Fifty small main-thread systems in one tier, each reading every row. */
 let total = 0;
 export const smalls = System.create({
-    name: "suite/smalls",
-    systems: Array.from({ length: 50 }, (_, i) => System.create({ name: `suite/small${i}`, components: { read: [position] } }, row => {
+    systems: Array.from({ length: 50 }, (_, i) => System.create({ components: { with: [position] } }, row => {
         total += row[position][0];
     })),
 });
@@ -203,30 +186,29 @@ export const seeded = async (create: () => World, count: number): Promise<World>
 };
 
 /** Folds every row's index into a sum and a maximum. */
-export const reduce = System.create({ name: "suite/reduce", kernel: "cpu", components: { read: [index] }, reduce: { [indexSum]: "+", [highest]: "max" } }, (row, { reduce }) => {
+export const reduce = System.create({ kernel: true, components: { with: [index] } }, (row, { reduce }) => {
     reduce[indexSum](row[index]);
     reduce[highest](row[index]);
 });
 
 /** A system no entity matches: what a run costs with nothing to do. */
-export const idle = System.create({ name: "suite/idle", components: { has: [unused] } }, () => {});
-/** A system that throws, so each run of it has a report to spawn. */
-export const failing = System.create({ name: "suite/failing" }, () => { throw new Error("suite: failing"); });
+export const idle = System.create({ components: { with: [unused] } }, () => {});
+/** A system that throws, so each run of it rejects. */
+export const failing = System.create({}, () => { throw new Error("suite: failing"); });
 /** An observer system no entity matches: a run of it alone has no tiers. */
-export const idleObserver = System.create({ name: "suite/idleObserver", observer: true, components: { has: [unused] } }, () => {});
+export const idleObserver = System.create({ observer: true, components: { with: [unused] } }, () => {});
 
 /** Fifty systems no entity matches, in one tier. */
 export const idles = System.create({
-    name: "suite/idles",
-    systems: Array.from({ length: 50 }, (_, i) => System.create({ name: `suite/idle${i}`, components: { has: [unused] } }, () => {})),
+    systems: Array.from({ length: 50 }, (_, i) => System.create({ components: { with: [unused] } }, () => {})),
 });
 
 /** Spawns one entity: a run with a sync point that applies one command. */
-export const spawnOne = System.create({ name: "suite/spawnOne" }, ({ commands }) => {
+export const spawnOne = System.create({}, ({ commands }) => {
     commands.spawn(moving)({ [position]: [0, 0, 0], [velocity]: [0, 0, 0], [index]: 0 });
 });
 
 /** One main-thread system reading every row. */
-export const small = System.create({ name: "suite/small", components: { read: [position] } }, row => {
+export const small = System.create({ components: { with: [position] } }, row => {
     total += row[position][0];
 });

package/src/perftest/systems.ts

@@ -1,4 +1,4 @@
-import { Component } from "../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { always } from "../interface/resources/always.js";
 import { eachTick, ticksAfter } from "./observer.js";
 import { System } from "../interface/system/system.js";
@@ -14,22 +14,21 @@ declare module "@adobe/ecs" {
         [level]: { type: number };
     }
 }
-Component.register(level, { type: { type: "number" } });
 
 /** Entities the added systems read. */
 const entities = 100;
 
-const seed = System.create({ name: "systems/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let i = 0; i < entities; i++) commands.spawn([level])({ [level]: i });
 });
 
 let read = 0;
 
 /** A new system for each tick: a change filter, which counts as watching `level`, and rows to read. */
-const fresh = (): System => System.create({ components: { read: [level], changed: [level] } }, row => { read += row[level]; });
+const fresh = (): System => System.create({ components: { with: [level], changed: [level] } }, row => { read += row[level]; });
 
 /** One module's system, added and removed again and again. */
-const again = System.create({ name: "systems/again", components: { read: [level], changed: [level] } }, row => { read += row[level]; });
+const again = System.create({ components: { with: [level], changed: [level] } }, row => { read += row[level]; });
 
 /** Ticks in each timed stretch. */
 export const churnTicks = 10_000;
@@ -56,7 +55,6 @@ const churning = async (churn: (() => System) | null, after: boolean, stretches
         world.add(again);
         await ticksAfter(world, 2);
         world.remove(again);
-        await ticksAfter(world, 2);
         await world.run(idle);
         const before = await world.tables();
         let added: System | null = null;