@adobe/ecs 0.1.0 → 0.2.0

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

@@ -1,4 +1,4 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Entity } from "../../interface/entity/entity.js";
 import { Index } from "../../interface/indexes/index-type.js";
 import { workers } from "../../interface/resources/workers.js";
@@ -6,6 +6,7 @@ import { System } from "../../interface/system/system.js";
 import { readEntity, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { countingWorkers } from "./platforms.test-helper.js";
+import type { U32, Vec2 } from "../../interface/math/index.js";
 
 /** Scenarios of kernels looking up through indexes across workers, run built in node and from source in chromium. */
 
@@ -20,44 +21,39 @@ const seen = Symbol("indexWorkersTest/seen");
 const serial = Symbol("indexWorkersTest/serial");
 const target = Symbol("indexWorkersTest/target");
 const tally = Symbol("indexWorkersTest/tally");
+const band = Symbol("indexWorkersTest/band");
+const bandSum = Symbol("indexWorkersTest/bandSum");
+const bandSumByHand = Symbol("indexWorkersTest/bandSumByHand");
 
 declare module "@adobe/ecs" {
     interface Components {
-        [cell]: { type: readonly [number, number] };
+        [cell]: { type: Vec2.I32 };
         [weight]: { type: number };
         [total]: { type: number };
         [count]: { type: number };
         [changes]: { type: number };
-        [lane]: { type: number };
+        [lane]: { type: U32 };
         [rank]: { type: number };
         [seen]: { type: Entity };
-        [serial]: { type: number };
-        [target]: { type: number };
+        [serial]: { type: U32 };
+        [target]: { type: U32 };
         [tally]: { type: number };
+        [band]: { type: U32 };
+        [bandSum]: { type: number };
+        [bandSumByHand]: { type: number };
     }
 }
-Component.register(cell, { type: { type: "array", items: { type: "integer", minimum: -1000, maximum: 1000 }, minItems: 2, maxItems: 2 } });
-Component.register(weight, { type: { type: "number" } });
-Component.register(total, { type: { type: "number" } });
-Component.register(count, { type: { type: "number" } });
-Component.register(changes, { type: { type: "number" } });
-Component.register(lane, { type: { type: "integer", minimum: 0, maximum: 1000 } });
-Component.register(rank, { type: { type: "number" } });
-Component.register(seen, { type: Entity.schema });
-Component.register(serial, { type: { type: "integer", minimum: 0, maximum: 1000000 } });
-Component.register(target, { type: { type: "integer", minimum: 0, maximum: 1000000 } });
-Component.register(tally, { type: { type: "number" } });
-
-const grid = Index.create({ name: "indexWorkersTest/grid", key: [cell], components: { has: [weight] } });
-const lanes = Index.create({ name: "indexWorkersTest/lanes", key: [lane, rank], sorted: true });
-const serials = Index.create({ name: "indexWorkersTest/serials", key: [serial], unique: true, components: { has: [weight] } });
-const weighted = Index.create({ name: "indexWorkersTest/weighted", key: [], components: { has: [weight] } });
+
+const grid = Index.create({ key: [cell], components: { with: [weight] } });
+const lanes = Index.create({ key: [lane, rank], sorted: true });
+const serials = Index.create({ key: [serial], unique: true, components: { with: [weight] } });
+const weighted = Index.create({ key: [], components: { with: [weight] } });
 
 /** Each row's neighbors in the 3 by 3 cells around its own: how many, and their weights' sum. */
 const neighbors = System.create({
-    name: "indexWorkersTest/neighbors", kernel: "cpu",
-    components: { read: [cell], write: [total, count] },
-    lookup: { near: { index: grid, read: [weight] } },
+    kernel: true,
+    components: { with: [cell, total, count] },
+    lookup: { near: { index: grid } },
 }, (row, { lookup }) => {
     const [x, y] = row[cell];
     let sum = 0;
@@ -77,8 +73,8 @@ const neighbors = System.create({
 
 /** Counts runs whose list of the row's own cell changed. */
 const watch = System.create({
-    name: "indexWorkersTest/watch", kernel: "cpu",
-    components: { read: [cell], write: [changes] },
+    kernel: true,
+    components: { with: [cell, changes] },
     lookup: { near: { index: grid, changed: [weight] } },
     after: [neighbors],
 }, (row, { lookup }) => {
@@ -88,8 +84,8 @@ const watch = System.create({
 
 /** How many rows of the row's lane have a rank within 5 of its own, and the first of them. */
 const window = System.create({
-    name: "indexWorkersTest/window", kernel: "cpu",
-    components: { read: [lane, rank], write: [count, seen] },
+    kernel: true,
+    components: { with: [lane, rank, count, seen] },
     lookup: { inLane: { index: lanes } },
     after: [watch],
 }, (row, { lookup }) => {
@@ -101,9 +97,9 @@ const window = System.create({
 
 /** The weight of the entity whose serial is the row's target, or -1. */
 const follow = System.create({
-    name: "indexWorkersTest/follow", kernel: "cpu",
-    components: { read: [target], write: [total] },
-    lookup: { bySerial: { index: serials, read: [weight] } },
+    kernel: true,
+    components: { with: [target, total] },
+    lookup: { bySerial: { index: serials } },
     after: [window],
 }, (row, { lookup }) => {
     const found = lookup.bySerial(row[target]);
@@ -112,9 +108,9 @@ const follow = System.create({
 
 /** Through an index without a key: how many entities it holds, a stride of their weights, and whether it changed. */
 const census = System.create({
-    name: "indexWorkersTest/census", kernel: "cpu",
-    components: { read: [target], write: [tally] },
-    lookup: { weighted: { index: weighted, read: [weight], changed: [weight] } },
+    kernel: true,
+    components: { with: [target, tally] },
+    lookup: { weighted: { index: weighted, changed: [weight] } },
     after: [follow],
 }, (row, { lookup }) => {
     const all = lookup.weighted();
@@ -123,9 +119,9 @@ const census = System.create({
     row[tally] = all.length * 1000000 + sum * 2 + (all.changed ? 1 : 0);
 });
 
-const tick = System.create({ name: "indexWorkersTest/tick", systems: [neighbors, watch, window, follow, census] });
+const tick = System.create({ systems: [neighbors, watch, window, follow, census] });
 
-const seed = System.create({ name: "indexWorkersTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let k = 0; k < 3000; k++) {
         commands.spawn([cell, weight, total, count, changes, serial])({ [cell]: [(k * 7) % 31, (k * 3) % 29], [weight]: k % 9, [total]: 0, [count]: 0, [changes]: 0, [serial]: k });
     }
@@ -136,15 +132,16 @@ const seed = System.create({ name: "indexWorkersTest/seed" }, ({ commands }) =>
 });
 
 /** Moves some cells, changes some weights and ranks, despawns some serials and spawns more: a different input each time. */
-const stir = System.create({ name: "indexWorkersTest/stir", input: { type: "object", properties: { round: { type: "integer" } } }, components: { write: [cell, weight] } }, (row, { input }) => {
+const stir = System.create({ components: { with: [cell, weight] } }, (row, _context, input: { readonly round: number }) => {
     const [x, y] = row[cell];
     if ((x + y + input.round) % 11 === 0) row[cell] = [(x + 1) % 31, y];
     if ((x * y + input.round) % 13 === 0) row[weight] = row[weight] + 1;
 });
-const rerank = System.create({ name: "indexWorkersTest/rerank", input: { type: "object", properties: { round: { type: "integer" } } }, components: { write: [rank] } }, (row, { input }) => {
+const rerank = System.create({ components: { with: [rank] } }, (row, _context, input: { readonly round: number }) => {
     if ((row[rank] + input.round) % 7 === 0) row[rank] = (row[rank] * 3 + 1) % 1009;
 });
-const churn = System.create({ name: "indexWorkersTest/churn", input: { type: "object", properties: { round: { type: "integer" } } }, components: { read: [serial] } }, (row, { input, commands }) => {
+// As written: spawned on workers, entities would take ids in an order that depends on the pool, which the census samples by.
+const churn = System.create({ kernel: false, components: { with: [serial] } }, (row, { commands }, input: { readonly round: number }) => {
     if ((row[serial] + input.round) % 17 === 0) commands.despawn(row.entity);
     if (row[serial] % 101 === input.round) {
         commands.spawn([cell, weight, total, count, changes, serial])({ [cell]: [input.round, row[serial] % 29], [weight]: 4, [total]: 0, [count]: 0, [changes]: 0, [serial]: 3000 + row[serial] + input.round });
@@ -189,3 +186,65 @@ export const simulate = async (threads: number, wasm: boolean): Promise<{ readon
         await ecs.dispose();
     }
 };
+
+/** Two long buckets, which changes leave unsorted until something reads them by position. */
+const bands = Index.create({ key: [band], components: { with: [serial] } });
+
+/** Each row's band's serials, each times its position plus one: a sum that tells the order. */
+const bandOrder = System.create({
+    kernel: true,
+    components: { with: [target, bandSum] },
+    lookup: { inBand: { index: bands } },
+}, (row, { lookup }) => {
+    const list = lookup.inBand(row[target] % 2);
+    let sum = 0;
+    for (let i = 0; i < list.length; i++) sum += (i + 1) * list.at(i)[serial];
+    row[bandSum] = sum;
+});
+const bandOrderByHand = System.create({
+    components: { with: [target, bandSumByHand] },
+    lookup: { inBand: { index: bands } },
+}, (row, { lookup }) => {
+    const list = lookup.inBand(row[target] % 2);
+    let sum = 0;
+    for (let i = 0; i < list.length; i++) sum += (i + 1) * list.at(i)[serial];
+    row[bandSumByHand] = sum;
+});
+const seedBands = System.create({}, ({ commands }) => {
+    for (let k = 0; k < 600; k++) commands.spawn([band, serial])({ [band]: k % 2, [serial]: k });
+    for (let k = 0; k < 512; k++) commands.spawn([target, bandSum, bandSumByHand])({ [target]: k, [bandSum]: 0, [bandSumByHand]: 0 });
+});
+/** Moves some entities to the other band, despawns some and spawns others. */
+const stirBands = System.create({ components: { with: [serial, band] } }, (row, { commands }, input: { readonly round: number }) => {
+    if ((row[serial] + input.round) % 7 === 0) row[band] = 1 - row[band];
+    if ((row[serial] + input.round) % 29 === 0) commands.despawn(row.entity);
+    if (row[serial] % 31 === input.round) commands.spawn([band, serial])({ [band]: row[serial] % 2, [serial]: 1000 + row[serial] * 10 + input.round });
+});
+
+/**
+ * Over rounds of changes, what a kernel reading the bands in order wrote, and what a main-thread system reading them
+ * after it wrote, each round's sorted; and the run tasks posted to workers.
+ */
+export const bandOrders = async (threads: number, wasm: boolean): Promise<{ readonly kernel: readonly (readonly number[])[]; readonly byHand: readonly (readonly number[])[]; readonly tasks: number }> => {
+    const counting = countingWorkers();
+    const ecs = createWorld({ [workers]: threads }, { minimumChunk: 64, wasm, pool: counting.platform });
+    try {
+        await ecs.run(seedBands);
+        const posted = (): number => counting.posted("run") + counting.posted("window");
+        const before = posted();
+        const kernel: number[][] = [];
+        const byHand: number[][] = [];
+        for (let round = 0; round < 6; round++) {
+            await ecs.run(stirBands, { round });
+            await ecs.run(bandOrder);
+            await ecs.run(bandOrderByHand);
+            const values = await Promise.all((await select(ecs, { required: [target] })).map(entity => readEntity(ecs, entity, [bandSum, bandSumByHand])));
+            kernel.push(values.map(found => found?.[bandSum] ?? -1).sort((a, b) => a - b));
+            byHand.push(values.map(found => found?.[bandSumByHand] ?? -1).sort((a, b) => a - b));
+        }
+        return { kernel, byHand, tasks: posted() - before };
+    }
+    finally {
+        await ecs.dispose();
+    }
+};

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
 import { Finalizer } from "../../interface/finalizer/finalizer.js";
 import { Index } from "../../interface/indexes/index-type.js";
@@ -11,7 +11,9 @@ import { System } from "../../interface/system/system.js";
 import { createWorld, type CreatedWorld } from "./create.js";
 import { tablesAfterCollecting } from "./lifetime.test-helper.js";
 import { backToBack } from "./loop.js";
-import { runReported } from "./reports.test-helper.js";
+import { ownId } from "./package-id.test-helper.js";
+import { runOutcome, runReported } from "./outcomes.test-helper.js";
+import type { I32, U32, Vec2 } from "../../interface/math/index.js";
 
 const cell = Symbol("indexesTest/cell");
 const weight = Symbol("indexesTest/weight");
@@ -23,30 +25,23 @@ const order = Symbol("indexesTest/order");
 
 declare module "@adobe/ecs" {
     interface Components {
-        [cell]: { type: readonly [number, number] };
+        [cell]: { type: Vec2.I32 };
         [weight]: { type: number };
         [label]: { type: string };
-        [serverId]: { type: number };
+        [serverId]: { type: U32 };
         [owner]: { type: Entity; reference: "weak" };
         [hidden]: { type: true };
         [order]: { type: number };
     }
 }
 
-Component.register(cell, { type: { type: "array", items: { type: "integer", minimum: -1000, maximum: 1000 }, minItems: 2, maxItems: 2 } });
-Component.register(weight, { type: { type: "number" } });
-Component.register(label, { type: { type: "string" } });
-Component.register(serverId, { type: { type: "integer", minimum: 0, maximum: 1000000 } });
-Component.register(owner, { type: Entity.schema, reference: "weak" });
-Component.register(hidden, { type: { const: true } });
-Component.register(order, { type: { type: "number" } });
 
-const grid = Index.create({ name: "indexesTest/grid", key: [cell], components: { has: [weight], not: [hidden] } });
-const byServerId = Index.create({ name: "indexesTest/byServerId", key: [serverId], unique: true });
-const byLabel = Index.create({ name: "indexesTest/byLabel", key: [label] });
-const children = Index.create({ name: "indexesTest/children", key: [owner] });
+const grid = Index.create({ key: [cell], components: { with: [weight], not: [hidden] } });
+const byServerId = Index.create({ key: [serverId], unique: true });
+const byLabel = Index.create({ key: [label] });
+const children = Index.create({ key: [owner] });
 
-const spawnCells = System.create({ name: "indexesTest/spawnCells", input: { type: "object", properties: { cells: { type: "array", items: { type: "array", items: { type: "integer" } } } } } }, ({ input, commands }) => {
+const spawnCells = System.create({}, ({ commands }, input: { readonly cells: readonly (readonly number[])[] }) => {
     input.cells.forEach(([x, y], k) => commands.spawn([cell, weight])({ [cell]: [x ?? 0, y ?? 0], [weight]: k }));
 });
 
@@ -54,10 +49,8 @@ const spawnCells = System.create({ name: "indexesTest/spawnCells", input: { type
 let seen: { readonly entities: readonly Entity[]; readonly weights: readonly number[]; readonly changed: boolean; readonly length: number } | null = null;
 
 const look = System.create({
-    name: "indexesTest/look",
-    input: { type: "object", properties: { x: { type: "integer" }, y: { type: "integer" } } },
-    lookup: { near: { index: grid, read: [weight] } },
-}, ({ input, lookup }) => {
+    lookup: { near: { index: grid } },
+}, ({ lookup }, input: { readonly x: number; readonly y: number }) => {
     const near = lookup.near([input.x, input.y]);
     const entities: Entity[] = [];
     const weights: number[] = [];
@@ -69,14 +62,14 @@ const look = System.create({
 });
 
 /** Moves every entity in cell [0, 0] to [1, 0], before `lookAfter` in the same run. */
-const shift = System.create({ name: "indexesTest/shift", components: { write: [cell] } }, row => {
+const shift = System.create({ components: { with: [cell] } }, row => {
     if (row[cell][0] === 0 && row[cell][1] === 0) row[cell] = [1, 0];
 });
 let afterShift: number | null = null;
-const lookAfter = System.create({ name: "indexesTest/lookAfter", lookup: { near: { index: grid } }, after: [shift] }, ({ lookup }) => {
+const lookAfter = System.create({ lookup: { near: { index: grid } }, after: [shift] }, ({ lookup }) => {
     afterShift = lookup.near([1, 0]).length;
 });
-const shiftThenLook = System.create({ name: "indexesTest/shiftThenLook", systems: [shift, lookAfter] });
+const shiftThenLook = System.create({ systems: [shift, lookAfter] });
 
 const entitiesOf = (world: CreatedWorld): Promise<readonly Entity[]> => Observe.toPromise(Observe.select(world, { required: [cell] }));
 
@@ -140,7 +133,7 @@ describe("hash indexes on the main thread", () => {
     it("key strings by value, and entities by their generation too", async () => {
         await using world = createWorld({ [workers]: 0 });
         let found: readonly number[] = [];
-        const named = System.create({ input: { type: "object", properties: { name: { type: "string" } } }, lookup: { named: { index: byLabel } } }, ({ input, lookup }) => {
+        const named = System.create({ lookup: { named: { index: byLabel } } }, ({ lookup }, input: { readonly name: string }) => {
             const list = lookup.named(input.name);
             found = Array.from({ length: list.length }, (_, i) => list.at(i).entity);
         });
@@ -156,7 +149,7 @@ describe("hash indexes on the main thread", () => {
         expect(found).toEqual([]);
         const parent = labeled[1];
         let held: readonly Entity[] = [];
-        const kids = System.create({ input: { type: "object", properties: { of: { type: "number" } } }, lookup: { of: { index: children } } }, ({ input, lookup }) => {
+        const kids = System.create({ lookup: { of: { index: children } } }, ({ lookup }, input: { readonly of: number }) => {
             const list = lookup.of(Entity.none);
             void list;
             const of = lookup.of(input.of === 0 ? parent : Entity.none);
@@ -176,7 +169,7 @@ describe("hash indexes on the main thread", () => {
 
 describe("unique indexes", () => {
     let known: Entity | null = null;
-    const find = System.create({ input: { type: "object", properties: { id: { type: "integer" } } }, lookup: { known: { index: byServerId } } }, ({ input, lookup }) => {
+    const find = System.create({ lookup: { known: { index: byServerId } } }, ({ lookup }, input: { readonly id: number }) => {
         known = lookup.known(input.id)?.entity ?? null;
     });
     it("give the row of a key or null, and report two entities with one key as an index failure, keeping the lower", async () => {
@@ -192,13 +185,15 @@ describe("unique indexes", () => {
         await world.run(find, { id: 9 });
         expect(known).toBe(null);
         await world.run(System.create(({ commands }) => { commands.add(second, serverId, 7); }));
-        const conflicted = await runReported(world, find, { id: 7 });
+        const { outcome: conflicted, error } = await runOutcome(world, find, { id: 7 });
+        // The run that found them rejects, naming the index.
+        expect(error instanceof Error && error.message).toMatch(`Index "byServerId" is unique, and entities ${first} and ${second} both have key 7`);
         expect(known).toBe(first);
-        expect(conflicted.failures).toEqual([{
+        expect(conflicted.failures.map(({ kind, name, id, message }) => ({ kind, name, id, message }))).toEqual([{
             kind: "index",
-            name: "indexesTest/byServerId",
-            message: `Index "indexesTest/byServerId" is unique, and entities ${first} and ${second} both have key 7; lookups give ${first}, the one with the lower entity index.`,
-            stack: null,
+            name: "byServerId",
+            id: ownId("src/implementation/world/indexes.test.ts", "byServerId"),
+            message: `Index "byServerId" is unique, and entities ${first} and ${second} both have key 7; lookups give ${first}, the one with the lower entity index.`,
         }]);
         // Found once: the next run reports nothing.
         expect((await runReported(world, find, { id: 7 })).failures).toEqual([]);
@@ -210,7 +205,7 @@ describe("call sites", () => {
         await using world = createWorld({ [workers]: 0 });
         await world.run(spawnCells, { cells: [[0, 0], [0, 0], [1, 1]] });
         let pairs: number[] = [];
-        const both = System.create({ lookup: { near: { index: grid, read: [weight] } } }, ({ lookup }) => {
+        const both = System.create({ lookup: { near: { index: grid } } }, ({ lookup }) => {
             const a = lookup.near([0, 0]);
             const b = lookup.near([1, 1]);
             pairs = [a.length, b.length, a.at(0)[weight] + a.at(1)[weight], b.at(0)[weight]];
@@ -235,7 +230,7 @@ describe("call sites", () => {
 
 describe("finalizers", () => {
     const released: number[] = [];
-    Finalizer.create({ name: "indexesTest/release", components: { read: [order, cell] }, lookup: { near: { index: grid, read: [weight] } } }, (row, { lookup }) => {
+    Finalizer.create({ components: { with: [order, cell] }, lookup: { near: { index: grid } } }, (row, { lookup }) => {
         released.push(lookup.near(row[cell]).length);
     });
     it("look up through indexes as they are before the sync point applies", async () => {
@@ -253,9 +248,9 @@ describe("finalizers", () => {
     });
 });
 
-const keepTicking = System.create({ name: "indexesTest/keepTicking" }, () => {});
+const keepTicking = System.create({}, () => {});
 /** Uses `grid` every tick it's added to. */
-const watchGrid = System.create({ name: "indexesTest/watchGrid", lookup: { near: { index: grid } } }, ({ lookup }) => { void lookup.near([0, 0]).length; });
+const watchGrid = System.create({ lookup: { near: { index: grid } } }, ({ lookup }) => { void lookup.near([0, 0]).length; });
 
 describe("index lifetime", () => {
     it("builds an index the first time a system uses it and releases it, arena blocks included, once none does", async () => {
@@ -263,7 +258,7 @@ describe("index lifetime", () => {
         await using world = createWorld({ [workers]: 0, [always]: true }, { loop: driver });
         await world.run(spawnCells, { cells: [[0, 0], [1, 1]] });
         // Ticks of what an index is keyed by stay once started, as any component's do.
-        await world.run(System.create({ components: { read: [cell], changed: [cell] } }, row => { void row[cell]; }));
+        await world.run(System.create({ components: { with: [cell], changed: [cell] } }, row => { void row[cell]; }));
         const before = await tablesAfterCollecting(world);
         // A system made for one run is collected, and its index with it.
         await world.run(System.create({ lookup: { near: { index: grid } } }, ({ lookup }) => { void lookup.near([0, 0]).length; }));
@@ -317,7 +312,7 @@ const bucketsOf = (lookup: (key: readonly [number, number]) => { readonly length
 const isOrdered = (bucket: readonly number[]): boolean => bucket.every((entity, k) => k === 0 || (bucket[k - 1] >>> 0) < (entity >>> 0));
 
 let incremental: readonly (readonly number[])[] = [];
-const probe = System.create({ name: "indexesTest/probe", lookup: { near: { index: grid } } }, ({ lookup }) => { incremental = bucketsOf(key => lookup.near(key)); });
+const probe = System.create({ lookup: { near: { index: grid } } }, ({ lookup }) => { incremental = bucketsOf(key => lookup.near(key)); });
 
 const folded = Symbol("indexesTest/folded");
 declare module "@adobe/ecs" {
@@ -325,15 +320,14 @@ declare module "@adobe/ecs" {
         [folded]: { type: number };
     }
 }
-Component.register(folded, { type: { type: "number" } });
 
 /** A list's entities folded into one number, by position: what `foldNear` writes. */
 const foldOf = (bucket: readonly number[]): number => bucket.reduce((sum, entity, i) => sum + (entity % 997) * (i + 1), 0);
 
 /** A kernel folding the entities of its row's own cell's list, so kernels' lookups are checked against the same index. */
 const foldNear = System.create({
-    name: "indexesTest/foldNear", kernel: "cpu",
-    components: { read: [cell], write: [folded] },
+    kernel: true,
+    components: { with: [cell, folded] },
     lookup: { near: { index: grid } },
 }, (row, { lookup }) => {
     const [x, y] = row[cell];
@@ -345,9 +339,8 @@ const foldNear = System.create({
 
 /** Moves each row whose weight is below `share` of 1000 to the cell `cell` gives it, so keys change during runs. */
 const rekey = System.create({
-    name: "indexesTest/rekey", input: { type: "object", properties: { share: { type: "number" }, seed: { type: "integer" } } },
-    components: { read: [weight], write: [cell] }, before: [probe],
-}, (row, { input }) => {
+    components: { with: [weight, cell] }, before: [probe],
+}, (row, _context, input: { readonly share: number; readonly seed: number }) => {
     if ((row[weight] * 7919 + input.seed) % 1000 < input.share * 1000) row[cell] = cells[(row[weight] + input.seed) % cells.length];
 });
 
@@ -377,7 +370,7 @@ describe("an incrementally refreshed hash index", () => {
             }));
             // Now and then most rows' keys change, past what a patch takes.
             await world.run(System.create({ systems: [rekey, probe] }), { share: next() < 0.1 ? 0.9 : 0.05, seed: step });
-            const scratch = Index.create({ key: [cell], components: { has: [weight], not: [hidden] } });
+            const scratch = Index.create({ key: [cell], components: { with: [weight], not: [hidden] } });
             let rebuilt: readonly (readonly number[])[] = [];
             await world.run(System.create({ lookup: { near: { index: scratch } } }, ({ lookup }) => { rebuilt = bucketsOf(key => lookup.near(key)); }));
             expect(incremental).toEqual(rebuilt);
@@ -399,20 +392,16 @@ const pair = Symbol("indexesTest/pair");
 declare module "@adobe/ecs" {
     interface Components {
         [rank]: { type: number };
-        [lane]: { type: number };
+        [lane]: { type: I32 };
         [flag]: { type: boolean };
-        [pair]: { type: readonly [number, number] };
+        [pair]: { type: Vec2 };
     }
 }
-Component.register(rank, { type: { type: "number" } });
-Component.register(lane, { type: { type: "integer", minimum: -100, maximum: 100 } });
-Component.register(flag, { type: { type: "boolean" } });
-Component.register(pair, { type: { type: "array", items: { type: "number", precision: 1 }, minItems: 2, maxItems: 2 } });
 
-const byRank = Index.create({ name: "indexesTest/byRank", key: [rank], sorted: true });
-const byLaneRank = Index.create({ name: "indexesTest/byLaneRank", key: [lane, rank], sorted: true, components: { has: [weight] } });
-const byName = Index.create({ name: "indexesTest/byName", key: [label], sorted: true, unique: true });
-const byFlagPair = Index.create({ name: "indexesTest/byFlagPair", key: [flag, pair], sorted: true });
+const byRank = Index.create({ key: [rank], sorted: true });
+const byLaneRank = Index.create({ key: [lane, rank], sorted: true, components: { with: [weight] } });
+const byName = Index.create({ key: [label], sorted: true, unique: true });
+const byFlagPair = Index.create({ key: [flag, pair], sorted: true });
 
 /** What a sorted lookup gave: its rows' entities and ranks, and whether it changed. */
 let ranked: { readonly ranks: readonly number[]; readonly changed: boolean } = { ranks: [], changed: false };
@@ -422,13 +411,12 @@ const ranksOf = (list: { readonly length: number; readonly changed: boolean; at(
 });
 
 describe("sorted indexes on the main thread", () => {
-    const spawnRanks = System.create({ input: { type: "object", properties: { ranks: { type: "array", items: { type: "number" } } } } }, ({ input, commands }) => {
+    const spawnRanks = System.create({}, ({ commands }, input: { readonly ranks: readonly number[] }) => {
         for (const value of input.ranks) commands.spawn([rank])({ [rank]: value });
     });
     const query = System.create({
-        input: { type: "object", properties: { kind: { type: "string" }, value: { type: "number" }, other: { type: "number" } } },
-        lookup: { ranks: { index: byRank, read: [rank] } },
-    }, ({ input, lookup }) => {
+        lookup: { ranks: { index: byRank } },
+    }, ({ lookup }, input: { readonly kind: string; readonly value: number; readonly other: number }) => {
         const { value, other } = input;
         switch (input.kind) {
             case "all": ranked = ranksOf(lookup.ranks()); break;
@@ -485,7 +473,7 @@ describe("sorted indexes on the main thread", () => {
             model.forEach(([laneValue, rankValue], k) => commands.spawn([lane, rank, weight])({ [lane]: laneValue, [rank]: rankValue, [weight]: k }));
         }));
         let found: (readonly (readonly number[])[])[] = [];
-        await world.run(System.create({ lookup: { lanes: { index: byLaneRank, read: [lane, rank] } } }, ({ lookup }) => {
+        await world.run(System.create({ lookup: { lanes: { index: byLaneRank } } }, ({ lookup }) => {
             const read = (list: { readonly length: number; at(index: number): { readonly [lane]: number; readonly [rank]: number } }) => Array.from({ length: list.length }, (_, i) => [list.at(i)[lane], list.at(i)[rank]]);
             found = [read(lookup.lanes(0)), read(lookup.lanes(1, { "<": 10 })), read(lookup.lanes({ "<": 0 })), read(lookup.lanes(-1, 26)), read(lookup.lanes(-1, 27))];
         }));
@@ -508,7 +496,7 @@ describe("sorted indexes on the main thread", () => {
         let pairs: (readonly [boolean, readonly [number, number]])[] = [];
         let one: string | null = null;
         let none: string | null = "x";
-        await world.run(System.create({ lookup: { names: { index: byName, read: [label] }, pairs: { index: byFlagPair, read: [flag, pair] } } }, ({ lookup }) => {
+        await world.run(System.create({ lookup: { names: { index: byName }, pairs: { index: byFlagPair } } }, ({ lookup }) => {
             const all = lookup.names();
             names = Array.from({ length: all.length }, (_, i) => all.at(i)[label]);
             const ordered = lookup.pairs();
@@ -554,15 +542,16 @@ describe("sorted indexes on the main thread", () => {
         const find = System.create({ lookup: { names: { index: byName } } }, ({ lookup }) => { kept = lookup.names("one")?.entity ?? null; });
         expect((await runReported(world, find)).failures).toEqual([]);
         await world.run(System.create(({ commands }) => { commands.add(second, label, "one"); }));
-        const report = await runReported(world, find);
+        const { outcome: report, error } = await runOutcome(world, find);
+        expect(error instanceof Error && error.message).toMatch(/^Index "byName" is unique/);
         expect(kept).toBe(first);
-        expect(report.failures).toEqual([{ kind: "index", name: "indexesTest/byName", message: `Index "indexesTest/byName" is unique, and entities ${first} and ${second} both have key "one"; lookups give ${first}, the one with the lower entity index.`, stack: null }]);
+        expect(report.failures.map(({ kind, name, id, message }) => ({ kind, name, id, message }))).toEqual([{ kind: "index", name: "byName", id: ownId("src/implementation/world/indexes.test.ts", "byName"), message: `Index "byName" is unique, and entities ${first} and ${second} both have key "one"; lookups give ${first}, the one with the lower entity index.` }]);
     });
 });
 
 let incrementalRanks: readonly number[] = [];
 let incrementalLanes: readonly (readonly number[])[] = [];
-const probeSorted = System.create({ name: "indexesTest/probeSorted", lookup: { lanes: { index: byLaneRank } } }, ({ lookup }) => {
+const probeSorted = System.create({ lookup: { lanes: { index: byLaneRank } } }, ({ lookup }) => {
     const all = lookup.lanes();
     incrementalRanks = Array.from({ length: all.length }, (_, i) => all.at(i).entity);
     incrementalLanes = [-1, 0, 1].map(laneValue => {
@@ -571,16 +560,15 @@ const probeSorted = System.create({ name: "indexesTest/probeSorted", lookup: { l
     });
 });
 const rerank = System.create({
-    name: "indexesTest/rerank", input: { type: "object", properties: { share: { type: "number" }, seed: { type: "integer" } } },
-    components: { read: [weight], write: [rank] }, before: [probeSorted],
-}, (row, { input }) => {
+    components: { with: [weight, rank] }, before: [probeSorted],
+}, (row, _context, input: { readonly share: number; readonly seed: number }) => {
     if ((row[weight] * 7919 + input.seed) % 1000 < input.share * 1000) row[rank] = (row[weight] * 31 + input.seed * 17) % 1000;
 });
 
 /** A kernel folding the entities of its row's lane's range of ranks within 50 of its own, so kernels' sorted lookups are checked against the same index. */
 const foldLane = System.create({
-    name: "indexesTest/foldLane", kernel: "cpu",
-    components: { read: [lane, rank], write: [folded] },
+    kernel: true,
+    components: { with: [lane, rank, folded] },
     lookup: { lanes: { index: byLaneRank } },
 }, (row, { lookup }) => {
     const r = row[rank];
@@ -613,7 +601,7 @@ describe("an incrementally refreshed sorted index", () => {
                 }
             }));
             await world.run(System.create({ systems: [rerank, probeSorted] }), { share: next() < 0.1 ? 0.9 : 0.05, seed: step });
-            const scratch = Index.create({ key: [lane, rank], sorted: true, components: { has: [weight] } });
+            const scratch = Index.create({ key: [lane, rank], sorted: true, components: { with: [weight] } });
             let rebuiltRanks: readonly number[] = [];
             let rebuiltLanes: readonly (readonly number[])[] = [];
             await world.run(System.create({ lookup: { lanes: { index: scratch } } }, ({ lookup }) => {
@@ -643,7 +631,7 @@ describe("an incrementally refreshed sorted index", () => {
             expect(kernel.map(values => values?.[folded] ?? -1)).toEqual(expected);
             held = Math.max(held, incrementalRanks.length);
             // Once its blocks have split, every entity of a lane goes, so whole blocks empty and are dropped.
-            if (step === 40) await world.run(System.create({ components: { read: [lane] } }, (row, { commands }) => { if (row[lane] < 1) commands.despawn(row.entity); }));
+            if (step === 40) await world.run(System.create({ components: { with: [lane] } }, (row, { commands }) => { if (row[lane] < 1) commands.despawn(row.entity); }));
         }
         expect(held).toBeGreaterThan(250);
     });
@@ -670,7 +658,7 @@ describe("lists and their rows", () => {
         }));
         let hashed: readonly object[] = [];
         let sorted: readonly object[] = [];
-        await world.run(System.create({ lookup: { near: { index: grid, read: [weight] }, ranks: { index: byRank, read: [rank] } } }, ({ lookup }) => {
+        await world.run(System.create({ lookup: { near: { index: grid }, ranks: { index: byRank } } }, ({ lookup }) => {
             const first = lookup.near([0, 0]);
             const second = lookup.near([1, 1]);
             hashed = [first, second, first.at(0), first.at(1), second.at(0)];
@@ -691,7 +679,7 @@ describe("a lookup's rows across sync points", () => {
         await using world = createWorld({ [workers]: 0 });
         await world.run(spawnCells, { cells: [[0, 0], [0, 0]] });
         let weights: number[] = [];
-        const read = System.create({ lookup: { near: { index: grid, read: [weight] } } }, ({ lookup }) => {
+        const read = System.create({ lookup: { near: { index: grid } } }, ({ lookup }) => {
             const near = lookup.near([0, 0]);
             weights = Array.from({ length: near.length }, (_, i) => near.at(i)[weight]);
         });
@@ -699,7 +687,7 @@ describe("a lookup's rows across sync points", () => {
         expect(weights).toEqual([0, 1]);
         // Enough spawns into the same archetype to grow its arrays, and new weights for the two already read.
         await world.run(spawnCells, { cells: Array.from({ length: 200 }, () => [5, 5]) });
-        await world.run(System.create({ components: { write: [weight], read: [cell] } }, row => {
+        await world.run(System.create({ components: { with: [cell, weight] } }, row => {
             if (row[cell][0] === 0) row[weight] += 10;
         }));
         await world.run(read);
@@ -716,7 +704,7 @@ describe("a long list's rows", () => {
         }));
         let fromStart: number[] = [];
         let fromEnd: number[] = [];
-        await world.run(System.create({ lookup: { ranks: { index: byRank, read: [rank] } } }, ({ lookup }) => {
+        await world.run(System.create({ lookup: { ranks: { index: byRank } } }, ({ lookup }) => {
             const all = lookup.ranks();
             // Every row held at once, then read.
             const held = Array.from({ length: all.length }, (_, i) => all.at(i));