@adobe/ecs 0.1.0 → 0.2.1

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

@@ -1,3 +1,4 @@
+// © 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";
@@ -28,17 +29,10 @@ declare module "@adobe/ecs" {
         [visited]: { type: number };
     }
 }
-Component.register(weight, { type: { type: "number" } });
-Component.register(hidden, { type: { const: true } });
-Component.register(color, { type: { type: "number" } });
-Component.register(spin, { type: { type: "number" } });
-Component.register(total, { type: { type: "number" } });
-Component.register(count, { type: { type: "number" } });
-Component.register(visited, { type: { type: "number" } });
 
-const shown = Index.create({ name: "indexKeylessTest/shown", key: [], components: { has: [weight], not: [hidden] } });
-const everything = Index.create({ name: "indexKeylessTest/everything", key: [] });
-const inOrder = Index.create({ name: "indexKeylessTest/inOrder", key: [], sorted: true, components: { has: [weight] } });
+const shown = Index.create({ key: [], components: { with: [weight], not: [hidden] } });
+const everything = Index.create({ key: [] });
+const inOrder = Index.create({ key: [], sorted: true, components: { with: [weight] } });
 
 /** What a lookup gave: its entities and weights, in its order, its length and whether it changed. */
 type Seen = { readonly entities: readonly Entity[]; readonly weights: readonly number[]; readonly length: number; readonly changed: boolean };
