@adobe/ecs 0.0.0-stage → 0.2.0

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

@@ -0,0 +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({
+}, (_context, input: { readonly distance: number }) => { seen.push({ system: "move", input: { ...input } }); });
+const step = System.create({
+}, (_context, input: { readonly distance: number; readonly dt: number }) => { seen.push({ system: "step", input: { ...input } }); });
+const idle = System.create({}, () => {});
+const label = System.create({
+}, (_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({ 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({ systems: [move, label] })).toThrow('Systems "move" and "label" declare input field "distance" with different schemas.');
+    });
+
+    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

@@ -0,0 +1,113 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { System } from "../../interface/system/system.js";
+import { read, readResource, select } from "./reads.test-helper.js";
+import { createWorld } from "./create.js";
+import { workers } from "../../interface/resources/workers.js";
+
+const paused = Symbol("conditionsTest/paused");
+const level = Symbol("conditionsTest/level");
+const ticks = Symbol("conditionsTest/ticks");
+const after = Symbol("conditionsTest/after");
+const sizes = Symbol("conditionsTest/sizes");
+const total = Symbol("conditionsTest/total");
+const count = Symbol("conditionsTest/count");
+const value = Symbol("conditionsTest/value");
+
+declare module "@adobe/ecs" {
+    interface Resources {
+        [paused]: { type: boolean };
+        [level]: { type: { readonly size: number } | null };
+        [ticks]: { type: number };
+        [after]: { type: number };
+        [sizes]: { type: number };
+        [total]: { type: number; reduce: "+" };
+        [count]: { type: number };
+    }
+    interface Components {
+        [value]: { type: number };
+    }
+}
+
+
+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({ kernel: true, components: { with: [value] }, resources: { is: [paused] } }, row => {
+    row[value] = row[value] + 1;
+});
+
+describe("resource conditions", () => {
+    it("skip a system while they don't hold, successfully, so systems after it still run", async () => {
+        await using world = createWorld({ [workers]: 0 });
+        await world.run(frame);
+        await world.run(pause);
+        await world.run(frame);
+        expect(await readResource(world, ticks)).toBe(1);
+        expect(await readResource(world, after)).toBe(2);
+    });
+
+    it("read an `is` condition as holding", async () => {
+        await using world = createWorld({ [workers]: 0 });
+        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({}, ({ resources }) => { resources[level] = { size: 3 }; });
+        await world.run(load);
+        await world.run(measure);
+        expect(await readResource(world, sizes)).toBe(3);
+    });
+
+    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({ 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({}, ({ resources }) => { resources[level] = { size: 1 }; }));
+        await world.run(watch);
+        expect(seen).toEqual([7]);
+    });
+
+    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({ resources: { not: [paused] } }, ({ reduce }) => { reduce[total](next++); });
+        await world.run(add);
+        expect(await readResource(world, total)).toBe(5);
+        await world.run(pause);
+        await world.run(add);
+        expect(await readResource(world, total)).toBe(5);
+    });
+
+    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({ resources: { is: [count] } }, () => {})).toThrow("which is never null or false");
+        // @ts-expect-error both is and not
+        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({}, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); }));
+        await world.run(grow);
+        await world.run(pause);
+        await world.run(grow);
+        const [entity] = await select(world, { required: [value] });
+        expect(await read(world, entity, value)).toBe(2);
+    });
+    it("run a kernel only while its `is` condition holds", async () => {
+        await using world = createWorld({ [workers]: 0 });
+        await world.run(System.create({}, ({ commands }) => { commands.spawn([value])({ [value]: 1 }); }));
+        await world.run(growWhilePaused);
+        await world.run(pause);
+        await world.run(growWhilePaused);
+        const [entity] = await select(world, { required: [value] });
+        expect(await read(world, entity, value)).toBe(2);
+    });
+});

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);
+});

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

