@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/holders.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { indexOf } from './entities.js';
 
 /**

package/src/implementation/world/ids-changes.test-helper.ts

@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** The components each change set added, which every evaluation of `ids-keys.test-helper.ts` records into. */
+export const changes: (readonly symbol[])[] = [];

package/src/implementation/world/ids-keys.test-helper.ts

@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Finalizer } from "../../interface/finalizer/finalizer.js";
+import { Rule } from "../../interface/rule/rule.js";
+import { changes } from "./ids-changes.test-helper.js";
+
+// A module of keys, a rule and a finalizer, which `ids.test.ts` evaluates again: each evaluation makes new symbols and
+// values under the same ids.
+export const score = Symbol("score");
+export const shown = Symbol("shown");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [score]: { type: number };
+        [shown]: { type: true; derived: true };
+    }
+}
+
+export const showing = Rule.create({ components: { with: [score] }, derive: [shown] });
+export const recording = Finalizer.changes({ watch: [score] }, ({ groups }) => {
+    for (const group of groups) changes.push(group.added);
+});

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

@@ -1,68 +1,31 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import type { Entity } from "../../interface/entity/entity.js";
-import { Finalizer } from "../../interface/finalizer/finalizer.js";
-import { identify } from "../../interface/registry/ids.test-helper.js";
 import { workers } from "../../interface/resources/workers.js";
-import { Rule } from "../../interface/rule/rule.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
+import { changes } from "./ids-changes.test-helper.js";
+import { score, shown } from "./ids-keys.test-helper.js";
 import { read } from "./reads.test-helper.js";
 
-// Each pair is one module's key and the key that module makes when evaluated again: one id, two symbols.
-const score = Symbol("score");
-const scoreAgain = Symbol("score");
-const shown = Symbol("shown");
-const shownAgain = Symbol("shown");
-
-identify(score, "worldIdsTest/keys.ts#score");
-identify(scoreAgain, "worldIdsTest/keys.ts#score");
-identify(shown, "worldIdsTest/keys.ts#shown");
-identify(shownAgain, "worldIdsTest/keys.ts#shown");
-
-declare module "@adobe/ecs" {
-    export interface Components {
-        [score]: { type: number };
-        [scoreAgain]: { type: number };
-        [shown]: { type: true; derived: true };
-        [shownAgain]: { type: true; derived: true };
-    }
-}
-
-Component.register(score, { type: { type: "number" } });
-Component.register(shown, { type: { const: true }, derived: true });
-Rule.create(identify({ name: "worldIdsTest/shown", components: { has: [score] }, derive: [shown] }, "worldIdsTest/systems.ts#shown"));
-const changes: (readonly symbol[])[] = [];
-Finalizer.changes(identify({ name: "worldIdsTest/changes", watch: [score] }, "worldIdsTest/systems.ts#changes"), ({ groups }) => {
-    for (const group of groups) changes.push(group.added);
-});
-
-// The module evaluated again, after the world met its first keys.
-const evaluateAgain = (): void => {
-    Component.register(scoreAgain, { type: { type: "number" } });
-    Component.register(shownAgain, { type: { const: true }, derived: true });
-    Rule.create(identify({ name: "worldIdsTest/shown", components: { has: [scoreAgain] }, derive: [shownAgain] }, "worldIdsTest/systems.ts#shown"));
-    Finalizer.changes(identify({ name: "worldIdsTest/changes", watch: [scoreAgain] }, "worldIdsTest/systems.ts#changes"), ({ groups }) => {
-        for (const group of groups) changes.push(group.added);
-    });
-};
-
-const spawn = System.create({ name: "worldIdsTest/spawn" }, ({ commands }) => { spawned.push(commands.spawn([score])({ [score]: 1 })); });
 const spawned: Entity[] = [];
