@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/attach-kernel.ts

@@ -1,6 +1,8 @@
-import { definitionOf, labelOfItem } from '../../interface/registry/index.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { definitionOf } from '../../interface/registry/index.js';
 import type { System } from '../../interface/system/system.js';
-import { checkKernel } from './check-kernel.js';
+import { unreadByKernel } from '../../interface/system/check.js';
+import { checkKernel, kernelMismatch } from './check-kernel.js';
 import type { KernelDescription } from './kernel.js';
 
 /** By the system `System.create` returned, so a lookup doesn't depend on which copy of the package defined it. */
@@ -9,13 +11,18 @@ const kernels = new WeakMap<System<unknown>, KernelDescription>();
 /**
  * The compiler's only hook into the runtime: wraps each kernel system's `System.create` call. Throws for a kernel that
  * doesn't match its declaration and schemas (`checkKernel`), and for a key that's a list, which a command names as one
- * component only where its build couldn't read the name's module.
+ * component only where its build couldn't read the name's module. A kernel the build only `tried`, for a system
+ * without a `kernel` flag, attaches only where it matches, and the system otherwise runs as written.
  */
-export const attachKernel = <S extends System<unknown>>(system: S, description: KernelDescription): S => {
-    for (const key of description.keys) {
-        if (Array.isArray(key)) throw new Error(`System "${labelOfItem(system)}" names a list of components where a command takes one component; its kernel's build couldn't read the list, so name it from a module the build reads, or as an array literal.`);
-    }
+export const attachKernel = <S extends System<unknown>>(system: S, description: KernelDescription, tried = false): S => {
+    const listed = description.keys.some(key => Array.isArray(key));
     const leaf = definitionOf(system);
+    if (tried) {
+        if (listed || leaf === undefined || leaf.kind === "composite" || unreadByKernel(leaf) !== null || kernelMismatch(leaf, description) !== null) return system;
+        kernels.set(system, description);
+        return system;
+    }
+    if (listed) throw new Error(`System "${system.name}" names a list of components where a command takes one component; its kernel's build couldn't read the list, so name it from a module the build reads, or as an array literal.`);
     if (leaf !== undefined && leaf.kind !== "composite") checkKernel(leaf, description);
     kernels.set(system, description);
     return system;

package/src/implementation/world/batches.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 type { Schema } from "../../interface/schema/schema.js";
 import { System } from "../../interface/system/system.js";
@@ -10,7 +10,8 @@ import { Observe } from "../../observe/index.js";
 import { createBuffer } from "./buffer.js";
 import { createCommands } from "./commands.js";
 import { createState } from "./state.js";
-import { runReported } from "./reports.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
+import type { F32 } from "../../interface/math/index.js";
 
 type Vec3 = readonly [number, number, number];
 const vec3 = { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } as const satisfies Schema;
@@ -20,29 +21,25 @@ const name = Symbol("batchesTest/name");
 const tag = Symbol("batchesTest/tag");
 declare module "@adobe/ecs" {
     export interface Components {
-        [position]: { type: readonly [number, number, number] };
-        [score]: { type: number };
+        [position]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
+        [score]: { type: F32 };
         [name]: { type: string };
         [tag]: { type: true };
     }
 }
-Component.register(position, { type: vec3 });
-Component.register(score, { type: { type: "number", precision: 1 } });
-Component.register(name, { type: { type: "string" } });
-Component.register(tag, { type: { const: true } });
 
 describe("staged spawns", () => {
     it("are seen once by `added` observers in earlier, the same and later tiers, and not before the sync point", async () => {
         const seen = { early: 0, same: 0, late: 0 };
         const spawned: Entity[] = [];
-        const early = System.create({ name: "batchesTest/early", components: { added: [score] } }, () => { seen.early++; });
-        const spawn = System.create({ name: "batchesTest/spawn", after: [early] }, ({ commands }) => {
+        const early = System.create({ components: { added: [score] } }, () => { seen.early++; });
+        const spawn = System.create({ after: [early] }, ({ commands }) => {
             if (spawned.length > 0) return;
             for (let i = 0; i < 100; i++) spawned.push(commands.spawn([position, score, name, tag])({ [position]: [i, i, i], [score]: i, [name]: `${i}`, [tag]: true }));
         });
-        const same = System.create({ name: "batchesTest/same", components: { added: [score] }, after: [early] }, () => { seen.same++; });
-        const late = System.create({ name: "batchesTest/late", components: { added: [score] }, after: [spawn, same] }, () => { seen.late++; });
-        const frame = System.create({ name: "batchesTest/edit", systems: [early, spawn, same, late] });
+        const same = System.create({ components: { added: [score] }, after: [early] }, () => { seen.same++; });
+        const late = System.create({ components: { added: [score] }, after: [spawn, same] }, () => { seen.late++; });
+        const frame = System.create({ systems: [early, spawn, same, late] });
         const world = createWorld({ [workers]: 0 });
         await world.run(frame);
         // Nothing saw the spawns during their own run.
@@ -57,7 +54,7 @@ describe("staged spawns", () => {
 
     it("can be changed, removed, re-added or despawned in the run that spawns them", async () => {
         const spawned: Entity[] = [];
-        const edit = System.create({ name: "batchesTest/edit/2" }, ({ commands }) => {
+        const edit = System.create({}, ({ commands }) => {
             for (let i = 0; i < 4; i++) spawned.push(commands.spawn([score, name])({ [score]: i, [name]: `${i}` }));
             commands.add(spawned[0], score, 10);
             commands.remove(spawned[1], name);
@@ -75,7 +72,7 @@ describe("staged spawns", () => {
     it("keep the spawns before a value that can't be written, and release that one's entity", async () => {
         const spawned: Entity[] = [];
         let poison = true;
-        const spawn = System.create({ name: "batchesTest/spawn/2" }, ({ commands }) => {
+        const spawn = System.create({}, ({ commands }) => {
             for (let i = 0; i < 3; i++) spawned.push(commands.spawn([position, score])({ [position]: [i, 0, 0], [score]: i }));
             // A symbol can't convert to a number, so writing it throws.
             if (poison) commands.spawn([position, score])({ [position]: [0, 0, 0], [score]: Symbol("x") as unknown as number });
@@ -92,7 +89,7 @@ describe("staged spawns", () => {
 
     it("take value objects built before the spawn", async () => {
         const spawned: Entity[] = [];
-        const spawn = System.create({ name: "batchesTest/spawn/4" }, ({ commands }) => {
+        const spawn = System.create({}, ({ commands }) => {
             for (let i = 0; i < 20; i++) {
                 const values = i % 2 === 0 ? { [position]: [i, 0, 1] as const, [score]: i, [name]: `${i}` } : { [score]: i, [position]: [i, 0, 1] as const, [name]: `${i}` };
                 spawned.push(commands.spawn([position, score, name])(values));
@@ -117,7 +114,7 @@ describe("spawns keyed by symbols", () => {
     });
     it("read only their components' values, as adds do", async () => {
         let spawned = Entity.none;
-        const edit = System.create({ name: "batchesTest/stringKeys" }, ({ commands }) => {
+        const edit = System.create({}, ({ commands }) => {
             const values = { [score]: 1, "batchesTest/score": 2, [name]: "a" };
             spawned = commands.spawn([score])(values);
             commands.add(spawned, [score], values);

package/src/implementation/world/batches.ts

@@ -1,7 +1,8 @@
-import { ensureCapacity, type Archetype } from './archetype.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { ensureCapacity, noShared, type Archetype } from './archetype.js';
 import type { CommandBuffer } from './buffer.js';
 import { indexOf } from './entities.js';
-import { chunkShift } from './kernel.js';
+import { blockShift, chunkShift } from './kernel.js';
 import { createBatch, type SpawnBatch } from './staging.js';
 import { archetypeOf, type State } from './state.js';
 import { gainsOf } from './structure.js';
@@ -10,30 +11,86 @@ import { countChanged } from './layout-directory.js';
 import { logRange, logSet, startTag, tagOf } from './move-log.js';
 import { writeDefault } from './synchronize.js';
 import { writeString } from './strings.js';
+import { cacheShared, internShared } from './shared.js';
 
 /** Batches of at most this many rows commit element by element. */
 const smallCopy = 8;
 
-/** The batch of main-thread spawns of exactly these components, made on first use. */
-export const batchOf = (state: State, ids: readonly number[]): SpawnBatch => {
-    const key = [...ids].sort((a, b) => a - b).join(",");
+/**
+ * The batch of main-thread spawns of exactly these components, with these shared values by component id, made on first
+ * use.
+ */
+export const batchOf = (state: State, ids: readonly number[], shared: readonly (number | undefined)[] = noShared): SpawnBatch => {
+    const sorted = [...ids].sort((a, b) => a - b);
+    const key = shared === noShared ? sorted.join(",") : keyOf(sorted, shared);
     let batch = state.batchByKey.get(key);
     if (batch === undefined) {
-        batch = createBatch(state.layouts, ids);
+        batch = createBatch(state.layouts, ids, shared);
         for (const column of batch.columns) if (state.remote[column.id] !== undefined) column.remote = remoteError(state, column.id).message;
         state.batchByKey.set(key, batch);
         state.batches.push(batch);
+        if (shared !== noShared) letGoWith(state, batch, key);
     }
     return batch;
 };
 
+/** A batch's key: its sorted component ids, each shared one with the number of its value. */
+const keyOf = (sorted: readonly number[], shared: readonly (number | undefined)[]): string =>
+    sorted.map(id => shared[id] === undefined ? `${id}` : `${id}=${shared[id]}`).join(",");
+
+/**
+ * Lets go of a batch of shared values, keyed `key`, once any of them is dropped, so batches don't pile up as values
+ * come and go. A spawner still holding it revives it as it next spawns: its values are interned again and it's listed
+ * once more, with numbers that may be new.
+ */
+const letGoWith = (state: State, batch: SpawnBatch, key: string): void => {
+    const held = batch.ids.flatMap(id => {
+        const number = batch.shared[id];
+        const values = state.shared[id];
+        return number === undefined || values === undefined ? [] : [{ id, values, value: values.values[number], number }];
+    });
+    const unregister: (() => void)[] = [];
+    const drop = (): void => {
+        for (const letGo of unregister) letGo();
+        if (state.batchByKey.get(key) === batch) state.batchByKey.delete(key);
+        const at = state.batches.indexOf(batch);
+        if (at >= 0) state.batches.splice(at, 1);
+        batch.archetype = null;
+        batch.capacity = batch.count;
+        batch.revive = () => {
+            const shared: (number | undefined)[] = [];
+            for (const { id, values, value } of held) shared[id] = internShared(values, value);
+            batch.shared = shared;
+            batch.capacity = batch.entities.length;
+            const again = keyOf(batch.ids, shared);
+            if (!state.batchByKey.has(again)) state.batchByKey.set(again, batch);
+            state.batches.push(batch);
+            letGoWith(state, batch, again);
+        };
+    };
+    for (const { values, number } of held) unregister.push(cacheShared(values, number, drop));
+};
+
+/**
+ * A batch's archetype, found the first time it commits, and again once it was reclaimed or reused for other values
+ * (`reclaim.ts`), which its generation tells.
+ */
+const archetypeOfBatch = (state: State, batch: SpawnBatch): Archetype => {
+    const known = batch.archetype;
+    if (known !== null && !known.reclaimed && known.generation === batch.generation) return known;
+    const archetype = archetypeOf(state, batch.ids, batch.shared);
+    batch.archetype = archetype;
+    batch.generation = archetype.generation;
+    return archetype;
+};
+
 /**
  * Copies rows `first` to `first + n` of a batch into its archetype, or into its closure under `close` when rules or
  * `within` apply, places their entities, writes the defaults of derived components the target gains, and stamps their
  * ticks with the sync point's tick, as a commanded spawn would be. `born` records the first row each target gains.
  */
 const commitRows = (state: State, batch: SpawnBatch, first: number, n: number, tick: number, born: Map<number, number>, close: ((archetype: Archetype) => Archetype) | null): void => {
-    const spawned = batch.archetype ?? (batch.archetype = archetypeOf(state, batch.ids));
+    const spawned = archetypeOfBatch(state, batch);
     const target = close === null ? spawned : close(spawned);
     ensureCapacity(state.memory, target, target.count + n);
     const start = target.count;
@@ -81,7 +138,9 @@ const commitRows = (state: State, batch: SpawnBatch, first: number, n: number, t
         if (!storage.ticked) continue;
         storage.added.fill(tick, start, start + n);
         if (storage.changed !== storage.added) storage.changed.fill(tick, start, start + n);
-        // Ticks only increase, so the newest tick in each chunk the rows reach is this one.
+        // Ticks only increase, so the newest tick in each chunk and block the rows reach is this one.
+        storage.blockAdded.fill(tick, start >> blockShift, ((start + n - 1) >> blockShift) + 1);
+        if (storage.blockChanged !== storage.blockAdded) storage.blockChanged.fill(tick, start >> blockShift, ((start + n - 1) >> blockShift) + 1);
         storage.chunkAdded.fill(tick, start >> chunkShift, ((start + n - 1) >> chunkShift) + 1);
         if (storage.chunkChanged !== storage.chunkAdded) storage.chunkChanged.fill(tick, start >> chunkShift, ((start + n - 1) >> chunkShift) + 1);
     }

package/src/implementation/world/buffer.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { viewsOf, type Layout, type Views } from '../../interface/registry/layout.js';
 import type { KernelCommands } from './kernel.js';
 import type { Positional, SpawnBatch } from './staging.js';
@@ -100,8 +101,13 @@ export const pushCommand = (buffer: CommandBuffer, kind: number, entity: number)
     buffer.count++;
 };
 
+/** Room for more component ids, outlined as `growCommands` is. */
+const growIds = (buffer: CommandBuffer): void => {
+    buffer.ids = grown(buffer.ids, length => new Int32Array(length));
+};
+
 export const pushComponent = (buffer: CommandBuffer, id: number, value: unknown): void => {
-    if (buffer.named === buffer.ids.length) buffer.ids = grown(buffer.ids, length => new Int32Array(length));
+    if (buffer.named === buffer.ids.length) growIds(buffer);
     buffer.ids[buffer.named] = id;
     buffer.values[buffer.named] = value;
     buffer.named++;
@@ -139,7 +145,32 @@ export const endOf = (buffer: CommandBuffer, command: number): number =>
  */
 export const createKernelCommands = (target: { readonly buffer: CommandBuffer }, ids: readonly number[], starts: readonly unknown[], spawners: readonly Positional[]): KernelCommands => ({
     spawners,
-    begin: (kind, entity) => pushCommand(target.buffer, kind, entity),
-    value: (key, value) => pushComponent(target.buffer, ids[key], value === undefined ? starts[key] : value),
-    component: key => pushComponent(target.buffer, ids[key], undefined),
+    // Each writes the buffer itself rather than through pushCommand and pushComponent: a kernel's row loop inlines one
+    // call, and a second one left as a call boxes every entity, which ids past 2^32 make a double.
+    begin: (kind, entity) => {
+        const buffer = target.buffer;
+        const count = buffer.count;
+        if (count === buffer.kinds.length) growCommands(buffer);
+        buffer.kinds[count] = kind;
+        buffer.shapes[count] = -1;
+        buffer.entities[count] = entity;
+        buffer.starts[count] = buffer.named;
+        buffer.count = count + 1;
+    },
+    value: (key, value) => {
+        const buffer = target.buffer;
+        const named = buffer.named;
+        if (named === buffer.ids.length) growIds(buffer);
+        buffer.ids[named] = ids[key];
+        buffer.values[named] = value === undefined ? starts[key] : value;
+        buffer.named = named + 1;
+    },
+    component: key => {
+        const buffer = target.buffer;
+        const named = buffer.named;
+        if (named === buffer.ids.length) growIds(buffer);
+        buffer.ids[named] = ids[key];
+        buffer.values[named] = undefined;
+        buffer.named = named + 1;
+    },
 });

package/src/implementation/world/builtins.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 { Mat4x4, Quat, Vec3 } from "../../interface/math/index.js";
 import { System } from "../../interface/system/system.js";
 import { readEach, select } from "./reads.test-helper.js";
@@ -22,13 +22,8 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(position, { type: Vec3.schema });
-Component.register(velocity, { type: Vec3.schema });
-Component.register(bits, { type: Vec3.U32.schema });
-Component.register(counts, { type: Vec3.U32.schema });
-Component.register(sums, { type: Vec3.I32.schema });
 
-const spawn = System.create({ name: "builtinsTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     for (let i = 0; i < 64; i++) commands.spawn([position, velocity])({ [position]: [i, i % 5, -i], [velocity]: [1, 0.5 * (i % 3), 0.25] });
 });
 
@@ -36,7 +31,7 @@ const rotation = Quat.fromAxisAngle([0, 1, 0], 0.5);
 const matrix = Mat4x4.multiply(Mat4x4.translation(1, 2, 3), Mat4x4.scaling(2, 2, 2));
 
 /** Rotates, transforms and offsets each position, with functions from three math namespaces inlined. */
-const transform = System.create({ name: "builtinsTest/transform", kernel: "cpu", components: { read: [velocity], write: [position] } }, row => {
+const transform = System.create({ kernel: true, components: { with: [velocity, position] } }, row => {
     const q = Quat.fromAxisAngle([0, 1, 0], 0.5);
     const m = Mat4x4.multiply(Mat4x4.translation(1, 2, 3), Mat4x4.scaling(2, 2, 2));
     row[position] = Vec3.add(Mat4x4.multiplyVec3(m, Quat.rotateVec3(q, row[position])), Vec3.normalize(row[velocity]));
@@ -47,7 +42,7 @@ const expected = (p: Vec3, v: Vec3): Vec3 => Vec3.add(Mat4x4.multiplyVec3(matrix
 const bitsAt = (i: number): Vec3.U32 => [Math.imul(i + 1, 0x9E3779B9) >>> 0, (0xFFFFFFFF - i) >>> 0, i << 26 >>> 0];
 const sumsAt = (i: number): Vec3.I32 => [2 ** 31 - 1 - i, -(2 ** 31) + i, Math.imul(i, 65536)];
 
-const spawnBits = System.create({ name: "builtinsTest/spawnBits" }, ({ commands }) => {
+const spawnBits = System.create({}, ({ commands }) => {
     for (let i = 0; i < 64; i++) commands.spawn([bits, counts, sums])({ [bits]: bitsAt(i), [counts]: [0, 0, 0], [sums]: sumsAt(i) });
 });
 
@@ -57,7 +52,7 @@ const integerResults = (b: Vec3.U32, s: Vec3.I32): { readonly counts: Vec3.U32;
     sums: Vec3.I32.add(Vec3.I32.multiply(s, [65536, 3, 65536]), Vec3.I32.abs(Vec3.I32.negate(s))),
 });
 
-const integers = System.create({ name: "builtinsTest/integers", kernel: "cpu", components: { read: [bits], write: [counts, sums] } }, row => {
+const integers = System.create({ kernel: true, components: { with: [bits, counts, sums] } }, row => {
     const b = row[bits];
     const s = row[sums];
     row[counts] = Vec3.U32.add(Vec3.U32.countOneBits(b), Vec3.U32.add(Vec3.U32.countTrailingZeros(b), Vec3.U32.multiply(Vec3.U32.reverseBits(b), b)));

package/src/implementation/world/cascade.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Archetype } from './archetype.js';
 import { readCell } from './cells.js';
 import { indexOf, locate } from './entities.js';
@@ -58,7 +59,7 @@ export const cascadeReferences = (state: State, queued: readonly Queued[], writt
             return;
         }
         const to = withoutComponent(state, archetypes[plan.to[entry]], component);
-        plan.to[entry] = closureOf(structure, state.derived, to, components => archetypeOf(state, components), archetypes).id;
+        plan.to[entry] = closureOf(structure, state.derived, to, (components, shared) => archetypeOf(state, components, shared), archetypes).id;
     };
     let checked = 0;
     for (let next = 0; next < despawned.length || checked < written.length;) {

package/src/implementation/world/cells.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Storage } from './archetype.js';
 import { readString, writeString } from './strings.js';
 

package/src/implementation/world/change-blocks.browser.test.ts

@@ -0,0 +1,76 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { Entity } from "../../interface/entity/entity.js";
+import { gpuDevice } from "../../interface/resources/gpu-device.js";
+import { workers } from "../../interface/resources/workers.js";
+import { System } from "../../interface/system/system.js";
+import { createWorld, join } from "./create.js";
+import type { F32, U32 } from "../../interface/math/index.js";
+import { gpu } from "./gpu.test-helper.js";
+
+// A GPU kernel stamps a whole column once; before a joined thread's systems filter on it, its rows, chunks and blocks
+// take the stamp, so the thread's change filters find every row, and then only rows written after.
+
+const value = Symbol("changeBlocksGpuTest/value");
+const at = Symbol("changeBlocksGpuTest/at");
+const note = Symbol("changeBlocksGpuTest/note");
+
+declare module "@adobe/ecs" {
+    interface Threads {
+        changeBlocksGpuTest: true;
+    }
+    interface Components {
+        [value]: { type: F32 };
+        [at]: { type: U32 };
+        [note]: { type: { readonly text: string } | null; thread: "changeBlocksGpuTest"; default: { text: "none" } };
+    }
+}
+const text = { type: "object", properties: { text: { type: "string" } } } as const;
+
+const rows = 4500;
+let entities: Entity[] = [];
+const seed = System.create({}, ({ commands }) => {
+    entities = [];
+    for (let i = 0; i < rows; i++) entities.push(commands.spawn([value, at, note])({ [value]: 0, [at]: i }));
+});
+const raise = System.create({ kernel: "gpu", components: { with: [value] } }, row => {
+    row[value] = row[value] + 1;
+});
+const setValue = System.create({ target: "entity", components: { with: [value] } }, (row, _context, input: { readonly entity: Entity }) => {
+    row[value] += 1;
+});
+let found: number[] = [];
+const there = System.create({ components: { with: [at, note], changed: [value] } }, row => { if (row[note] !== undefined) found.push(row[at]); });
+
+const device = async (): Promise<GPUDevice> => {
+    const adapter = await navigator.gpu.requestAdapter();
+    if (adapter === null) throw new Error("No WebGPU adapter.");
+    return adapter.requestDevice();
+};
+
+describe("chunk and block ticks after a GPU kernel's column stamp", () => {
+    it.runIf(gpu)("let a joined thread's filters find every row a GPU kernel wrote, then a row the CPU wrote", async () => {
+        const world = createWorld({ [workers]: 0, [gpuDevice]: await device() });
+        const channel = new MessageChannel();
+        const shared = world.share(channel.port1);
+        const remote = await join(channel.port2, { threads: ["changeBlocksGpuTest"] });
+        try {
+            await shared;
+            await world.run(seed);
+            await world.run(there);
+            await world.run(raise);
+            found = [];
+            await world.run(there);
+            expect(found.length).toBe(rows);
+            const row = 2 * 1024 + 5 * 64 + 9;
+            await world.run(setValue, { entity: entities[row] });
+            found = [];
+            await world.run(there);
+            expect(found).toEqual([row]);
+        }
+        finally {
+            await remote.dispose();
+            await world.dispose();
+        }
+    });
+});

package/src/implementation/world/change-blocks.cases.ts

@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import type * as Fixture from "./change-blocks.fixture.js";
+
+/** Chunk and block ticks on workers: the cases, over the fixture built for node or from source. */
+export const changeBlocksCases = (load: () => Promise<typeof Fixture>) => describe("chunk and block ticks on workers", () => {
+    for (const wasm of [false, true]) {
+        it(`let readers find the rows a kernel on workers wrote (${wasm ? "WASM" : "JS"} kernels)`, async () => {
+            const fixture = await load();
+            const expected = [5, 2048 + 5 * 64 + 9, 4499];
+            expect(await fixture.foundOnWorkers(wasm)).toEqual({ kernel: expected, main: expected });
+        });
+    }
+});

package/src/implementation/world/change-blocks.fixture.ts

@@ -0,0 +1,70 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { I32 } from "../../interface/math/i32/index.js";
+import { workers } from "../../interface/resources/workers.js";
+import { System } from "../../interface/system/system.js";
+import { readEach, select } from "./reads.test-helper.js";
+import { createWorld } from "./create.js";
+import type { U32 } from "../../interface/math/index.js";
+
+/** Scenarios of chunk and block ticks on workers, run built in node and from source in chromium. */
+
+const value = Symbol("changeBlocksWorkersTest/value");
+const at = Symbol("changeBlocksWorkersTest/at");
+const seen = Symbol("changeBlocksWorkersTest/seen");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [value]: { type: number };
+        [at]: { type: U32 };
+        [seen]: { type: number };
+    }
+}
+
+
+const rows = 4500;
+
+const seed = System.create({}, ({ commands }) => {
+    for (let i = 0; i < rows; i++) commands.spawn([value, at, seen])({ [value]: 0, [at]: i, [seen]: 0 });
+});
+
+/** Writes the rows whose `at` is one of three, stamping row by row. */
+const writeSome = System.create({ kernel: true, components: { with: [at, value] } }, (row, _context, input: { readonly a: I32; readonly b: I32; readonly c: I32 }) => {
+    const here = row[at];
+    if (here === input.a || here === input.b || here === input.c) row[value] += 1;
+});
+
+/** Counts each run of the rows whose value changed. */
+const watch = System.create({ kernel: true, components: { with: [seen], changed: [value] } }, row => {
+    row[seen] += 1;
+});
+
+let found: number[] = [];
+const onMain = System.create({ components: { with: [at], changed: [value] } }, row => { found.push(row[at]); });
+
+/**
+ * The rows a kernel on workers and a system on the world's thread find after a kernel on workers wrote three rows far
+ * apart: in the first block, a middle block of a middle chunk, and the last row.
+ */
+export const foundOnWorkers = async (wasm: boolean): Promise<{ readonly kernel: readonly number[]; readonly main: readonly number[] }> => {
+    const world = createWorld({ [workers]: 2 }, { wasm, minimumChunk: 64 });
+    try {
+        await world.run(seed);
+        await world.run(watch);
+        await world.run(onMain);
+        const all = await select(world, { required: [seen] });
+        const before = await readEach(world, all, seen);
+        await world.run(writeSome, { a: 5, b: 2048 + 5 * 64 + 9, c: rows - 1 });
+        await world.run(watch);
+        found = [];
+        await world.run(onMain);
+        const after = await readEach(world, all, seen);
+        const ats = await readEach(world, all, at);
+        return {
+            kernel: all.flatMap((_, k) => after[k] !== before[k] ? [ats[k] ?? -1] : []).sort((a, b) => a - b),
+            main: [...found].sort((a, b) => a - b),
+        };
+    }
+    finally {
+        await world.dispose();
+    }
+};