@@ -46,8 +40,7 @@ let seen: Seen = { entities: [], weights: [], length: 0, changed: false };
 let all: readonly Entity[] = [];
 
 const look = System.create({
-    name: "indexKeylessTest/look",
-    lookup: { shown: { index: shown, read: [weight] }, all: { index: everything } },
+    lookup: { shown: { index: shown }, all: { index: everything } },
 }, ({ lookup }) => {
     const rows = lookup.shown();
     const entities: Entity[] = [];
@@ -63,7 +56,7 @@ const look = System.create({
 
 /** Whether the lookup through `shown` changed, with `color` watched. */
 let watchedChanged = false;
-const watchColor = System.create({ name: "indexKeylessTest/watchColor", lookup: { shown: { index: shown, changed: [weight] } } }, ({ lookup }) => {
+const watchColor = System.create({ lookup: { shown: { index: shown, changed: [weight] } } }, ({ lookup }) => {
     watchedChanged = lookup.shown().changed;
 });
 
@@ -75,7 +68,7 @@ const expected = async (world: CreatedWorld): Promise<{ readonly entities: reado
     all: [...await select(world, {})].sort(byIndex),
 });
 
-const spawn = System.create({ name: "indexKeylessTest/spawn", input: { type: "object", properties: { weights: { type: "array", items: { type: "number" } } } } }, ({ input, commands }) => {
+const spawn = System.create({}, ({ commands }, input: { readonly weights: readonly number[] }) => {
     for (const value of input.weights) commands.spawn([weight, color])({ [weight]: value, [color]: 0 });
 });
 
@@ -121,7 +114,7 @@ describe("an index without a key on the main thread", () => {
         await world.run(look);
         expect(seen.changed).toBe(false);
         // A write to what it holds by, unwatched, or to anything else, changes nothing.
-        await world.run(System.create({ components: { write: [weight, color] } }, row => {
+        await world.run(System.create({ components: { with: [weight, color] } }, row => {
             row[weight] = row[weight] + 1;
             row[color] = 2;
         }));
@@ -142,10 +135,10 @@ describe("an index without a key on the main thread", () => {
         await world.run(watchColor);
         await world.run(watchColor);
         expect(watchedChanged).toBe(false);
-        await world.run(System.create({ components: { write: [color] } }, row => { row[color] = 5; }));
+        await world.run(System.create({ components: { with: [color] } }, row => { row[color] = 5; }));
         await world.run(watchColor);
         expect(watchedChanged).toBe(false);
-        await world.run(System.create({ components: { write: [weight] } }, row => { row[weight] = 5; }));
+        await world.run(System.create({ components: { with: [weight] } }, row => { row[weight] = 5; }));
         await world.run(watchColor);
         expect(watchedChanged).toBe(true);
         await world.run(watchColor);
@@ -158,7 +151,7 @@ describe("an index without a key on the main thread", () => {
         // Moving the first to another archetype puts it last in storage order.
         await world.run(System.create(({ commands }) => { commands.add(entities[0], spin, 1); }));
         const order: Entity[] = [];
-        await world.run(System.create({ components: { read: [weight] }, order: inOrder }, row => { if (row[weight] > 0) order.push(row.entity); }));
+        await world.run(System.create({ components: { with: [weight] }, order: inOrder }, row => { if (row[weight] > 0) order.push(row.entity); }));
         expect(order).toEqual(entities);
     });
 });
@@ -209,9 +202,9 @@ describe("an incrementally refreshed index without a key", () => {
 
 /** Each row's tally of the rows of `shown`: how many, and the sum of a window of their weights. */
 const tally = System.create({
-    name: "indexKeylessTest/tally", kernel: "cpu",
-    components: { read: [color], write: [total, count] },
-    lookup: { shown: { index: shown, read: [weight] } },
+    kernel: true,
+    components: { with: [color, total, count] },
+    lookup: { shown: { index: shown } },
 }, (row, { lookup }) => {
     const rows = lookup.shown();
     let sum = 0;
@@ -219,7 +212,7 @@ const tally = System.create({
     row[total] = sum;
     row[count] = rows.length;
 });
-const tallyByHand = System.create({ name: "indexKeylessTest/tallyByHand", components: { read: [color], write: [total, count] }, lookup: { shown: { index: shown, read: [weight] } } }, (row, { lookup }) => {
+const tallyByHand = System.create({ components: { with: [color, total, count] }, lookup: { shown: { index: shown } } }, (row, { lookup }) => {
     const rows = lookup.shown();
     let sum = 0;
     for (let i = row[color] % 7; i < rows.length; i += 7) sum += rows.at(i)[weight];
@@ -228,8 +221,8 @@ const tallyByHand = System.create({ name: "indexKeylessTest/tallyByHand", compon
 });
 /** Counts runs whose list changed, `weight` watched. */
 const visit = System.create({
-    name: "indexKeylessTest/visit", kernel: "cpu",
-    components: { write: [visited] },
+    kernel: true,
+    components: { with: [visited] },
     lookup: { shown: { index: shown, changed: [weight] } },
 }, (row, { lookup }) => {
     if (lookup.shown().changed) row[visited] = row[visited] + 1;
@@ -238,7 +231,7 @@ const visit = System.create({
 const values = async (world: CreatedWorld, keys: readonly Component.Key[]): Promise<readonly unknown[]> => {
     let found: readonly unknown[] = [];
     const entities = [...await select(world, { required: [total] })].sort(byIndex);
-    await world.run(System.create({ lookup: { of: { read: [total, count, visited] } } }, ({ lookup }) => {
+    await world.run(System.create({ lookup: { of: { with: [total, count, visited] } } }, ({ lookup }) => {
         found = entities.map(entity => {
             const row = lookup.of(entity);
             return row === null ? null : keys.map(key => key === total ? row[total] : key === count ? row[count] : row[visited]);
@@ -254,7 +247,7 @@ describe.each([[true], [false]])("kernels looking up through an index without a
             for (let k = 0; k < 300; k++) commands.spawn([weight, color, total, count, visited])({ [weight]: k % 11, [color]: k, [total]: 0, [count]: 0, [visited]: 0 });
             for (let k = 0; k < 40; k++) commands.spawn([color, total, count, visited])({ [color]: k, [total]: 0, [count]: 0, [visited]: 0 });
         }));
-        await world.run(System.create({ components: { read: [color] } }, (row, { commands }) => {
+        await world.run(System.create({ components: { with: [color] } }, (row, { commands }) => {
             if (row[color] % 5 === 0) commands.add(row.entity, hidden);
             if (row[color] % 9 === 0) commands.despawn(row.entity);
         }));
@@ -268,10 +261,10 @@ describe.each([[true], [false]])("kernels looking up through an index without a
         const visits = async (): Promise<number> => (await values(world, [visited])).reduce<number>((sum, row) => sum + (Array.isArray(row) ? Number(row[0]) : 0), 0);
         const rows = (await values(world, [visited])).length;
         expect(await visits()).toBe(rows);
-        await world.run(System.create({ components: { write: [color] } }, row => { row[color] = row[color] + 1; }));
+        await world.run(System.create({ components: { with: [color] } }, row => { row[color] = row[color] + 1; }));
         await world.run(visit);
         expect(await visits()).toBe(rows);
-        await world.run(System.create({ components: { write: [weight] } }, row => { row[weight] = row[weight] + 1; }));
+        await world.run(System.create({ components: { with: [weight] } }, row => { row[weight] = row[weight] + 1; }));
         await world.run(visit);
         expect(await visits()).toBe(2 * rows);
     });

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { declarationOf } from '../../interface/registry/index.js';
 import { layoutOf, type Layout, type Leaf, type Scalar } from '../../interface/registry/layout.js';
 import type { Storage } from './archetype.js';

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

@@ -1,22 +1,21 @@
+// © 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";
 
 const spot = Symbol("indexLookupsCspTest/spot");
 const size = Symbol("indexLookupsCspTest/size");
 declare module "@adobe/ecs" {
     interface Components {
-        [spot]: { type: readonly [number, number] };
+        [spot]: { type: Vec2.I32 };
         [size]: { type: number };
     }
 }
-Component.register(spot, { type: { type: "array", items: { type: "integer", minimum: -100, maximum: 100 }, minItems: 2, maxItems: 2 } });
-Component.register(size, { type: { type: "number" } });
 
-const bySpot = Index.create({ key: [spot], components: { has: [size] } });
+const bySpot = Index.create({ key: [spot], components: { with: [size] } });
 const bySize = Index.create({ key: [size], sorted: true, unique: true });
 
 describe("index lookups where code can't be generated", () => {
@@ -30,7 +29,7 @@ describe("index lookups where code can't be generated", () => {
                 for (let k = 0; k < 6; k++) commands.spawn([spot, size])({ [spot]: [k % 2, 0], [size]: k });
             }));
             let found: number[] = [];
-            await world.run(System.create({ lookup: { at: { index: bySpot, read: [size] }, sized: { index: bySize, read: [size] } } }, ({ lookup }) => {
+            await world.run(System.create({ lookup: { at: { index: bySpot }, sized: { index: bySize } } }, ({ lookup }) => {
                 const list = lookup.at([1, 0]);
                 const range = lookup.sized({ ">": 1, "<=": 4 });
                 found = [...Array.from({ length: list.length }, (_, i) => list.at(i)[size]), -1, ...Array.from({ length: range.length }, (_, i) => range.at(i)[size]), -1, lookup.sized(5)?.[size] ?? -2];

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

@@ -1,6 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Scalar } from '../../interface/registry/layout.js';
 import { encodeScalar, encodeValue, hashWords, orderF32, orderF64, partWords, type KeyPart } from './index-keys.js';
-import { entryWords, findBucket, lengthOf, recordKey, recordLength, recordStart, startOf, type HashView } from './index-hash.js';
+import { entryWords, findBucket, isHashTable, lengthOf, recordKey, recordLength, recordStart, sortBucket, startOf, type HashView } from './index-hash.js';
 import { blockAt, blockBase, bound, firstPosition, treeMaximum, type SortedView } from './index-sorted.js';
 import { sharedRows, type Row, type RowArchetype, type RowHost } from './rows.js';
 import { idOf, type Key, type State } from './state.js';
@@ -40,10 +41,10 @@ export type IndexLookup = {
     readonly watched: readonly number[];
     readonly since: Since;
     /**
-     * How many times the world's archetypes' arrays were replaced, while which rows bound to them stay current: on the
-     * world's thread. Null on a joined thread, whose rows check their archetype's version each time.
+     * How many times archetypes' arrays were replaced, while which rows bound to them stay current: the world's count on
+     * its thread; on a joined thread, its directory's, moved on once a run finds any archetype's views changed.
      */
-    readonly replaced: { readonly count: number } | null;
+    readonly replaced: { readonly count: number };
 };
 
 /** The lookup behind each function bodies are given, for the plugin's call sites. */
@@ -58,6 +59,8 @@ type Pool = {
     readonly rows: (Row | undefined)[];
     readonly archetypes: number[];
     readonly versions: number[];
+    /** By position: the archetype it was bound to, since a joined thread's view of one is made again when it changes. */
+    readonly bound: (LookupArchetype | undefined)[];
     readonly make: (archetype: RowArchetype) => Row;
     /** The lookup's `replaced` count when every row was last checked against its archetype's version. */
     replaced: number;
@@ -71,7 +74,7 @@ const makers = new WeakMap<IndexLookup, (archetype: RowArchetype) => Row>();
 const poolOf = (lookup: IndexLookup): Pool => {
     let make = makers.get(lookup);
     if (make === undefined) makers.set(lookup, make = sharedRows(lookup.rows, lookup.reads, lookup.readIds));
-    return { rows: [], archetypes: [], versions: [], make, replaced: lookup.replaced?.count ?? 0, ahead: 0 };
+    return { rows: [], archetypes: [], versions: [], bound: [], make, replaced: lookup.replaced.count, ahead: 0 };
 };
 
 /** Binds row `n` of a pool to an archetype, making it first if the pool has none there yet. */
@@ -82,12 +85,14 @@ const bindRow = (pool: Pool, n: number, archetypeId: number, archetype: LookupAr
         rows.push(undefined);
         pool.archetypes.push(-1);
         pool.versions.push(-1);
+        pool.bound.push(undefined);
     }
     let found = rows[n];
     if (found === undefined) found = rows[n] = pool.make(archetype);
     else found.bind(archetype);
     pool.archetypes[n] = archetypeId;
     pool.versions[n] = archetype.version;
+    pool.bound[n] = archetype;
     return found;
 };
 
@@ -100,18 +105,22 @@ const madeAhead = 256;
  * body inlines.
  */
 const growPool = (lookup: IndexLookup, pool: Pool, length: number, archetypeId: number): void => {
-    pool.ahead = length;
+    // A first entry that's an unsorted bucket's hole, archetype -1, names none: a later lookup makes them.
     const archetype = lookup.archetypeAt(archetypeId);
     if (archetype === undefined) return;
+    pool.ahead = length;
     const end = Math.min(length, madeAhead);
     for (let n = pool.rows.length; n < end; n++) bindRow(pool, n, archetypeId, archetype);
 };
 
-/** Binds again the rows whose archetype's arrays were replaced since the pool last checked, on the world's thread. */
+/** Whether row `n` of a pool is bound to an archetype as it is now: the same view, its arrays not replaced since. */
+const boundTo = (pool: Pool, n: number, archetype: LookupArchetype): boolean => pool.bound[n] === archetype && pool.versions[n] === archetype.version;
+
+/** Binds again the rows whose archetype's arrays were replaced since the pool last checked. */
 const refreshPool = (lookup: IndexLookup, pool: Pool, replaced: { readonly count: number }): void => {
     for (let n = 0; n < pool.rows.length; n++) {
         const archetype = pool.rows[n] === undefined ? undefined : lookup.archetypeAt(pool.archetypes[n]);
-        if (archetype !== undefined && archetype.version !== pool.versions[n]) bindRow(pool, n, pool.archetypes[n], archetype);
+        if (archetype !== undefined && !boundTo(pool, n, archetype)) bindRow(pool, n, pool.archetypes[n], archetype);
     }
     pool.replaced = replaced.count;
 };
@@ -119,27 +128,22 @@ const refreshPool = (lookup: IndexLookup, pool: Pool, replaced: { readonly count
 /** Binds row `n` again to an entry's archetype, or makes it, when its archetype or that's arrays changed. */
 const reboundAt = (lookup: IndexLookup, pool: Pool, n: number, archetypeId: number, row: number): object | undefined => {
     const { replaced } = lookup;
-    if (replaced !== null && pool.replaced !== replaced.count) refreshPool(lookup, pool, replaced);
+    if (pool.replaced !== replaced.count) refreshPool(lookup, pool, replaced);
     const archetype = lookup.archetypeAt(archetypeId);
     if (archetype === undefined) return undefined;
     const current = pool.rows[n];
-    const found = current !== undefined && pool.archetypes[n] === archetypeId && pool.versions[n] === archetype.version ? current : bindRow(pool, n, archetypeId, archetype);
+    const found = current !== undefined && pool.archetypes[n] === archetypeId && boundTo(pool, n, archetype) ? current : bindRow(pool, n, archetypeId, archetype);
     found.index = row;
     return found.value;
 };
 
-/** Whether row `n` of a pool is bound to its archetype's current arrays, on a joined thread. */
-const currentVersion = (lookup: IndexLookup, pool: Pool, n: number, archetypeId: number): boolean =>
-    pool.versions[n] === lookup.archetypeAt(archetypeId)?.version;
-
 /**
- * Points row `n` of a pool at an entry's archetype and row, binding it again only when its archetype or that's arrays
- * changed: on the world's thread, when any archetype's were replaced since the pool last checked.
+ * Points row `n` of a pool at an entry's archetype and row, binding it again only when its archetype changed, or any
+ * archetype's arrays were replaced since the pool last checked.
  */
 const rowAt = (lookup: IndexLookup, pool: Pool, n: number, archetypeId: number, row: number): object | undefined => {
     const found = pool.rows[n];
-    const { replaced } = lookup;
-    if (found === undefined || pool.archetypes[n] !== archetypeId || (replaced === null ? !currentVersion(lookup, pool, n, archetypeId) : pool.replaced !== replaced.count)) return reboundAt(lookup, pool, n, archetypeId, row);
+    if (found === undefined || pool.archetypes[n] !== archetypeId || pool.replaced !== lookup.replaced.count) return reboundAt(lookup, pool, n, archetypeId, row);
     found.index = row;
     return found.value;
 };
@@ -191,6 +195,8 @@ const hashAt = function (this: HashList, position: number): object | undefined {
     const { bucket, hash } = found;
     const record = bucket * hash.stride;
     if (bucket < 0 || !(position >= 0 && position < hash.records[record + recordLength])) return undefined;
+    // On the world's thread, a bucket a change left unsorted is sorted by the first read by position.
+    if (hash.unsorted !== 0 && isHashTable(hash) && hash.tails[bucket] >= 0) sortBucket(hash, bucket);
     const at = (hash.records[record + recordStart] + position) * entryWords;
     return rowAt(found.lookup, found.pool, position, hash.entries[at + 1], hash.entries[at + 2]);
 };
@@ -307,8 +313,8 @@ const generatedFind = (lookup: IndexLookup, hash: HashView, shape: Shape, list:
         ...lookup.unique ? [
             `if (bucket < 0 || records[bucket * ${hash.stride} + ${recordLength}] === 0) return null;`,
             `const at = records[bucket * ${hash.stride} + ${recordStart}] * ${entryWords};`,
-            "const archetypeId = table.entries[at + 1], archetype = archetypeAt(archetypeId), row = pool.rows[0];",
-            "if (row === undefined || archetype === undefined || pool.archetypes[0] !== archetypeId || pool.versions[0] !== archetype.version) return rowAt(lookup, pool, 0, archetypeId, table.entries[at + 2]);",
+            "const archetypeId = table.entries[at + 1], row = pool.rows[0];",
+            "if (row === undefined || pool.archetypes[0] !== archetypeId || pool.replaced !== replaced.count) return rowAt(lookup, pool, 0, archetypeId, table.entries[at + 2]);",
             "row.index = table.entries[at + 2];",
             "return row.value;",
         ] : [
@@ -319,9 +325,9 @@ const generatedFind = (lookup: IndexLookup, hash: HashView, shape: Shape, list:
         "};",
     ].join("\n");
     try {
-        const factory = new Function("key", "table", "found", "list", "pool", "lookup", "rowAt", "growPool", "encodeValue", "parts", "orderF32", "orderF64", "f32", "f64", "u32", "u8", "archetypeAt", body);
+        const factory = new Function("key", "table", "found", "list", "pool", "lookup", "rowAt", "growPool", "encodeValue", "parts", "orderF32", "orderF64", "f32", "f64", "u32", "u8", "replaced", body);
         // The factory returns the function its body above makes.
-        const made: (...values: unknown[]) => unknown = factory(new Uint32Array(Math.max(1, words)), hash, found, list, found.pool, lookup, rowAt, growPool, encodeValue, index.parts, orderF32, orderF64, f32, f64, u32, u8, lookup.archetypeAt);
+        const made: (...values: unknown[]) => unknown = factory(new Uint32Array(Math.max(1, words)), hash, found, list, found.pool, lookup, rowAt, growPool, encodeValue, index.parts, orderF32, orderF64, f32, f64, u32, u8, lookup.replaced);
         return made;
     }
     catch {

package/src/implementation/world/index-order.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 { Index } from "../../interface/indexes/index-type.js";
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
@@ -8,6 +8,7 @@ import { workers } from "../../interface/resources/workers.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld, type CreatedWorld } from "./create.js";
 import { backToBack } from "./loop.js";
+import type { U32 } from "../../interface/math/index.js";
 
 const rank = Symbol("indexOrderTest/rank");
 const lane = Symbol("indexOrderTest/lane");
@@ -18,45 +19,40 @@ const marker = Symbol("indexOrderTest/marker");
 declare module "@adobe/ecs" {
     interface Components {
         [rank]: { type: number };
-        [lane]: { type: number };
+        [lane]: { type: U32 };
         [weight]: { type: number };
         [extra]: { type: true };
         [marker]: { type: number };
     }
 }
-Component.register(rank, { type: { type: "number" } });
-Component.register(lane, { type: { type: "integer", minimum: 0, maximum: 100 } });
-Component.register(weight, { type: { type: "number" } });
-Component.register(extra, { type: { const: true } });
-Component.register(marker, { type: { type: "number" } });
 
 /** By lane, then rank, of the entities that have a weight. */
-const ranked = Index.create({ name: "indexOrderTest/ranked", key: [lane, rank], sorted: true, components: { has: [weight] } });
+const ranked = Index.create({ key: [lane, rank], sorted: true, components: { with: [weight] } });
 
 /** Each row's lane and rank as one number, in the order rows ran. */
 let order: number[] = [];
-const visit = System.create({ name: "indexOrderTest/visit", components: { read: [lane, rank] }, order: ranked }, row => {
+const visit = System.create({ components: { with: [lane, rank] }, order: ranked }, row => {
     order.push(row[lane] * 1000 + row[rank]);
 });
-const visitChanged = System.create({ name: "indexOrderTest/visitChanged", components: { read: [lane, rank], changed: [weight] }, order: ranked }, row => {
+const visitChanged = System.create({ components: { with: [lane, rank], changed: [weight] }, order: ranked }, row => {
     order.push(row[lane] * 1000 + row[rank]);
 });
 /** A kernel spawning a marker for each row in turn, so the markers' entities, in order, are the rows' order. */
-const markEach = System.create({ name: "indexOrderTest/markEach", kernel: "cpu", components: { read: [lane, rank] }, order: ranked }, (row, { commands }) => {
+const markEach = System.create({ kernel: true, components: { with: [lane, rank] }, order: ranked }, (row, { commands }) => {
     commands.spawn([marker])({ [marker]: row[lane] * 1000 + row[rank] });
 });
-const markChanged = System.create({ name: "indexOrderTest/markChanged", kernel: "cpu", components: { read: [lane, rank], changed: [weight] }, order: ranked }, (row, { commands }) => {
+const markChanged = System.create({ kernel: true, components: { with: [lane, rank], changed: [weight] }, order: ranked }, (row, { commands }) => {
     commands.spawn([marker])({ [marker]: row[lane] * 1000 + row[rank] });
 });
-const keepTicking = System.create({ name: "indexOrderTest/keepTicking" }, () => {});
+const keepTicking = System.create({}, () => {});
 
 /** Changes the weight of every row whose weight ends in 3, a tenth of them. */
-const nudge = System.create({ name: "indexOrderTest/nudge", components: { write: [weight] } }, row => {
+const nudge = System.create({ components: { with: [weight] } }, row => {
     if (row[weight] % 10 === 3) row[weight] = row[weight] + 1;
 });
 
 /** Entities in two archetypes, interleaved in the index's order, some without the weight the index requires. */
-const seed = System.create({ name: "indexOrderTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let k = 0; k < input.count; k++) {
         const values = { [lane]: k % 3, [rank]: (k * 37) % 101, [weight]: k };
         if (k % 5 === 4) commands.spawn([lane, rank])({ [lane]: k % 3, [rank]: (k * 37) % 101 });
@@ -76,7 +72,7 @@ const expected = async (world: CreatedWorld, only?: (weighed: number) => boolean
 };
 
 const markerValues: number[] = [];
-const readMarkers = System.create({ name: "indexOrderTest/readMarkers", observer: true, components: { read: [marker] } }, row => { markerValues.push(row[marker]); });
+const readMarkers = System.create({ observer: true, components: { with: [marker] } }, row => { markerValues.push(row[marker]); });
 
 /** Markers' values in the order they were spawned: their archetype's rows', in storage order. */
 const markers = async (world: CreatedWorld): Promise<number[]> => {
@@ -104,7 +100,7 @@ describe("systems ordering their rows by a sorted index", () => {
         expect(order).toEqual(await expected(world, weighed => weighed % 10 === 4));
         expect(order.length).toBeGreaterThan(100);
         // Most rows change: the index is scanned rather than the rows' positions sorted.
-        await world.run(System.create({ components: { write: [weight] } }, row => { row[weight] = row[weight] + 2; }));
+        await world.run(System.create({ components: { with: [weight] } }, row => { row[weight] = row[weight] + 2; }));
         order = [];
         await world.run(visitChanged);
         expect(order).toEqual(await expected(world));

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Archetype } from './archetype.js';
 import { allocateArray, freeArray } from './arrays.js';
 import { blockAt, blockBase, firstPosition, type SortedTable } from './index-sorted.js';

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { TypedArray, View } from '../../interface/registry/layout.js';
 import { encodeScalar } from './index-keys.js';
 import type { WasmKeyValue, WasmProbe } from './wasm.js';

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { blockAt, blockBase, coverSortedEntities, createSortedTable, firstPosition, insertSorted, removeSorted, stampWatched, treeMaximum, watchSortedComponent, type SortedTable } from "./index-sorted.js";
 import { createMemory } from "./memory.js";

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { allocateArray, freeArray } from './arrays.js';
 import { compareObjects, type KeyPart } from './index-keys.js';
 import type { Memory } from './memory.js';
@@ -584,12 +585,16 @@ const split = (table: SortedTable, k: number, tick: number): void => {
     reindexFrom(table, k, table.blocks);
 };
 
-/** Updates where entity index `entity` is: its archetype and row, at its entry. */
-export const relocateSorted = (table: SortedTable, entity: number, archetype: number, row: number): void => {
+/** Updates where entity index `entity` is: its archetype and row, at its entry. Returns whether either changed. */
+export const relocateSorted = (table: SortedTable, entity: number, archetype: number, row: number): boolean => {
     const base = entryOf(table, entity);
-    if (base < 0) return;
-    table.entries[base + table.words + 1] = archetype;
-    table.entries[base + table.words + 2] = row;
+    if (base < 0) return false;
+    const at = base + table.words;
+    const { entries } = table;
+    if (entries[at + 1] === archetype && entries[at + 2] === row) return false;
+    entries[at + 1] = archetype;
+    entries[at + 2] = row;
+    return true;
 };
 
 /**

package/src/implementation/world/index-workers.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-workers.fixture.js";
 
@@ -14,4 +15,13 @@ export const indexWorkersCases = (load: () => Promise<typeof Fixture>) => descri
         // Targets' tallies through the index without a key: its length in millions, then a stride of its weights.
         expect(three.rows.filter(row => /^\[\d+,-?\d+,\d{7,}\]$/.test(row)).length).toBeGreaterThan(900);
     });
+    it.each([[true], [false]])("read a hash index's long buckets in entity order after changes left them unsorted, WASM %s", async wasm => {
+        const fixture = await load();
+        for (const threads of [0, 3]) {
+            const orders = await fixture.bandOrders(threads, wasm);
+            expect(orders.kernel).toEqual(orders.byHand);
+            expect(orders.kernel.every(round => round[0] > 0)).toBe(true);
+            if (threads > 0) expect(orders.tasks).toBeGreaterThan(0);
+        }
+    });
 });