@@ -0,0 +1,362 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { giveAccess } from "../../interface/registry/ids.test-helper.js";
+import { identify } from "../../interface/registry/ids.test-helper.js";
+import { Entity } from "../../interface/entity/entity.js";
+import { gpuDevice } from "../../interface/resources/gpu-device.js";
+import { System } from "../../interface/system/system.js";
+import { count, read, readEach, readEntity, readResource, select } from "./reads.test-helper.js";
+import { World } from "../../interface/world/world.js";
+import { attachKernel } from "./attach-kernel.js";
+import { createWorld } from "../index.js";
+import { runReported } from "./outcomes.test-helper.js";
+import type { Schema } from "../../interface/schema/schema.js";
+
+type Vec2 = readonly [number, number];
+
+const position = Symbol("createTest/position");
+const velocity = Symbol("createTest/velocity");
+const label = Symbol("createTest/label");
+const frozen = Symbol("createTest/frozen");
+const spawnCount = Symbol("createTest/spawnCount");
+const seen = Symbol("createTest/seen");
+const marker = Symbol("createTest/marker");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [position]: { type: readonly [number, number] };
+        [velocity]: { type: number };
+        [label]: { type: string };
+        [frozen]: { type: true };
+        [marker]: { type: number };
+    }
+    export interface Resources {
+        [spawnCount]: { type: Schema.Type<{ type: "integer" }>; default: 3 };
+        [seen]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
+    }
+}
+
+
+const spawn = System.create({
+    resources: { changed: [spawnCount] },
+}, ({ resources, commands }) => {
+    for (let i = 0; i < resources[spawnCount]; i++) commands.spawn([position, velocity, label])({ [position]: [i, 0], [velocity]: 1, [label]: `e${i}` });
+});
+
+const move = System.create({
+    components: { with: [velocity, position], not: [frozen] },
+    after: [spawn],
+}, row => {
+    const [x, y] = row[position];
+    row[position] = [x, y + row[velocity]];
+});
+
+/** Counts rows whose position may have changed since it last ran. */
+const watch = System.create({
+    components: { changed: [position] },
+    after: [move],
+}, (_, { resources }) => {
+    resources[seen] += 1;
+});
+
+/** A kernel whose module can't be imported. */
+const missing = attachKernel(
+    System.create({ kernel: true, components: { with: [velocity] } }, () => {}),
+    { columns: [], shapes: [], resources: [], lookups: [], keys: [], spawns: [], structuredValues: [], url: "/@missing/kernel.js", program: null, reductions: [], reducedShapes: [] },
+);
+
+const main = System.create({ systems: [spawn, move, watch] });
+
+const positions = async (world: World): Promise<Vec2[]> =>
+    (await readEach(world, await select(world, { required: [position], order: { [position]: true } }), position)).map(value => value ?? [NaN, NaN]);
+
+describe("World.create", () => {
+    it("spawns once from a changed resource, then integrates", async () => {
+        const world = createWorld();
+        await world.run(main);
+        expect(await positions(world)).toEqual([[0, 0], [1, 0], [2, 0]]);
+        await world.run(main);
+        expect(await positions(world)).toEqual([[0, 1], [1, 1], [2, 1]]);
+        expect(await readResource(world, spawnCount)).toBe(3);
+    });
+
+    it("reports each change to a system exactly once", async () => {
+        const world = createWorld();
+        await world.run(main);
+        // Spawned at the sync point, after watch ran: seen on the next run.
+        expect(await readResource(world, seen)).toBe(0);
+        await world.run(main);
+        expect(await readResource(world, seen)).toBe(3);
+        // Moved before watch in the last run, so already reported.
+        await world.run(watch);
+        expect(await readResource(world, seen)).toBe(3);
+        await world.run(move);
+        await world.run(watch);
+        expect(await readResource(world, seen)).toBe(6);
+    });
+
+    it("applies the net structural change of a sync point", async () => {
+        let first = Entity.none;
+        let second = Entity.none;
+        const edit = System.create({}, ({ commands }, input: { readonly action: string }) => {
+            if (input.action === "spawn") {
+                first = commands.spawn([velocity])({ [velocity]: 1 });
+                second = commands.spawn([velocity])({ [velocity]: 2 });
+            }
+            if (input.action === "toggle") {
+                commands.add(first, frozen, true);
+                commands.remove(first, frozen);
+                commands.add(second, [velocity, label], { [velocity]: 5, [label]: "second" });
+                commands.despawn(first);
+                commands.add(first, label, "dead");
+            }
+        });
+        const world = createWorld();
+        await world.run(edit, { action: "spawn" });
+        expect(await count(world, { required: [velocity] })).toBe(2);
+        await world.run(edit, { action: "toggle" });
+        expect(await readEntity(world, first, [velocity])).toBeNull();
+        expect(await readEntity(world, second, [velocity, label])).toEqual({ [velocity]: 5, [label]: "second" });
+        expect(await select(world, { required: [velocity] })).toEqual([second]);
+    });
+
+    it("reuses a despawned index only after a sync point, with a new generation", async () => {
+        const spawned: Entity[] = [];
+        const edit = System.create({}, ({ commands }, input: { readonly action: string }) => {
+            if (input.action === "spawn") spawned.push(commands.spawn([velocity])({ [velocity]: spawned.length }));
+            else for (const entity of spawned) commands.despawn(entity);
+        });
+        const world = createWorld();
+        await world.run(edit, { action: "spawn" });
+        await world.run(edit, { action: "despawn" });
+        await world.run(edit, { action: "spawn" });
+        const [old, reused] = spawned;
+        expect(reused >>> 0).toBe(old >>> 0);
+        expect(reused).not.toBe(old);
+        expect(await read(world, old, velocity)).toBeNull();
+        expect(await read(world, reused, velocity)).toBe(1);
+    });
+
+    it("keeps rows consistent across swap-removes and archetype growth", async () => {
+        const spawned: Entity[] = [];
+        const edit = System.create({}, ({ commands }, input: { readonly action: string }) => {
+            if (input.action === "spawn") for (let i = 0; i < 100; i++) spawned.push(commands.spawn([velocity, label])({ [velocity]: i, [label]: `${i}` }));
+            else for (let i = 0; i < 100; i += 3) commands.remove(spawned[i], label);
+        });
+        const world = createWorld();
+        await world.run(edit, { action: "spawn" });
+        await world.run(edit, { action: "remove" });
+        for (const [i, entity] of spawned.entries()) {
+            expect(await read(world, entity, velocity)).toBe(i);
+            expect(await read(world, entity, label)).toBe(i % 3 === 0 ? null : `${i}`);
+        }
+        expect(await count(world, { required: [label] })).toBe(66);
+    });
+
+    it("reads a component the world had no id for at an earlier read, once it has one", async () => {
+        await using world = createWorld();
+        const spawnPlain = System.create({}, ({ commands }) => { commands.spawn([velocity])({ [velocity]: 1 }); });
+        await world.run(spawnPlain);
+        const [entity] = await select(world, { required: [velocity] });
+        expect(await read(world, entity, frozen)).toBe(null);
+        const freeze = System.create({}, ({ commands }, input: { readonly entity: Entity }) => {
+            commands.add(input.entity, frozen, true);
+        });
+        await world.run(freeze, { entity });
+        expect(await read(world, entity, frozen)).toBe(true);
+    });
+
+    it("hides the resource entity from queries and commands", async () => {
+        const edit = System.create({ components: {} }, (row, { commands }) => {
+            commands.despawn(row.entity);
+        });
+        const world = createWorld();
+        expect(await count(world, { required: [] })).toBe(0);
+        await world.run(edit);
+        expect(await readResource(world, seen)).toBe(0);
+    });
+
+    it("throws at creating a composite with an unordered conflict, naming nothing", () => {
+        const push = System.create({ components: { with: [position] } }, row => { row[position] = [0, 0]; });
+        expect(() => System.create({ systems: [move, push] })).toThrow('"move" and "push"');
+        expect(() => System.create({ systems: [move] })).not.toThrow();
+    });
+
+    it("gives a body's context only the kinds its body uses", async () => {
+        let keys: string[] = [];
+        // It passes its context on, so the build can't follow it, and it's given what it reads.
+        const probe = System.create(giveAccess({}, { resources: { read: [seen] } }), context => {
+            keys = Object.keys(context);
+            void context.resources[seen];
+        });
+        const world = createWorld();
+        await world.run(probe);
+        expect(keys).toEqual(["resources", "commands"]);
+    });
+
+    it("reports a system that throws, still applying its commands", async () => {
+        const fail = System.create({}, ({ commands }) => {
+            commands.spawn([velocity])({ [velocity]: 1 });
+            throw new Error("boom");
+        });
+        const world = createWorld();
+        const [failure] = (await runReported(world, fail)).failures;
+        expect([failure.kind, failure.name, failure.message]).toEqual(["system", "fail", "boom"]);
+        expect(failure.error instanceof Error && failure.error.stack).toContain("boom");
+        expect(await count(world, { required: [velocity] })).toBe(1);
+    });
+
+    it("spawns nothing of its own for a run, with nothing to report for runs that went right", async () => {
+        const quiet = System.create({}, () => {});
+        await using world = createWorld();
+        expect(await world.run(quiet)).toBeUndefined();
+        expect(await runReported(world, quiet)).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
+        expect(await count(world, {})).toBe(0);
+    });
+
+    it("reports what isn't an Error as text, without a stack", async () => {
+        const fail = System.create({}, () => {
+            // A value that isn't an Error, which user code may throw.
+            throw { code: 7 };
+        });
+        await using world = createWorld();
+        expect((await runReported(world, fail)).failures).toEqual([{ kind: "system", name: "fail", id: null, message: "[object Object]", error: { code: 7 }, subject: fail }]);
+    });
+
+    it("reports the systems a failed tier skips, and the commands that did nothing", async () => {
+        const doomed = System.create({}, ({ commands }) => {
+            const entity = commands.spawn([velocity])({ [velocity]: 1 });
+            commands.despawn(entity);
+            commands.add(entity, frozen, true);
+            commands.despawn(entity);
+        });
+        const fails = System.create({}, () => { throw new Error("first"); });
+        const later = System.create({ after: [fails] }, () => {});
+        await using world = createWorld();
+        expect(await runReported(world, doomed)).toEqual({ failures: [], skipped: [], dropped: 2, warnings: [] });
+        const report = await runReported(world, System.create({ systems: [fails, later] }));
+        expect(report.skipped).toEqual(["later"]);
+        expect(report.failures.map(failure => failure.name)).toEqual(["fails"]);
+    });
+
+    it("skips every row when a system's only filter is an unchanged resource", async () => {
+        const count = System.create({
+            components: { with: [velocity] },
+            resources: { changed: [spawnCount] },
+        }, (_, { resources }) => {
+            resources[seen] += 1;
+        });
+        const world = createWorld();
+        await world.run(spawn);
+        await world.run(count);
+        expect(await readResource(world, seen)).toBe(3);
+        await world.run(count);
+        expect(await readResource(world, seen)).toBe(3);
+    });
+
+    it("doesn't let a lookup match the resource entity", async () => {
+        let found: object | null | undefined;
+        const probe = System.create({ lookup: { any: {} } }, ({ lookup: { any } }) => {
+            // The resource entity is entity 1, since index 0 is never an entity and registration reserves the next first.
+            // @ts-expect-error an untyped caller can pass any number
+            found = any(1);
+        });
+        const world = createWorld();
+        await world.run(probe);
+        expect(found).toBeNull();
+    });
+
+    it("undoes a registration whose kernels fail to load, so the next run tries again", async () => {
+        const world = createWorld();
+        await expect(world.run(missing)).rejects.toThrow();
+        await expect(world.run(missing)).rejects.toThrow();
+        await world.run(spawn);
+    });
+
+    it("sees a change moved into an older chunk by a swap-remove", async () => {
+        const spawned: Entity[] = [];
+        const edit = System.create({}, ({ commands }, input: { readonly action: string }) => {
+            if (input.action === "spawn") for (let i = 0; i < 2100; i++) spawned.push(commands.spawn([velocity])({ [velocity]: i }));
+            else commands.despawn(spawned[5]);
+        });
+        const writer = System.create({ components: { with: [velocity] } }, row => {
+            if (row[velocity] === 2099) row[velocity] = -1;
+        });
+        const changes: number[] = [];
+        const observer = System.create({ components: { with: [velocity], changed: [velocity] } }, row => {
+            changes.push(row[velocity]);
+        });
+        const world = createWorld();
+        await world.run(edit, { action: "spawn" });
+        await world.run(observer);
+        changes.length = 0;
+        // The last row (in the third chunk) changes; then a despawn moves it into row 5, in the first chunk.
+        await world.run(writer);
+        await world.run(edit, { action: "despawn" });
+        await world.run(observer);
+        expect(changes).toEqual([-1]);
+    });
+
+    it("selects with where and order", async () => {
+        const edit = System.create({}, ({ commands }) => {
+            for (let i = 0; i < 10; i++) commands.spawn([position, velocity])({ [position]: [i % 3, i], [velocity]: i });
+        });
+        const world = createWorld();
+        await world.run(edit);
+        const velocities = async (entities: Promise<readonly Entity[]>): Promise<(number | null)[]> => readEach(world, await entities, velocity);
+        expect(await velocities(select(world, { required: [velocity], where: { [velocity]: { "<": 3 } } }))).toEqual([0, 1, 2]);
+        expect(await velocities(select(world, { required: [velocity], where: { [velocity]: { ">=": 2, "!=": 4, "<": 6 } } }))).toEqual([2, 3, 5]);
+        expect(await velocities(select(world, { required: [position, velocity], where: { [position]: [1, 4] } }))).toEqual([4]);
+        expect(await velocities(select(world, { required: [velocity], order: { [velocity]: false } }))).toEqual([9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
+        expect(await velocities(select(world, { required: [position, velocity], where: { [velocity]: { ">": 1 } }, order: { [position]: true } })))
+            .toEqual([3, 6, 9, 4, 7, 2, 5, 8]);
+        expect(await count(world, { required: [velocity], where: { [velocity]: { "<": 3 } } })).toBe(3);
+    });
+
+    it("spawns components named by symbols", async () => {
+        let spawned = Entity.none;
+        const edit = System.create({}, ({ commands }) => {
+            spawned = commands.spawn([velocity, marker])({ [velocity]: 2, [marker]: 7 });
+        });
+        const world = createWorld();
+        await world.run(edit);
+        expect(await readEntity(world, spawned, [velocity, marker])).toEqual({ [velocity]: 2, [marker]: 7 });
+    });
+
+    it("starts resources at values given at creation, in place of their defaults", async () => {
+        const world = createWorld({ [spawnCount]: 2 });
+        expect(await readResource(world, spawnCount)).toBe(2);
+        await world.run(spawn);
+        expect(await count(world, { required: [velocity] })).toBe(2);
+        expect(await readResource(createWorld(), spawnCount)).toBe(3);
+        // @ts-expect-error resources takes only resource names
+        expect(() => createWorld({ [velocity]: 1 })).toThrow(`"createTest/velocity" isn't a registered resource`);
+        // A string key is never a resource's, so it's ignored, as in commands.
+        const untyped: World = Reflect.apply(createWorld, undefined, [{ "createTest/spawnCount": 5, [spawnCount]: 2 }]);
+        expect(await readResource(untyped, spawnCount)).toBe(2);
+    });
+
+    it("has the gpuDevice resource, null without a device", async () => {
+        await using world = createWorld();
+        expect(await readResource(world, gpuDevice)).toBeNull();
+        let seen: unknown = undefined;
+        await world.run(System.create({}, ({ resources }) => { seen = resources[gpuDevice]; }));
+        expect(seen).toBeNull();
+    });
+
+    it("accepts a system declared again the same under its id, as a module evaluated again declares it, and rejects a different one", async () => {
+        const first = System.create(identify({  }, "createTest/systems.ts#named"), ({ resources }) => { resources[seen] = 1; });
+        const again = System.create(identify({  }, "createTest/systems.ts#named"), ({ resources }) => { resources[seen] = 2; });
+        expect(() => System.create(identify({}, "createTest/systems.ts#named"), () => {})).toThrow('Cannot declare "named" (createTest/systems.ts#named): its id is another item\'s, with another declaration; if a module was evaluated again with a changed declaration, reload the page.');
+        await using world = createWorld();
+        await world.run(first);
+        await world.run(again);
+        expect(await readResource(world, seen)).toBe(2);
+    });
+
+    it("refuses runs as soon as dispose is called", async () => {
+        const world = createWorld();
+        void world.dispose();
+        await expect(world.run(main)).rejects.toThrow("disposed");
+    });
+});