@adobe/ecs 0.1.0 → 0.2.0

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

@@ -1,10 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Archetype } from "../../interface/archetype/archetype.js";
-import { Report } from "../../interface/report/report.js";
-import { Component } from "../../interface/component/component.js";
 import type { Essential } from "../../interface/component/value.js";
 import { Entity } from "../../interface/entity/entity.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { Rule } from "../../interface/rule/rule.js";
 import type { Schema } from "../../interface/schema/schema.js";
 import type { Commands } from "../../interface/system/commands.js";
@@ -14,7 +11,9 @@ import { workers } from "../../interface/resources/workers.js";
 import { Observe } from "../../observe/index.js";
 import { count, read, readEntity, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
-import { runReported } from "./reports.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
+import { recordDeclaration } from "../../interface/registry/ids.test-helper.js";
+import type { F32 } from "../../interface/math/index.js";
 
 type Vec3 = readonly [number, number, number];
 const vec3 = { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } as const satisfies Schema;
@@ -25,6 +24,7 @@ const label = Symbol("commandsTest/label");
 const tag = Symbol("commandsTest/tag");
 const other = Symbol("commandsTest/other");
 const slot = Symbol("commandsTest/slot");
+// Never declared, so never registered.
 const unregistered = Symbol("commandsTest/unregistered");
 const level = Symbol("commandsTest/level");
 const bit0 = Symbol("commandsTest/bit0");
@@ -34,14 +34,13 @@ const bit3 = Symbol("commandsTest/bit3");
 const bits = [bit0, bit1, bit2, bit3] as const;
 declare module "@adobe/ecs" {
     export interface Components {
-        [position]: { type: readonly [number, number, number] };
-        [score]: { type: number };
+        [position]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
+        [score]: { type: F32 };
         [health]: { type: number };
         [label]: { type: string | null };
         [tag]: { type: true };
         [other]: { type: true };
         [slot]: { type: number; derived: true };
-        [unregistered]: { type: number };
         [bit0]: { type: true };
         [bit1]: { type: true };
         [bit2]: { type: true };
@@ -51,23 +50,11 @@ declare module "@adobe/ecs" {
         [level]: { type: number };
     }
 }
-Component.register(position, { type: vec3 });
-Component.register(score, { type: { type: "number", precision: 1 } });
-Component.register(health, { type: { type: "number" } });
-Component.register(label, { type: { anyOf: [{ type: "string" }, { type: "null" }] } });
-Component.register(tag, { type: { const: true } });
-Component.register(other, { type: { const: true } });
-Component.register(slot, { type: { type: "number", default: 0 }, derived: true });
-Component.register(bit0, { type: { const: true } });
-Component.register(bit1, { type: { const: true } });
-Component.register(bit2, { type: { const: true } });
-Component.register(bit3, { type: { const: true } });
-Resource.register(level, { type: { type: "number", default: 0 } });
-Rule.create({ name: "commandsTest/slots", components: { has: [other, score] }, derive: [slot] });
+Rule.create({ components: { with: [other, score] }, derive: [slot] });
 
-const unit = Archetype.create([position, score, tag]);
-const made = Archetype.create([score, tag]);
-const marks = Archetype.create([other, label]);
+const unit = [position, score, tag] as const;
+const made = [score, tag] as const;
+const marks = [other, label] as const;
 
 /** Every component of these tests an entity has, or `null` if it is dead. */
 const components = (world: World, entity: Entity) =>
@@ -75,29 +62,29 @@ const components = (world: World, entity: Entity) =>
 
 /** Spawns and adds with literal values, which the plugin passes positionally, from one site over several lists. */
 const literals: Entity[] = [];
-const spawnLiterals = System.create({ name: "commandsTest/spawnLiterals" }, ({ commands }) => {
+const spawnLiterals = System.create({}, ({ commands }) => {
     for (let i = 0; i < 6; i++) literals.push(commands.spawn(i % 3 === 0 ? defaulted : i % 3 === 1 ? made : [score, label])({ [score]: i }));
 });
-const addLiterals = System.create({ name: "commandsTest/addLiterals", components: { has: [score], not: [health] } }, (row, { commands }) => {
+const addLiterals = System.create({ components: { with: [score], not: [health] } }, (row, { commands }) => {
     commands.add(row.entity, [health, label], { [label]: "x", [health]: 5 });
 });
 
-const spawnFrom = System.create({ name: "commandsTest/spawnFrom", kernel: "cpu", components: { read: [score], not: [tag, other] } }, (row, { commands }) => {
+const spawnFrom = System.create({ kernel: true, components: { with: [score], not: [tag, other] } }, (row, { commands }) => {
     commands.spawn(made)({ [score]: row[score] + 10 });
 });
-const mark = System.create({ name: "commandsTest/mark", kernel: "cpu", components: { has: [tag], not: [other] } }, (row, { commands }) => {
+const mark = System.create({ kernel: true, components: { with: [tag], not: [other] } }, (row, { commands }) => {
     commands.add(row.entity, marks, {});
 });
-const unmark = System.create({ name: "commandsTest/unmark", kernel: "cpu", components: { has: [other] } }, (row, { commands }) => {
+const unmark = System.create({ kernel: true, components: { with: [other] } }, (row, { commands }) => {
     commands.remove(row.entity, marks);
 });
-const defaulted = Archetype.create([score, label, tag]);
+const defaulted = [score, label, tag] as const;
 
 /** A world, and a function running `body` once in a system with the world's commands, rejecting with what it threw. */
 const withCommands = () => {
     const world = createWorld({ [workers]: 0 });
     let body: (commands: Commands) => void = () => {};
-    const issue = System.create({ name: "commandsTest/issue" }, ({ commands }) => body(commands));
+    const issue = System.create({}, ({ commands }) => body(commands));
     const run = async (next: (commands: Commands) => void): Promise<void> => {
         body = next;
         const [failure] = (await runReported(world, issue)).failures;
@@ -107,7 +94,7 @@ const withCommands = () => {
 };
 
 describe("spawn", () => {
-    it("spawns exactly the components listed, through Archetype.create, plain and inline lists", async () => {
+    it("spawns exactly the components listed, through lists declared as const, made at runtime and inline", async () => {
         const { world, run } = withCommands();
         const plain: readonly Essential[] = [score, tag];
         const spawned: Entity[] = [];
@@ -121,6 +108,60 @@ describe("spawn", () => {
         expect(await components(world, spawned[2])).toEqual({ [position]: [6, 6, 6], [score]: 6 });
         await world.dispose();
     });
+    it("spawns a list made at runtime as it is at each spawn, though it changed since the last", async () => {
+        const { world, run } = withCommands();
+        const changing: Essential[] = [score];
+        const spawned: Entity[] = [];
+        await run(commands => { spawned.push(commands.spawn(changing)({ [score]: 1 })); });
+        changing.push(tag);
+        await run(commands => { spawned.push(commands.spawn(changing)({ [score]: 2 })); });
+        expect(await components(world, spawned[0])).toEqual({ [score]: 1 });
+        expect(await components(world, spawned[1])).toEqual({ [score]: 2, [tag]: true });
+        await world.dispose();
+    });
+    it("gives lists made at runtime on every call one index per set of components, however many are made", async () => {
+        const { world, run } = withCommands();
+        const count = (): number => {
+            const value: unknown = Reflect.get(globalThis, Symbol.for("@adobe/ecs/archetypes@1"));
+            return typeof value === "number" ? value : 0;
+        };
+        // Fifteen subsets of four bits, more than are kept as recent, each list made afresh at every spawn.
+        const spawnAll = (commands: Commands): void => {
+            for (let subset = 1; subset < 16; subset++) commands.spawn(bits.filter((_, bit) => (subset & (1 << bit)) !== 0))({});
+        };
+        await run(spawnAll);
+        const before = count();
+        for (let round = 0; round < 20; round++) await run(spawnAll);
+        expect(count() - before).toBe(0);
+        await world.dispose();
+    });
+    it("fails only the systems using a key whose declaration failed, each time, never another key's", async () => {
+        const { world, run } = withCommands();
+        await run(() => {});
+        // As a module imported after the world exists records it.
+        const broken = Symbol("commandsTest/broken");
+        recordDeclaration(broken, "component", { type: { type: "number" }, reduce: "+" });
+        await run(commands => { commands.spawn([bit0])({}); });
+        for (let round = 0; round < 2; round++) {
+            // Undeclared to the types, so spawned as an untyped caller would.
+            await expect(run(commands => { Reflect.apply(Reflect.apply(commands.spawn, commands, [[broken]]), undefined, [{}]); })).rejects.toThrow("only a resource is reduced");
+        }
+        await world.dispose();
+    });
+    it("spawns a list made at runtime in each world that uses it", async () => {
+        const first = withCommands();
+        const second = withCommands();
+        const shared: readonly Essential[] = [score, tag];
+        const spawned: Entity[] = [];
+        for (let round = 0; round < 2; round++) {
+            await first.run(commands => { spawned.push(commands.spawn(shared)({ [score]: 1 })); });
+            await second.run(commands => { spawned.push(commands.spawn(shared)({ [score]: 2 })); });
+        }
+        expect(await components(first.world, spawned[2])).toEqual({ [score]: 1, [tag]: true });
+        expect(await components(second.world, spawned[3])).toEqual({ [score]: 2, [tag]: true });
+        await first.world.dispose();
+        await second.world.dispose();
+    });
     it("starts a tag or a component whose type allows null, left out or given undefined, at true or null, never leaving it out", async () => {
         const { world, run } = withCommands();
         const spawned: Entity[] = [];
@@ -165,7 +206,7 @@ describe("spawn", () => {
     it("spawns into more archetypes than spawns cache, each with its values", async () => {
         const { world, run } = withCommands();
         const lists = Array.from({ length: 16 }, (_, set): (typeof score | (typeof bits)[number])[] => [score, ...bits.filter((_, bit) => (set & (1 << bit)) !== 0)]);
-        const archetypes = lists.map(list => Archetype.create([...list]));
+        const archetypes = lists.map(list => [...list] as const);
         const spawned: Entity[] = [];
         await run(commands => {
             for (let i = 0; i < 64; i++) spawned.push(commands.spawn(i % 2 === 0 ? archetypes[i % 16] : [...lists[i % 16]])({ [score]: i }));
@@ -184,8 +225,8 @@ describe("spawn", () => {
         await expect(tried([level])).rejects.toThrow(`"commandsTest/level" is a resource, not a component`);
         await expect(tried([score, score])).rejects.toThrow(`lists "commandsTest/score" twice`);
         await expect(tried(["commandsTest/score"])).rejects.toThrow("a component's key is a symbol");
-        // Nothing spawned but the failed runs' reports.
-        expect(await count(world, { not: [Report.run] })).toBe(0);
+        // Nothing spawned.
+        expect(await count(world, {})).toBe(0);
         await world.dispose();
     });
 });
@@ -204,14 +245,14 @@ describe("literal values in a system's body", () => {
 });
 
 /** Three adds of one component to each row, by systems ordered first to third, the second adding twice. */
-const first = System.create({ name: "commandsTest/firstAdd", kernel: "cpu", components: { has: [position] } }, (row, { commands }) => {
+const first = System.create({ kernel: true, components: { with: [position] } }, (row, { commands }) => {
     commands.add(row.entity, score, 1);
 });
-const second = System.create({ name: "commandsTest/secondAdd", components: { has: [position] }, after: [first] }, (row, { commands }) => {
+const second = System.create({ components: { with: [position] }, after: [first] }, (row, { commands }) => {
     commands.add(row.entity, score, 2);
     commands.add(row.entity, score, 3);
 });
-const third = System.create({ name: "commandsTest/thirdAdd", kernel: "cpu", components: { has: [position] }, after: [second] }, (row, { commands }) => {
+const third = System.create({ kernel: true, components: { with: [position] }, after: [second] }, (row, { commands }) => {
     commands.add(row.entity, score, 4);
 });
 
@@ -270,9 +311,9 @@ describe("add and remove", () => {
         });
         const added: Entity[] = [];
         const changed: Entity[] = [];
-        const watchAdded = System.create({ name: "commandsTest/watchAdded", components: { has: [score], added: [tag] } }, row => { added.push(row.entity); });
-        const watchChanged = System.create({ name: "commandsTest/watchChanged", components: { has: [score], changed: [position] } }, row => { changed.push(row.entity); });
-        const watch = System.create({ name: "commandsTest/watch", systems: [watchAdded, watchChanged] });
+        const watchAdded = System.create({ components: { with: [score], added: [tag] } }, row => { added.push(row.entity); });
+        const watchChanged = System.create({ components: { with: [score], changed: [position] } }, row => { changed.push(row.entity); });
+        const watch = System.create({ systems: [watchAdded, watchChanged] });
         await world.run(watch);
         added.length = changed.length = 0;
         await run(commands => {
@@ -310,7 +351,7 @@ describe("spawners where code can't be generated", () => {
                 spawned.push(commands.spawn([score, label])(values));
             });
             // A spawn with literal values in a system's body, which the plugin passes positionally.
-            const literal = System.create({ name: "commandsTest/literal" }, ({ commands }) => {
+            const literal = System.create({}, ({ commands }) => {
                 spawned.push(commands.spawn([score, bit2, label])({ [label]: "b", [score]: 8 }));
             });
             await world.run(literal);
@@ -328,7 +369,7 @@ describe("spawners where code can't be generated", () => {
 });
 
 describe("kernels", () => {
-    it("spawn, add and remove through Archetype.create bindings", async () => {
+    it("spawn, add and remove through lists declared as const", async () => {
         const { world, run } = withCommands();
         await run(commands => { for (let i = 0; i < 3; i++) commands.spawn([score])({ [score]: i }); });
         await world.run(spawnFrom);

package/src/implementation/world/commands.ts

@@ -1,7 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Commands } from '../../interface/system/commands.js';
 import { addCommand, despawnCommand, pushCommand, pushComponent, removeCommand, type CommandBuffer } from './buffer.js';
-import { listShapeOf, spawnerOf } from './lists.js';
-import { commandIdOf, idOf, type Key, type State } from './state.js';
+import { listShapeOf, presetSpawnerOf, spawnerOf, type ListShape } from './lists.js';
+import { commandIdOf, idOf, storedShared, type Key, type State } from './state.js';
 
 const collect = (state: State, buffer: CommandBuffer, key: Key, value: unknown): void => {
     if (value !== undefined) pushComponent(buffer, idOf(state, key), value);
@@ -30,6 +31,19 @@ export const commandsTarget = Symbol("commandsTarget");
 
 export type CommandsTarget = { readonly state: State; readonly target: { readonly buffer: CommandBuffer } };
 
+/** A list add naming shared components: each value checked and interned first, so one not of its type queues nothing. */
+const addShared = (state: State, buffer: CommandBuffer, entity: number, shape: ListShape, given: object): void => {
+    const { keys, ids, starts } = shape;
+    const values = keys.map((key, k) => {
+        const value: unknown = Reflect.get(given, key);
+        const start = value === undefined ? starts[k] : value;
+        return state.shared[ids[k]] === undefined ? start : storedShared(state, ids[k], start);
+    });
+    pushCommand(buffer, addCommand, entity);
+    buffer.shapes[buffer.count - 1] = shape.index;
+    for (let k = 0; k < keys.length; k++) pushComponent(buffer, ids[k], values[k]);
+};
+
 /** Values of a list add given none, which only an untyped caller does. */
 const empty = {};
 
@@ -39,7 +53,11 @@ const empty = {};
  */
 export const createCommands = (state: State, target: { readonly buffer: CommandBuffer }): Commands & { readonly [commandsTarget]: CommandsTarget } => ({
     [commandsTarget]: { state, target },
-    spawn: components => spawnerOf(state, listShapeOf(state, components)),
+    // A second parameter rather than a rest one, which would allocate an array each call.
+    spawn: (components: readonly symbol[], preset?: unknown) => {
+        const shape = listShapeOf(state, components);
+        return typeof preset === "object" && preset !== null ? presetSpawnerOf(state, shape, preset) : spawnerOf(state, shape);
+    },
     despawn: entity => {
         pushCommand(target.buffer, despawnCommand, entity);
     },
@@ -47,13 +65,17 @@ export const createCommands = (state: State, target: { readonly buffer: CommandB
         const { buffer } = target;
         if (typeof components === "symbol") {
             const id = commandIdOf(state, components);
+            const value = values === undefined ? state.starts[id] : values;
+            // A shared value chooses the archetype: one not of its type fails this system, queuing nothing.
+            const stored = state.shared[id] === undefined ? value : storedShared(state, id, value);
             pushCommand(buffer, addCommand, entity);
-            pushComponent(buffer, id, values === undefined ? state.starts[id] : values);
+            pushComponent(buffer, id, stored);
             return;
         }
         const shape = listShapeOf(state, components);
         const { keys, ids, starts } = shape;
         const given = typeof values === "object" && values !== null ? values : empty;
+        if (shape.shared.length > 0) return addShared(state, buffer, entity, shape, given);
         pushCommand(buffer, addCommand, entity);
         buffer.shapes[buffer.count - 1] = shape.index;
         for (let k = 0; k < keys.length; k++) {

package/src/implementation/world/composite-input.test.ts

@@ -1,37 +1,39 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
+import { giveAccess } from "../../interface/registry/ids.test-helper.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
 import { workers } from "../../interface/resources/workers.js";
 
 const seen: { readonly system: string; readonly input: unknown }[] = [];
 const move = System.create({
-    name: "compositeInputTest/move",
-    input: { type: "object", properties: { distance: { type: "number" } } },
-}, ({ input }) => { seen.push({ system: "move", input: { ...input } }); });
+}, (_context, input: { readonly distance: number }) => { seen.push({ system: "move", input: { ...input } }); });
 const step = System.create({
-    name: "compositeInputTest/step",
-    input: { type: "object", properties: { distance: { type: "number" }, dt: { type: "number" } } },
-}, ({ input }) => { seen.push({ system: "step", input: { ...input } }); });
-const idle = System.create({ name: "compositeInputTest/idle" }, () => {});
+}, (_context, input: { readonly distance: number; readonly dt: number }) => { seen.push({ system: "step", input: { ...input } }); });
+const idle = System.create({}, () => {});
 const label = System.create({
-    name: "compositeInputTest/label",
-    input: { type: "object", properties: { distance: { type: "string" } } },
-}, ({ input }) => { void input.distance; });
+}, (_context, input: { readonly distance: string }) => { void input.distance; });
 
 describe("composite input", () => {
     it("passes each member the fields of the run's input that it declares", async () => {
         await using world = createWorld({ [workers]: 0 });
-        await world.run(System.create({ name: "compositeInputTest/frame", systems: [move, step, idle] }), { distance: 1, dt: 0.5 });
+        await world.run(System.create({ systems: [move, step, idle] }), { distance: 1, dt: 0.5 });
         expect(seen).toEqual([{ system: "move", input: { distance: 1 } }, { system: "step", input: { distance: 1, dt: 0.5 } }]);
     });
 
     it("rejects a field two members declare with different schemas, naming both", () => {
         // @ts-expect-error distance is a number in one and a string in the other
-        expect(() => System.create({ name: "compositeInputTest/conflict", systems: [move, label] })).toThrow('Systems "compositeInputTest/move" and "compositeInputTest/label" declare input field "distance" with different schemas.');
+        expect(() => System.create({ systems: [move, label] })).toThrow('Systems "move" and "label" declare input field "distance" with different schemas.');
     });
 
-    it("rejects an input that isn't an object of named fields, for untyped declarations", () => {
-        // @ts-expect-error input is an object schema
-        expect(() => System.create({ name: "compositeInputTest/scalar", input: { type: "number" } }, () => {})).toThrow('System "compositeInputTest/scalar": input is an object schema of named fields.');
+    it("rejects a body taking input without the schema the plugin gives from its type, as one not written in place has", () => {
+        const counting = (_context: unknown, input: { readonly count: number }): void => { void input.count; };
+        expect(() => System.create({}, counting)).toThrow("has no access the build inferred from its body");
+        expect(() => System.create(giveAccess({}), counting)).toThrow('takes input, whose schema the plugin gives from the type of its body\'s parameter: write its body in place and build it with Compiler.plugin().');
+    });
+
+    it("rejects an input schema that isn't an object of named fields", () => {
+        const create: (...parameters: unknown[]) => unknown = System.create;
+        expect(() => create(giveAccess({}), (_context: unknown, _input: unknown) => {}, { type: "number" })).toThrow('input is an object schema of named fields.');
     });
 });

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

@@ -1,6 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import { read, readResource, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
@@ -30,23 +29,15 @@ declare module "@adobe/ecs" {
     }
 }
 
-Resource.register(paused, { type: { type: "boolean", default: false } });
-Resource.register(level, { type: { anyOf: [{ type: "object", properties: { size: { type: "number" } } }, { type: "null" }] } });
-Resource.register(ticks, { type: { type: "number", default: 0 } });
-Resource.register(after, { type: { type: "number", default: 0 } });
-Resource.register(sizes, { type: { type: "number", default: 0 } });
-Resource.register(count, { type: { type: "number", default: 0 } });
-Resource.register(total, { type: { type: "number", default: 0 }, reduce: "+" });
-Component.register(value, { type: { type: "number" } });
 
-const pause = System.create({ name: "conditionsTest/pause", resources: { write: [paused] } }, ({ resources }) => { resources[paused] = true; });
-const tick = System.create({ name: "conditionsTest/tick", resources: { not: [paused], write: [ticks] } }, ({ resources }) => { resources[ticks] += 1; });
-const afterTick = System.create({ name: "conditionsTest/afterTick", resources: { write: [after] }, after: [tick] }, ({ resources }) => { resources[after] += 1; });
-const frame = System.create({ name: "conditionsTest/frame", systems: [tick, afterTick] });
-const grow = System.create({ name: "conditionsTest/grow", kernel: "cpu", components: { write: [value] }, resources: { not: [paused] } }, row => {
+const pause = System.create({}, ({ resources }) => { resources[paused] = true; });
+const tick = System.create({ resources: { not: [paused] } }, ({ resources }) => { resources[ticks] += 1; });
+const afterTick = System.create({ after: [tick] }, ({ resources }) => { resources[after] += 1; });
+const frame = System.create({ systems: [tick, afterTick] });
+const grow = System.create({ kernel: true, components: { with: [value] }, resources: { not: [paused] } }, row => {
     row[value] = row[value] + 1;
 });
-const growWhilePaused = System.create({ name: "conditionsTest/growWhilePaused", kernel: "cpu", components: { write: [value] }, resources: { is: [paused] } }, row => {
+const growWhilePaused = System.create({ kernel: true, components: { with: [value] }, resources: { is: [paused] } }, row => {
     row[value] = row[value] + 1;
 });
 
@@ -62,10 +53,10 @@ describe("resource conditions", () => {
 
     it("read an `is` condition as holding", async () => {
         await using world = createWorld({ [workers]: 0 });
-        const measure = System.create({ name: "conditionsTest/measure", resources: { is: [level], write: [sizes] } }, ({ resources }) => { resources[sizes] = resources[level].size; });
+        const measure = System.create({ resources: { is: [level] } }, ({ resources }) => { resources[sizes] = resources[level].size; });
         await world.run(measure);
         expect(await readResource(world, sizes)).toBe(0);
-        const load = System.create({ name: "conditionsTest/load", resources: { write: [level] } }, ({ resources }) => { resources[level] = { size: 3 }; });
+        const load = System.create({}, ({ resources }) => { resources[level] = { size: 3 }; });
         await world.run(load);
         await world.run(measure);
         expect(await readResource(world, sizes)).toBe(3);
@@ -74,12 +65,12 @@ describe("resource conditions", () => {
     it("keep a skipped system's lastRun, so it sees every change once it runs again", async () => {
         await using world = createWorld({ [workers]: 0 });
         const seen: number[] = [];
-        const watch = System.create({ name: "conditionsTest/watch", components: { read: [value], changed: [value] }, resources: { is: [level] } }, row => { seen.push(row[value]); });
-        const spawn = System.create({ name: "conditionsTest/spawn" }, ({ commands }) => { commands.spawn([value])({ [value]: 7 }); });
+        const watch = System.create({ components: { with: [value], changed: [value] }, resources: { is: [level] } }, row => { seen.push(row[value]); });
+        const spawn = System.create({}, ({ commands }) => { commands.spawn([value])({ [value]: 7 }); });
         await world.run(spawn);
         await world.run(watch);
         expect(seen).toEqual([]);
-        await world.run(System.create({ name: "conditionsTest/ready", resources: { write: [level] } }, ({ resources }) => { resources[level] = { size: 1 }; }));
+        await world.run(System.create({}, ({ resources }) => { resources[level] = { size: 1 }; }));
         await world.run(watch);
         expect(seen).toEqual([7]);
     });
@@ -87,7 +78,7 @@ describe("resource conditions", () => {
     it("leave a reduced resource as it was when every contributor is skipped", async () => {
         await using world = createWorld({ [workers]: 0 });
         let next = 5;
-        const add = System.create({ name: "conditionsTest/add", reduce: { [total]: "+" }, resources: { not: [paused] } }, ({ reduce }) => { reduce[total](next++); });
+        const add = System.create({ resources: { not: [paused] } }, ({ reduce }) => { reduce[total](next++); });
         await world.run(add);
         expect(await readResource(world, total)).toBe(5);
         await world.run(pause);
@@ -97,15 +88,13 @@ describe("resource conditions", () => {
 
     it("reject conditions that are never null or false, or listed twice, for untyped declarations, when declared", () => {
         // @ts-expect-error a number is never null or false
-        expect(() => System.create({ name: "conditionsTest/number", resources: { is: [count] } }, () => {})).toThrow("which is never null or false");
+        expect(() => System.create({ resources: { is: [count] } }, () => {})).toThrow("which is never null or false");
         // @ts-expect-error both is and not
-        expect(() => System.create({ name: "conditionsTest/both", resources: { is: [paused], not: [paused] } }, () => {})).toThrow("in both resources is and not");
-        // @ts-expect-error is already makes it readable
-        expect(() => System.create({ name: "conditionsTest/read", resources: { is: [level], read: [level] } }, ({ resources }) => { void resources[level]; })).toThrow("is already makes it readable");
+        expect(() => System.create({ resources: { is: [paused], not: [paused] } }, () => {})).toThrow("in both resources is and not");
     });
     it("skip a kernel the same way", async () => {
         await using world = createWorld({ [workers]: 0 });
-        await world.run(System.create({ name: "conditionsTest/seed" }, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); }));
+        await world.run(System.create({}, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); }));
         await world.run(grow);
         await world.run(pause);
         await world.run(grow);
@@ -114,7 +103,7 @@ describe("resource conditions", () => {
     });
     it("run a kernel only while its `is` condition holds", async () => {
         await using world = createWorld({ [workers]: 0 });
-        await world.run(System.create({ name: "conditionsTest/seed" }, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); }));
+        await world.run(System.create({}, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); }));
         await world.run(growWhilePaused);
         await world.run(pause);
         await world.run(growWhilePaused);

package/src/implementation/world/constant-unions.test.ts

@@ -0,0 +1,43 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { expect, it } from "vitest";
+import { System } from "../../interface/system/system.js";
+import { workers } from "../../interface/resources/workers.js";
+import { createWorld } from "./create.js";
+import { readEach, select } from "./reads.test-helper.js";
+import { registerResource } from "../../interface/registry/declarations.js";
+import { defaultOf } from "./state.js";
+
+const Frame = { fixed: 0, autoHeight: 1, autoWidth: 2 } as const;
+type Frame = (typeof Frame)[keyof typeof Frame];
+
+const frame = Symbol("constantUnionsTest/frame");
+const shown = Symbol("constantUnionsTest/shown");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [frame]: { type: Frame };
+        [shown]: { type: { text: string } | null; thread: "main" };
+    }
+}
+
+const spawn = System.create({}, ({ commands }) => {
+    commands.spawn([frame, shown])({ [frame]: Frame.autoWidth, [shown]: null });
+});
+// Reads the union beside an object of the main thread: the union is a number in shared memory, on no thread.
+const show = System.create({ components: { with: [frame, shown] } }, row => {
+    row[shown] = { text: `frame ${row[frame]}` };
+});
+
+it("stores a union of number constants as a number in shared memory, read beside another thread's objects", async () => {
+    await using world = createWorld({ [workers]: 0 });
+    await world.run(spawn);
+    await world.run(show);
+    expect(await readEach(world, await select(world, { required: [frame] }), frame)).toEqual([2]);
+});
+
+// Registered by hand without a default, as only code the build didn't generate can.
+const mode = Symbol("constantUnionsTest/mode");
+registerResource(mode, { type: { anyOf: [{ const: 1 }, { const: 2 }, { const: 4 }] } });
+
+it("starts a resource of a union of number constants without a default at its first constant, a value of its type", () => {
+    expect(defaultOf(mode)).toBe(1);
+});