+const spawn = System.create({}, ({ commands }) => { spawned.push(commands.spawn([score])({ [score]: 1 })); });
 
 describe("a world given keys with ids", () => {
     it("stores the symbols of one id as one component, giving values by the newest", async () => {
         const world = createWorld({ [workers]: 0 });
         await world.run(spawn);
-        evaluateAgain();
-        const spawnAgain = System.create({ name: "worldIdsTest/spawnAgain" }, ({ commands }) => { spawned.push(commands.spawn([scoreAgain])({ [scoreAgain]: 2 })); });
-        const add = System.create({ name: "worldIdsTest/add", components: { write: [scoreAgain] } }, row => { row[scoreAgain] += 10; });
+        // The keys' module evaluated again, after the world met its first keys: a new module by its query, its ids the same.
+        const again: typeof import("./ids-keys.test-helper.js") = await import(/* @vite-ignore */ `./ids-keys.test-helper.js?again=${Date.now()}`);
+        expect(again.score).not.toBe(score);
+        const spawnAgain = System.create({}, ({ commands }) => { spawned.push(commands.spawn([again.score])({ [again.score]: 2 })); });
+        const add = System.create({ components: { with: [again.score] } }, row => { row[again.score] += 10; });
         await world.run(spawnAgain);
         await world.run(add);
         const [first, second] = spawned;
-        expect([await read(world, first, score), await read(world, first, scoreAgain), await read(world, second, score)]).toEqual([11, 11, 12]);
-        expect([await read(world, first, shownAgain), await read(world, second, shown)]).toEqual([true, true]);
-        expect(changes).toEqual([[score], [scoreAgain]]);
+        expect([await read(world, first, score), await read(world, first, again.score), await read(world, second, score)]).toEqual([11, 11, 12]);
+        expect([await read(world, first, again.shown), await read(world, second, shown)]).toEqual([true, true]);
+        expect(changes).toEqual([[score], [again.score]]);
         await world.dispose();
     });
 });

package/src/implementation/world/imported-lists.test-helper.ts

@@ -1,5 +1,4 @@
-import { Archetype } from '../../interface/archetype/archetype.js';
-import { Component } from '../../interface/component/component.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 
 /** Keys and lists another module's kernels import, in `imported-lists.test.ts`. */
 
@@ -14,9 +13,6 @@ declare module "@adobe/ecs" {
         [marked]: { type: true };
     }
 }
-Component.register(ember, { type: { type: "number" } });
-Component.register(glow, { type: { const: true } });
-Component.register(marked, { type: { const: true } });
 
-export const Spark = Archetype.create([ember, glow]);
+export const Spark = [ember, glow] as const;
 export const Marks = [ember, marked] as const;

package/src/implementation/world/imported-lists.test.ts

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { System } from "../../interface/system/system.js";
 import { count, read, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
@@ -13,21 +13,20 @@ declare module "@adobe/ecs" {
         [heat]: { type: number };
     }
 }
-Component.register(heat, { type: { type: "number" } });
 
-const seed = System.create({ name: "importedListsTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     commands.spawn([heat])({ [heat]: 2 });
     commands.spawn([heat])({ [heat]: 5 });
 });
 
 /** Spawns and adds through lists another module declares, naming one of their keys only through the list. */
-const ignite = System.create({ name: "importedListsTest/ignite", kernel: "cpu", components: { read: [heat] } }, (row, { commands }) => {
+const ignite = System.create({ kernel: true, components: { with: [heat] } }, (row, { commands }) => {
     commands.spawn(Spark)({ [ember]: row[heat] * 2 });
     commands.add(row.entity, Lists.Marks, { [ember]: row[heat] });
 });
 
 /** Declares an imported list, and removes through one. */
-const cool = System.create({ name: "importedListsTest/cool", kernel: "cpu", components: { read: [ember], has: Lists.Spark } }, (row, { commands }) => {
+const cool = System.create({ kernel: true, components: { with: [ember, ...Lists.Spark] } }, (row, { commands }) => {
     if (row[ember] > 4) commands.remove(row.entity, Spark);
 });
 

package/src/implementation/world/index-buckets.test.ts

@@ -0,0 +1,276 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import type { Entity } from "../../interface/entity/entity.js";
+import { Index } from "../../interface/indexes/index-type.js";
+import { workers } from "../../interface/resources/workers.js";
+import { System } from "../../interface/system/system.js";
+import { createWorld, type CreatedWorld } from "./create.js";
+import type { U32 } from "../../interface/math/index.js";
+
+// Long buckets of a hash index, which a change may leave unsorted until a list is read by position: every reader still
+// gets each bucket's rows in entity order.
+
+const group = Symbol("indexBucketsTest/group");
+const serial = Symbol("indexBucketsTest/serial");
+const hidden = Symbol("indexBucketsTest/hidden");
+const extra = Symbol("indexBucketsTest/extra");
+const reads = Symbol("indexBucketsTest/reads");
+const sum = Symbol("indexBucketsTest/sum");
+const sumByHand = Symbol("indexBucketsTest/sumByHand");
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [group]: { type: U32 };
+        [serial]: { type: U32 };
+        [hidden]: { type: true };
+        [extra]: { type: true };
+        [reads]: { type: U32 };
+        [sum]: { type: number };
+        [sumByHand]: { type: number };
+    }
+}
+
+const groups = [0, 1, 2];
+const byGroup = Index.create({ key: [group], components: { with: [serial], not: [hidden] } });
+
+/** What a reader saw: each bucket's length, or each bucket's rows as entity index and serial, in order. */
+let lengths: number[] = [];
+let rows: (readonly [number, number])[][] = [];
+const readLengths = System.create({ lookup: { byGroup: { index: byGroup } } }, ({ lookup }) => {
+    lengths = groups.map(value => lookup.byGroup(value).length);
+});
+const readRows = System.create({ lookup: { byGroup: { index: byGroup } } }, ({ lookup }) => {
+    rows = groups.map(value => {
+        const list = lookup.byGroup(value);
+        const found: (readonly [number, number])[] = [];
+        for (let i = 0; i < list.length; i++) {
+            const row = list.at(i);
+            found.push([row.entity >>> 0, row[serial]]);
+        }
+        return found;
+    });
+});
+
+/** Each reader row's bucket's serials, each times its position plus one: a sum that tells the order. */
+const orderSum = System.create({
+    kernel: true,
+    components: { with: [reads, sum] },
+    lookup: { byGroup: { index: byGroup } },
+}, (row, { lookup }) => {
+    const list = lookup.byGroup(row[reads]);
+    let total = 0;
+    for (let i = 0; i < list.length; i++) total += (i + 1) * list.at(i)[serial];
+    row[sum] = total;
+});
+const orderSumByHand = System.create({
+    components: { with: [reads, sumByHand] },
+    lookup: { byGroup: { index: byGroup } },
+}, (row, { lookup }) => {
+    const list = lookup.byGroup(row[reads]);
+    let total = 0;
+    for (let i = 0; i < list.length; i++) total += (i + 1) * list.at(i)[serial];
+    row[sumByHand] = total;
+});
+let sums: { kernel: number[]; byHand: number[] } = { kernel: [], byHand: [] };
+const readSums = System.create({ components: { with: [reads, sum, sumByHand] } }, row => {
+    sums.kernel[row[reads]] = row[sum];
+    sums.byHand[row[reads]] = row[sumByHand];
+});
+const spawnReaders = System.create({}, ({ commands }) => {
+    for (const value of groups) commands.spawn([reads, sum, sumByHand])({ [reads]: value, [sum]: 0, [sumByHand]: 0 });
+});
+
+/** An entity as the test keeps it, and the changes a round makes. */
+type Held = { group: number; readonly serial: number; hidden: boolean };
+type Change =
+    | { readonly kind: "spawn"; readonly group: number; readonly serial: number; readonly extra: boolean }
+    | { readonly kind: "despawn" | "hide" | "show" | "extra" | "plain"; readonly entity: Entity }
+    | { readonly kind: "group"; readonly entity: Entity; readonly group: number };
+
+let spawned: Entity[] = [];
+const apply = System.create({}, ({ commands }, input: { readonly changes: readonly Change[] }) => {
+    spawned = [];
+    for (const change of input.changes) {
+        switch (change.kind) {
+            case "spawn":
+                spawned.push(change.extra
+                    ? commands.spawn([group, serial, extra])({ [group]: change.group, [serial]: change.serial, [extra]: true })
+                    : commands.spawn([group, serial])({ [group]: change.group, [serial]: change.serial }));
+                break;
+            case "despawn": commands.despawn(change.entity); break;
+            case "hide": commands.add(change.entity, hidden); break;
+            case "show": commands.remove(change.entity, hidden); break;
+            case "extra": commands.add(change.entity, extra); break;
+            case "plain": commands.remove(change.entity, extra); break;
+            case "group": commands.add(change.entity, group, change.group); break;
+        }
+    }
+});
+
+/** A seeded generator of numbers in [0, 1). */
+const generator = (seed: number): (() => number) => {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6D2B79F5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+};
+
+/** The world and what it holds, as the test keeps it: entities by entity, and the next serial. */
+type Scenario = { readonly world: CreatedWorld; readonly held: Map<Entity, Held>; next: number };
+
+const applyChanges = async (scenario: Scenario, changes: readonly Change[]): Promise<void> => {
+    await scenario.world.run(apply, { changes });
+    let k = 0;
+    for (const change of changes) {
+        if (change.kind === "spawn") scenario.held.set(spawned[k++], { group: change.group, serial: change.serial, hidden: false });
+        else if (change.kind === "despawn") scenario.held.delete(change.entity);
+        else if (change.kind === "hide" || change.kind === "show") {
+            const found = scenario.held.get(change.entity);
+            if (found !== undefined) found.hidden = change.kind === "hide";
+        }
+        else if (change.kind === "group") {
+            const found = scenario.held.get(change.entity);
+            if (found !== undefined) found.group = change.group;
+        }
+    }
+};
+
+const spawnMany = (scenario: Scenario, count: number, groupOf: (k: number) => number): Change[] =>
+    Array.from({ length: count }, (_, k): Change => ({ kind: "spawn", group: groupOf(k), serial: scenario.next++, extra: k % 3 === 0 }));
+
+/** Each bucket's rows as the index must give them: by entity index. */
+const expectedRows = (scenario: Scenario): (readonly [number, number])[][] => groups.map(value => [...scenario.held]
+    .filter(([, held]) => held.group === value && !held.hidden)
+    .map(([entity, held]): readonly [number, number] => [entity >>> 0, held.serial])
+    .sort((a, b) => a[0] - b[0]));
+
+const orderSumOf = (bucket: readonly (readonly [number, number])[]): number => bucket.reduce((total, [, value], i) => total + (i + 1) * value, 0);
+
+const checkRows = async (scenario: Scenario): Promise<void> => {
+    await scenario.world.run(readRows);
+    expect(rows).toEqual(expectedRows(scenario));
+};
+const checkLengths = async (scenario: Scenario): Promise<void> => {
+    await scenario.world.run(readLengths);
+    expect(lengths).toEqual(expectedRows(scenario).map(bucket => bucket.length));
+};
+
+/** A round of random changes: entities moved between buckets, hidden and shown, given a tag and plain again, despawned and spawned. */
+const randomChanges = (scenario: Scenario, next: () => number, count: number): Change[] => {
+    const entities = [...scenario.held.keys()];
+    const pick = (): Entity => entities[Math.floor(next() * entities.length)];
+    const used = new Set<Entity>();
+    const changes: Change[] = [];
+    for (let k = 0; k < count; k++) {
+        const entity = pick();
+        const choice = next();
+        if (choice < 0.08) {
+            changes.push({ kind: "spawn", group: Math.floor(next() * 3), serial: scenario.next++, extra: next() < 0.5 });
+            continue;
+        }
+        // One change an entity a round, so the test's model applies them as the sync point does.
+        if (used.has(entity)) continue;
+        used.add(entity);
+        const held = scenario.held.get(entity);
+        if (held === undefined) continue;
+        if (choice < 0.6) changes.push({ kind: "group", entity, group: (held.group + 1 + Math.floor(next() * 2)) % 3 });
+        else if (choice < 0.7) changes.push({ kind: "despawn", entity });
+        else if (choice < 0.8) changes.push({ kind: held.hidden ? "show" : "hide", entity });
+        else changes.push({ kind: next() < 0.5 ? "extra" : "plain", entity });
+    }
+    return changes;
+};
+
+const createScenario = (wasm = true): Scenario => ({ world: createWorld({ [workers]: 0 }, { wasm }), held: new Map(), next: 0 });
+
+describe("a hash index's long buckets", () => {
+    it.each([[1], [2], [3], [4]])("give their rows in entity order after random changes, read by length and by position, seed %i", async seed => {
+        const scenario = createScenario();
+        await using _world = scenario.world;
+        const next = generator(seed);
+        await applyChanges(scenario, spawnMany(scenario, 600, k => k % 3));
+        await checkRows(scenario);
+        for (let round = 0; round < 80; round++) {
+            await applyChanges(scenario, randomChanges(scenario, next, Math.floor(next() * 60)));
+            const mode = Math.floor(next() * 4);
+            if (mode === 0 || mode === 2) await checkLengths(scenario);
+            if (mode === 1 || mode === 2) await checkRows(scenario);
+        }
+        await checkRows(scenario);
+        expect(expectedRows(scenario).every(bucket => bucket.length >= 64)).toBe(true);
+    });
+    it("give their rows in entity order after an entity leaves and comes back, and one moves between buckets each run", async () => {
+        const scenario = createScenario();
+        await using _world = scenario.world;
+        await applyChanges(scenario, spawnMany(scenario, 300, k => k % 2));
+        await checkRows(scenario);
+        const entities = [...scenario.held.keys()];
+        for (let k = 0; k < 400; k++) {
+            const entity = entities[(k * 37) % entities.length];
+            const held = scenario.held.get(entity);
+            if (held === undefined) continue;
+            await applyChanges(scenario, [k % 5 === 0 ? { kind: held.hidden ? "show" : "hide", entity } : { kind: "group", entity, group: 1 - held.group }]);
+            if (k % 7 === 0) await checkRows(scenario);
+            else await checkLengths(scenario);
+        }
+        await checkRows(scenario);
+    });
+    it("give their rows in entity order after a refresh that builds the index again, and changes after it", async () => {
+        const scenario = createScenario();
+        await using _world = scenario.world;
+        await applyChanges(scenario, spawnMany(scenario, 6000, k => k % 3));
+        await checkLengths(scenario);
+        const next = generator(9);
+        for (let round = 0; round < 6; round++) {
+            await applyChanges(scenario, randomChanges(scenario, next, 30));
+            await checkLengths(scenario);
+            // More changes than a refresh patches: the index is built again, its unsorted buckets with it.
+            const everyOther = [...scenario.held].filter((_, k) => k % 2 === round % 2).map(([entity, held]): Change => ({ kind: "group", entity, group: (held.group + 1) % 3 }));
+            await applyChanges(scenario, [...randomChanges(scenario, next, 30).filter(change => change.kind === "spawn"), ...everyOther]);
+            await checkLengths(scenario);
+            await applyChanges(scenario, randomChanges(scenario, next, 30));
+            await checkRows(scenario);
+        }
+    });
+    it("give their rows in entity order after a build in phases, and changes after it", async () => {
+        const scenario = createScenario();
+        await using _world = scenario.world;
+        // Enough entities for a build in phases (`rebuildPhased`).
+        await applyChanges(scenario, spawnMany(scenario, 70_000, k => k % 2));
+        await checkLengths(scenario);
+        const next = generator(11);
+        for (let round = 0; round < 4; round++) {
+            await applyChanges(scenario, randomChanges(scenario, next, 50));
+            await checkLengths(scenario);
+            await applyChanges(scenario, randomChanges(scenario, next, 50));
+            await checkRows(scenario);
+        }
+        expect((await scenario.world.tables()).phasedBuilds).toBeGreaterThan(0);
+    });
+});
+
+describe.each([[true], [false]])("kernels reading a hash index's long buckets, WASM %s", wasm => {
+    it("read their rows in entity order, as a main-thread system does, after changes left them unsorted", async () => {
+        const scenario = createScenario(wasm);
+        await using _world = scenario.world;
+        await scenario.world.run(spawnReaders);
+        await applyChanges(scenario, spawnMany(scenario, 600, k => k % 3));
+        const next = generator(5);
+        for (let round = 0; round < 12; round++) {
+            await applyChanges(scenario, randomChanges(scenario, next, 40));
+            // Read by length only, so the buckets stay unsorted for the kernel.
+            await checkLengths(scenario);
+            await scenario.world.run(orderSum);
+            await scenario.world.run(orderSumByHand);
+            sums = { kernel: [], byHand: [] };
+            await scenario.world.run(readSums);
+            const expected = expectedRows(scenario).map(orderSumOf);
+            expect(sums.kernel).toEqual(expected);
+            expect(sums.byHand).toEqual(expected);
+        }
+    });
+});

package/src/implementation/world/index-build-csp.test.ts

@@ -1,26 +1,25 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Index } from "../../interface/indexes/index-type.js";
 import { workers } from "../../interface/resources/workers.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
+import type { Vec2 } from "../../interface/math/index.js";
+import type { Schema } from "../../interface/schema/schema.js";
 
 const spot = Symbol("indexBuildCspTest/spot");
 const size = Symbol("indexBuildCspTest/size");
 const bulk = Symbol("indexBuildCspTest/bulk");
 declare module "@adobe/ecs" {
     interface Components {
-        [spot]: { type: readonly [number, number] };
+        [spot]: { type: Vec2.I32 };
         [size]: { type: number };
-        [bulk]: { type: number };
+        [bulk]: { type: Schema.Type<{ type: "number"; precision: 2 }> };
     }
 }
-Component.register(spot, { type: { type: "array", items: { type: "integer", minimum: -1000, maximum: 1000 }, minItems: 2, maxItems: 2 } });
-Component.register(size, { type: { type: "number" } });
-Component.register(bulk, { type: { type: "number", precision: 2 } });
 
 /** A key of a pair of i32s and an f64, so the steps encode three kinds of leaf. */
-const bySpot = Index.create({ key: [spot, bulk], components: { has: [size] } });
+const bySpot = Index.create({ key: [spot, bulk], components: { with: [size] } });
 const count = 70_000;
 
 describe("index builds in phases where code can't be generated", () => {
@@ -34,14 +33,14 @@ describe("index builds in phases where code can't be generated", () => {
                 for (let k = 0; k < count; k++) commands.spawn([spot, size, bulk])({ [spot]: [k % 37 - 18, k % 11], [size]: k, [bulk]: (k % 3) / 4 });
             }));
             const expected = new Map<string, number[]>();
-            await world.run(System.create({ components: { read: [spot, size, bulk] } }, row => {
+            await world.run(System.create({ components: { with: [spot, size, bulk] } }, row => {
                 const text = `${row[spot][0]},${row[spot][1]},${row[bulk]}`;
                 const held = expected.get(text) ?? [];
                 held.push(row[size]);
                 expected.set(text, held);
             }));
             const found = new Map<string, number[]>();
-            await world.run(System.create({ lookup: { at: { index: bySpot, read: [size] } } }, ({ lookup }) => {
+            await world.run(System.create({ lookup: { at: { index: bySpot } } }, ({ lookup }) => {
                 for (const text of expected.keys()) {
                     const [x, y, b] = text.split(",").map(Number);
                     const list = lookup.at([x, y], b);

package/src/implementation/world/index-build.cases.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./index-build.fixture.js";
 

package/src/implementation/world/index-build.fixture.ts

@@ -1,9 +1,10 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Index } from "../../interface/indexes/index-type.js";
 import { workers } from "../../interface/resources/workers.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
-import { runReported } from "./reports.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
+import type { U32, Vec2 } from "../../interface/math/index.js";
 
 /** Scenarios of indexes built again across the pool, run built in node and from source in chromium. */
 
@@ -13,37 +14,34 @@ const weight = Symbol("indexBuildTest/weight");
 
 declare module "@adobe/ecs" {
     interface Components {
-        [cell]: { type: readonly [number, number] };
-        [serial]: { type: number };
+        [cell]: { type: Vec2.I32 };
+        [serial]: { type: U32 };
         [weight]: { type: number };
     }
 }
-Component.register(cell, { type: { type: "array", items: { type: "integer", minimum: -1000, maximum: 1000 }, minItems: 2, maxItems: 2 } });
-Component.register(serial, { type: { type: "integer", minimum: 0, maximum: 10000000 } });
-Component.register(weight, { type: { type: "number" } });
 
-const grid = Index.create({ name: "indexBuildTest/grid", key: [cell], components: { has: [weight] } });
-const serials = Index.create({ name: "indexBuildTest/serials", key: [serial], unique: true });
+const grid = Index.create({ key: [cell], components: { with: [weight] } });
+const serials = Index.create({ key: [serial], unique: true });
 
 const width = 300;
 const height = 200;
 const count = 150_000;
 
 /** Spawns entities in cells, with serials of which a few repeat. */
-const seed = System.create({ name: "indexBuildTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let k = 0; k < count; k++) {
         commands.spawn([cell, serial, weight])({ [cell]: [(k * 7919) % width, (k * 104729) % height], [serial]: k % 50_000 === 7 ? 7 : k, [weight]: k % 13 });
     }
 });
 
 /** Moves every entity to another cell, so the next refresh builds the index again. */
-const shuffle = System.create({ name: "indexBuildTest/shuffle", components: { write: [cell] } }, row => {
+const shuffle = System.create({ components: { with: [cell] } }, row => {
     const [x, y] = row[cell];
     row[cell] = [(x * 7 + 3) % width, (y + x) % height];
 });
 
 /** A kernel, so the pool starts, as it does with a world's first kernel. */
-const warm = System.create({ name: "indexBuildTest/warm", kernel: "cpu", components: { read: [serial], write: [weight] } }, row => {
+const warm = System.create({ kernel: true, components: { with: [serial, weight] } }, row => {
     row[weight] = row[serial] % 13;
 });
 
@@ -51,8 +49,7 @@ const seen = { grid: 0, rows: 0, serials: 0 };
 
 /** Every cell's rows, in order, folded into one number; and the unique index's row of each serial. */
 const read = System.create({
-    name: "indexBuildTest/read",
-    lookup: { near: { index: grid, read: [weight] }, bySerial: { index: serials } },
+    lookup: { near: { index: grid }, bySerial: { index: serials } },
 }, ({ lookup }) => {
     let fold = 0;
     let rows = 0;
@@ -74,7 +71,7 @@ const read = System.create({
 });
 
 /** The same folds without an index: each cell's rows sorted by entity, and each serial's lowest entity. */
-const reference = System.create({ name: "indexBuildTest/reference", components: { read: [cell, serial, weight] } }, row => {
+const reference = System.create({ components: { with: [cell, serial, weight] } }, row => {
     const [x, y] = row[cell];
     const cellRows = byCell[x * height + y] ??= [];
     cellRows.push([row.entity, row[weight]]);

package/src/implementation/world/index-build.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { capacityFor, entryWords, recordCapacity, recordHash, recordKey, recordLength, recordStart } from './index-hash.js';
 import { hashWords, orderF32, orderF64 } from './index-keys.js';